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

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.js","names":[],"sources":["../../../../../zql/src/ivm/aggregate.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {assignProperty} from '../../../shared/src/objects.ts';\nimport {\n  aggregateValue,\n  type AggregateFunction,\n  type Ordering,\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 {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {makeEditChange, type Change} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport {\n  compareValues,\n  makeComparator,\n  normalizeUndefined,\n  valueToKey,\n  type Node,\n  type NormalizedValue,\n} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n  type Storage,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {SourceInput} from './source.ts';\nimport {type Stream} from './stream.ts';\n\n/**\n * The name of the synthetic column that holds the aggregate result in the rows\n * this operator emits. The value is projected to a bare scalar in the view, so\n * this name is internal.\n *\n * The synthetic columns share the emitted row with the group key, whose names\n * come from the user's schema, so they use the reserved `_0_` prefix (as\n * `_0_version` does) rather than plain words a schema could also use.\n */\nexport const AGGREGATE_VALUE_COLUMN = '_0_value';\n\n/**\n * A top-level (ungrouped) aggregate has no group key, but the synced path keys\n * every row in the CVR and forbids empty row keys (see zero-cache\n * `types/row-key.ts`). Since there is no group key, the single global row is\n * given one synthetic, constant-valued key column so it still has a (non-empty)\n * primary key. The materialized-view path ignores it (it projects only\n * `AGGREGATE_VALUE_COLUMN`), so this name is internal.\n *\n * The row holds nothing but this column and the payload columns, so any name\n * other than theirs (and `_0_version`) is collision-free. It must not be empty:\n * a SQLite-backed source cannot declare a zero-length column name.\n */\nexport const AGGREGATE_KEY_COLUMN = '_0_key';\n\n/** The constant value of {@link AGGREGATE_KEY_COLUMN} (one global row). */\nconst AGGREGATE_KEY_VALUE = 0;\n\n/**\n * `sum` and `avg` additionally carry their running components so the synced\n * client can adjust them optimistically: you can't move an average from the\n * final value alone, and a sum's value alone can't tell an empty group (`null`)\n * from one summing to 0. The value column stays the result (for display); these are the\n * sum of non-null field values and the count of non-null contributors.\n */\nexport const AGGREGATE_SUM_COLUMN = '_0_sum';\nexport const AGGREGATE_COUNT_COLUMN = '_0_count';\n\n/**\n * A grouped `sum`/`avg` row also carries its group's number of rows, nulls\n * included, which neither component gives: the synced client adds a group with\n * its first row and removes it with its last, as it does a count's.\n */\nexport const AGGREGATE_ROWS_COLUMN = '_0_rows';\n\n/**\n * Whether `col` is the name of a synthetic column of an aggregate or grouped\n * row: `_0_key` or a payload column.\n */\nexport function isSyntheticColumn(col: string): boolean {\n  return col === AGGREGATE_KEY_COLUMN || AGGREGATE_PAYLOAD_COLUMNS.has(col);\n}\n\n/**\n * Asserts that the group key column `col` of an aggregate, or a column of a\n * grouped query, is not a synthetic column. The synthetic columns are written over\n * the group's columns in the emitted row, the payload is stripped from it by\n * the client's row key and `_0_key` alone keys a row that has it, so a\n * collision would silently merge or corrupt the groups. Their reserved `_0_`\n * prefix keeps real schemas clear of this; the check guards the invariant.\n */\nexport function assertNotSyntheticColumn(col: string): void {\n  assert(\n    !isSyntheticColumn(col),\n    () =>\n      `Aggregate: group key column \"${col}\" collides with the synthetic ` +\n      `aggregate column of the same name`,\n  );\n}\n\n/** Whether `fn`'s rows carry the sum and count components. */\nexport function carriesComponents(fn: AggregateFunction): boolean {\n  return fn === 'sum' || fn === 'avg';\n}\n\n/** The synthetic payload columns (not part of an aggregate row's key). */\nexport const AGGREGATE_PAYLOAD_COLUMNS: ReadonlySet<string> = new Set([\n  AGGREGATE_VALUE_COLUMN,\n  AGGREGATE_SUM_COLUMN,\n  AGGREGATE_COUNT_COLUMN,\n  AGGREGATE_ROWS_COLUMN,\n]);\n\n/**\n * The type of the synthetic value column for an aggregate result: `count` is a\n * non-null number; `sum`/`avg` are nullable numbers; `min`/`max` take the\n * field's own type (`json` for a JSON path, whose leaf can be a number or a\n * string) and are nullable (empty group).\n */\nfunction aggregateValueColumn(\n  fn: AggregateFunction,\n  field: string | undefined,\n  inputColumns: Record<string, SchemaValue>,\n  path: readonly (string | number)[] | undefined,\n): SchemaValue {\n  switch (fn) {\n    case 'count':\n      return {type: 'number'};\n    case 'sum':\n    case 'avg':\n      return {type: 'number', optional: true};\n    case 'min':\n    case 'max': {\n      if (path !== undefined) {\n        // A JSON leaf: a number or a string, decided per value.\n        return {type: 'json', optional: true};\n      }\n      const fieldSchema = inputColumns[must(field)];\n      assert(fieldSchema, () => `Aggregate: ${fn} field \"${field}\" missing`);\n      return {...fieldSchema, optional: true};\n    }\n    default:\n      unreachable(fn);\n  }\n}\n\n/**\n * The synthetic schema (columns + primary key) an aggregate produces, derived\n * from the *input* columns (the rows being aggregated), the group key, and the\n * fn/field. Shared by the {@link Aggregate} operator (compute mode) and the\n * client query builder (`aggregatesFromSource` mode) so both agree on the\n * synthetic source's shape. For a top-level (empty group key) aggregate the\n * single synthetic key column is added; otherwise the group key is the key.\n */\nexport function aggregateSourceSchema(\n  inputColumns: Record<string, SchemaValue>,\n  groupKey: readonly string[],\n  fn: AggregateFunction,\n  field: string | undefined,\n  path?: readonly (string | number)[] | undefined,\n): {columns: Record<string, SchemaValue>; primaryKey: readonly string[]} {\n  const columns: Record<string, SchemaValue> = {};\n  for (const col of groupKey) {\n    assertNotSyntheticColumn(col);\n    const colSchema = inputColumns[col];\n    assert(colSchema, () => `Aggregate: group key column \"${col}\" missing`);\n    assignProperty(columns, col, colSchema);\n  }\n  const keyColumns = groupKey.length > 0 ? groupKey : [AGGREGATE_KEY_COLUMN];\n  if (groupKey.length === 0) {\n    columns[AGGREGATE_KEY_COLUMN] = {type: 'number'};\n  }\n  columns[AGGREGATE_VALUE_COLUMN] = aggregateValueColumn(\n    fn,\n    field,\n    inputColumns,\n    path,\n  );\n  if (carriesComponents(fn)) {\n    // Components for optimistic adjustment on the synced client.\n    columns[AGGREGATE_SUM_COLUMN] = {type: 'number'};\n    columns[AGGREGATE_COUNT_COLUMN] = {type: 'number'};\n  }\n  return {columns, primaryKey: keyColumns};\n}\n\n/**\n * Per-group running state. We keep enough to derive any supported function:\n *  - `count`    → count(*)                (all rows)\n *  - `sum`      → sum of non-null         (NULL when nonNull === 0)\n *  - `avg`      → sum / nonNull           (NULL when nonNull === 0)\n *  - `min`/`max`→ extreme of non-null     (NULL when nonNull === 0)\n */\nexport type AggState = {\n  count: number;\n  sum: number;\n  nonNull: number;\n  /** Current min/max of the non-null field values (null when nonNull === 0). */\n  extreme: NormalizedValue;\n};\n\n/**\n * Typed view of the operator's {@link Storage} (mirrors Take): a group's state\n * by its key. Shared with `GroupBy`.\n */\nexport interface AggStorage {\n  get(key: string): AggState | undefined;\n  set(key: string, value: AggState): void;\n  del(key: string): void;\n  destroy(): void;\n}\n\n/**\n * Whether a change to one input row maps to a fixed delta of the aggregate\n * (`count`/`sum`/`avg`). Shared with the synced client, which only applies\n * optimistic deltas to these functions.\n */\nexport const isInvertible = (fn: AggregateFunction) =>\n  fn === 'count' || fn === 'sum' || fn === 'avg';\n\n/**\n * How an aggregate function reduces a group's rows into an {@link AggState},\n * and reads its result back. Shared by {@link Aggregate}, which keeps a state\n * per parent of a relationship, and `GroupBy`, which keeps one per group.\n */\nexport class Reducer {\n  readonly fn: AggregateFunction;\n  readonly field: string | undefined;\n  /** A JSON path into `field` (see `Aggregate.path`). */\n  readonly path: readonly (string | number)[] | undefined;\n\n  constructor(\n    fn: AggregateFunction,\n    field: string | undefined,\n    path: readonly (string | number)[] | undefined,\n  ) {\n    assert(\n      fn === 'count' ? field === undefined : field !== undefined,\n      () =>\n        `Aggregate: ${fn} ${fn === 'count' ? 'takes no' : 'requires a'} field`,\n    );\n    assert(\n      path === undefined || field !== undefined,\n      'Aggregate: a JSON path requires a field',\n    );\n    this.fn = fn;\n    this.field = field;\n    this.path = path;\n  }\n\n  /** The state of a group with no rows. */\n  empty(): AggState {\n    return {count: 0, sum: 0, nonNull: 0, extreme: null};\n  }\n\n  /** The scalar result for a state, per the aggregate function. */\n  value(s: AggState): Value {\n    switch (this.fn) {\n      case 'count':\n        return s.count;\n      case 'sum':\n        return s.nonNull === 0 ? null : s.sum;\n      case 'avg':\n        return s.nonNull === 0 ? null : s.sum / s.nonNull;\n      case 'min':\n      case 'max':\n        return s.extreme; // null when nonNull === 0\n      default:\n        unreachable(this.fn);\n    }\n  }\n\n  /** Whether `v` should replace the current extreme for a min/max. */\n  #beats(v: NormalizedValue, current: NormalizedValue): boolean {\n    const c = compareAggregateValues(v, current);\n    return this.fn === 'max' ? c > 0 : c < 0;\n  }\n\n  /**\n   * The value `row` contributes: its field, or the JSON leaf at the path (see\n   * `aggregateValue`), `null` when it contributes nothing.\n   */\n  #read(row: Row): NormalizedValue {\n    const field = must(this.field);\n    return normalizeUndefined(\n      this.path === undefined\n        ? row[field]\n        : (aggregateValue({fn: this.fn, field, path: this.path}, row) as Value),\n    );\n  }\n\n  /** Whether an edit from `oldRow` to `newRow` leaves the value it reduces. */\n  sameValue(oldRow: Row, newRow: Row): boolean {\n    return (\n      this.field === undefined ||\n      compareAggregateValues(this.#read(oldRow), this.#read(newRow)) === 0\n    );\n  }\n\n  /** Add one row's contribution to a (freshly accumulating) state. */\n  contribute(s: AggState, row: Row): void {\n    s.count++;\n    if (this.field === undefined) {\n      return;\n    }\n    const v = this.#read(row);\n    if (v === null) {\n      return;\n    }\n    s.nonNull++;\n    switch (this.fn) {\n      case 'sum':\n      case 'avg':\n        assert(\n          typeof v === 'number',\n          () => `Aggregate: ${this.fn} needs a number`,\n        );\n        s.sum += v;\n        break;\n      case 'min':\n      case 'max':\n        if (s.extreme === null || this.#beats(v, s.extreme)) {\n          s.extreme = v;\n        }\n        break;\n      default:\n        break;\n    }\n  }\n\n  /** Invertible delta for count/sum/avg. */\n  applyInvertible(\n    state: AggState,\n    row: Row,\n    sign: 1 | -1,\n    fieldOnly = false,\n  ): void {\n    if (!fieldOnly) {\n      state.count += sign;\n    }\n    if (this.field !== undefined) {\n      const v = this.#read(row);\n      if (v !== null) {\n        assert(\n          typeof v === 'number',\n          () => `Aggregate: ${this.fn}(${this.field}) requires a number`,\n        );\n        state.sum += sign * v;\n        state.nonNull += sign;\n      }\n    }\n  }\n\n  /**\n   * min/max maintenance, applied to `state` in place. Cheap for adds and for\n   * removing a non-extreme value. Returns false when the current extreme is\n   * removed or edited away: the new extreme is not recoverable from running\n   * state, so the group has to be re-fetched.\n   */\n  pushExtreme(state: AggState, change: Change): boolean {\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD:\n        // Adding can only extend the extreme outward — O(1).\n        this.contribute(state, change[ChangeIndex.NODE].row);\n        return true;\n      case ChangeType.REMOVE: {\n        const v = this.#read(change[ChangeIndex.NODE].row);\n        state.count--;\n        if (v === null) {\n          return true; // null never contributed to the extreme\n        }\n        if (\n          state.extreme !== null &&\n          compareAggregateValues(v, state.extreme) === 0\n        ) {\n          return false; // removed (one of) the extreme\n        }\n        state.nonNull--; // a non-extreme value left; extreme unchanged\n        return true;\n      }\n      case ChangeType.EDIT:\n        // When the field moved, the extreme may have changed in either\n        // direction.\n        return this.sameValue(\n          change[ChangeIndex.OLD_NODE].row,\n          change[ChangeIndex.NODE].row,\n        );\n      case ChangeType.CHILD:\n        return true;\n      default:\n        unreachable(change);\n    }\n  }\n\n  /**\n   * Whether a group's row changes from `stored` to `state`: its value, or, for\n   * sum/avg, the components even when the value doesn't (e.g. adding a 0 to a\n   * sum, or a row equal to the average), so the synced client's\n   * optimistic-delta base stays in sync.\n   */\n  changed(stored: AggState, state: AggState): boolean {\n    return (\n      this.value(stored) !== this.value(state) ||\n      (carriesComponents(this.fn) &&\n        (stored.sum !== state.sum || stored.nonNull !== state.nonNull))\n    );\n  }\n\n  /** Writes the result, and for sum/avg its components, into `row`. */\n  writePayload(row: Record<string, Value>, state: AggState): void {\n    row[AGGREGATE_VALUE_COLUMN] = this.value(state);\n    if (carriesComponents(this.fn)) {\n      // Carry the running components so the synced client can adjust them.\n      row[AGGREGATE_SUM_COLUMN] = state.sum;\n      row[AGGREGATE_COUNT_COLUMN] = state.nonNull;\n    }\n  }\n}\n\n/**\n * Aggregate is a reducing operator for `count(*)` / `sum` / `avg` / `min` /\n * `max` over a correlated relationship.\n *\n * It sits at the end of a related-subquery pipeline (where a normal `related`\n * would emit child rows) and collapses the child rows for each parent into a\n * *single* synthetic row `{ ...groupKey, value }`. Carrying the group key keeps\n * the {@link Join} unchanged — it routes child changes by childField.\n *\n * Two maintenance strategies share the same fetch/emit machinery:\n *\n *  - **Invertible** (count/sum/avg): add/remove/edit adjust running numbers in\n *    O(1); no re-fetch.\n *  - **Non-invertible** (min/max): add and removing a non-extreme value are\n *    O(1), but removing (or editing away) the current extreme is not\n *    invertible — the new extreme is unknown. In that case the group is marked\n *    dirty and re-fetched from the source in {@link reconcile}, as {@link Take}\n *    refills a partition. Re-fetching during the push itself could read\n *    operators upstream (e.g. an `EXISTS` under an `OR`) before they have\n *    settled the rest of the change.\n *\n * Null/empty semantics match SQL: every function except `count(*)` ignores null\n * field values and is NULL for an empty (or all-null) group; `count(*)` counts\n * all rows (0 when empty). An EDIT is emitted only when the derived value\n * actually changes.\n */\nexport class Aggregate implements Operator {\n  readonly #input: Input;\n  readonly #storage: AggStorage;\n  // Empty for a top-level (ungrouped) aggregate — a single global group.\n  readonly #groupKey: readonly string[];\n  readonly #reducer: Reducer;\n  readonly #schema: SourceSchema;\n  // The source connection `input` reads straight from, when nothing between\n  // them drops rows. A `count` asks it for the number instead of reading every\n  // row (see #compute).\n  readonly #countSource: SourceInput | undefined;\n\n  #output: Output = throwOutput;\n\n  /**\n   * min/max groups whose extreme a push removed, by storage key, to recompute\n   * in {@link reconcile}. Until then their storage keeps the state last sent\n   * downstream, which a fetch keeps returning.\n   */\n  readonly #dirtyGroups = new Map<string, readonly NormalizedValue[]>();\n\n  constructor(\n    input: Input,\n    storage: Storage,\n    groupKey: readonly string[],\n    fn: AggregateFunction,\n    field?: string,\n    tableName?: string,\n    countSource?: SourceInput,\n    path?: readonly (string | number)[],\n  ) {\n    this.#reducer = new Reducer(fn, field, path);\n    this.#input = input;\n    this.#storage = storage as AggStorage;\n    this.#groupKey = groupKey;\n    this.#countSource = fn === 'count' ? countSource : undefined;\n    input.setOutput(this);\n\n    const inputSchema = input.getSchema();\n    // Top-level (ungrouped) aggregate synthesizes a single constant-valued key\n    // column (so the one global row has a non-empty primary key, required by the\n    // synced/CVR path); grouped/relationship aggregates use the group key. The\n    // same derivation runs on the client (aggregatesFromSource), so the two\n    // sides agree on the synthetic source shape.\n    const {columns, primaryKey: keyColumns} = aggregateSourceSchema(\n      inputSchema.columns,\n      groupKey,\n      fn,\n      field,\n      path,\n    );\n\n    // Exactly one row per key, so the key is the primary key and a valid\n    // (stable) sort.\n    const sort: Ordering = keyColumns.map(col => [col, 'asc'] as const);\n    this.#schema = {\n      // The synthetic rows are routed (e.g. by the view-syncer streamer) to a\n      // synthetic table, distinct from the child table, so they are never\n      // confused with real child rows.\n      tableName: tableName ?? inputSchema.tableName,\n      columns,\n      // The group key (relationship aggregate) or the synthetic singleton key\n      // (top-level aggregate) — one row per key in either case.\n      primaryKey: keyColumns as unknown as PrimaryKey,\n      relationships: {},\n      isHidden: false,\n      isAggregate: true,\n      system: inputSchema.system,\n      sort,\n      compareRows: makeComparator(sort),\n    };\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n    this.#storage.destroy();\n  }\n\n  /** Recompute the whole group state from the source (already up to date). */\n  *#compute(constraint: Constraint | undefined): Generator<'yield', AggState> {\n    const s = this.#reducer.empty();\n    const count = this.#countSource?.count?.(constraint);\n    if (count !== undefined) {\n      s.count = count;\n      return s;\n    }\n    for (const node of this.#input.fetch({constraint})) {\n      if (node === 'yield') {\n        yield node;\n        continue;\n      }\n      this.#reducer.contribute(s, node.row);\n    }\n    return s;\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    const groupValues = this.#groupValuesFromConstraint(req.constraint);\n    const key = stateKey(groupValues);\n\n    let state = this.#storage.get(key);\n    if (state === undefined) {\n      state = yield* this.#compute(req.constraint);\n      this.#storage.set(key, state);\n    }\n\n    yield this.#makeNode(groupValues, state);\n  }\n\n  /**\n   * Phase 2 of the two-phase push: recompute the min/max groups whose extreme\n   * Phase 1 removed, now that everything upstream has settled, then forward the\n   * signal for bounded operators downstream.\n   */\n  *reconcile(_pusher: InputBase): Stream<'yield'> {\n    if (this.#dirtyGroups.size > 0) {\n      const dirty = [...this.#dirtyGroups];\n      this.#dirtyGroups.clear();\n      for (const [key, groupValues] of dirty) {\n        const stored = must(this.#storage.get(key));\n        const state = yield* this.#compute(\n          this.#constraintFromGroup(groupValues),\n        );\n        this.#storage.set(key, state);\n        yield* this.#emitIfChanged(groupValues, stored, state);\n      }\n    }\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    const groupValues = this.#groupValuesFromRow(change[ChangeIndex.NODE].row);\n    const key = stateKey(groupValues);\n    const stored = this.#storage.get(key);\n\n    // If we have no state for this group, nothing downstream has materialized\n    // it, so there is nothing to update. When it is later fetched, fetch()\n    // computes the true state from the source (which has already applied this\n    // change). Mirrors Take's no-state no-op.\n    if (stored === undefined) {\n      return;\n    }\n\n    const state: AggState = {...stored};\n\n    const reducer = this.#reducer;\n    if (isInvertible(reducer.fn)) {\n      switch (change[ChangeIndex.TYPE]) {\n        case ChangeType.ADD:\n          reducer.applyInvertible(state, change[ChangeIndex.NODE].row, 1);\n          break;\n        case ChangeType.REMOVE:\n          reducer.applyInvertible(state, change[ChangeIndex.NODE].row, -1);\n          break;\n        case ChangeType.EDIT: {\n          // Group key unchanged (Join guarantees it); only the field moves the\n          // value. count(*) is unaffected, and so is a sum/avg whose field kept\n          // its value: subtracting and re-adding it would only add rounding\n          // error.\n          if (\n            reducer.sameValue(\n              change[ChangeIndex.OLD_NODE].row,\n              change[ChangeIndex.NODE].row,\n            )\n          ) {\n            return;\n          }\n          // Remove the old contribution, add the new.\n          reducer.applyInvertible(\n            state,\n            change[ChangeIndex.OLD_NODE].row,\n            -1,\n            true,\n          );\n          reducer.applyInvertible(state, change[ChangeIndex.NODE].row, 1, true);\n          break;\n        }\n        case ChangeType.CHILD:\n          return;\n        default:\n          unreachable(change);\n      }\n    } else {\n      // min/max — non-invertible. A dirty group is recomputed from the source\n      // in reconcile, which covers this change too.\n      if (this.#dirtyGroups.has(key) || !reducer.pushExtreme(state, change)) {\n        this.#dirtyGroups.set(key, groupValues);\n        return;\n      }\n    }\n\n    assert(state.count >= 0, 'Aggregate: removed a row from an empty group');\n    this.#storage.set(key, state);\n    yield* this.#emitIfChanged(groupValues, stored, state);\n  }\n\n  /** Sends downstream the move of a group from `stored` to `state`, if any. */\n  *#emitIfChanged(\n    groupValues: readonly NormalizedValue[],\n    stored: AggState,\n    state: AggState,\n  ): Stream<'yield'> {\n    if (this.#reducer.changed(stored, state)) {\n      yield* this.#output.push(\n        makeEditChange(\n          this.#makeNode(groupValues, state),\n          this.#makeNode(groupValues, stored),\n        ),\n        this,\n      );\n    }\n  }\n\n  #makeNode(groupValues: readonly NormalizedValue[], state: AggState): Node {\n    const row: Record<string, Value> = {};\n    for (let i = 0; i < this.#groupKey.length; i++) {\n      assignProperty(row, this.#groupKey[i], groupValues[i]);\n    }\n    if (this.#groupKey.length === 0) {\n      // Top-level (ungrouped): the single row carries the synthetic key column.\n      row[AGGREGATE_KEY_COLUMN] = AGGREGATE_KEY_VALUE;\n    }\n    this.#reducer.writePayload(row, state);\n    return {row, relationships: {}};\n  }\n\n  #constraintFromGroup(groupValues: readonly NormalizedValue[]): Constraint {\n    const constraint: Record<string, Value> = {};\n    for (let i = 0; i < this.#groupKey.length; i++) {\n      assignProperty(constraint, this.#groupKey[i], groupValues[i]);\n    }\n    return constraint;\n  }\n\n  #groupValuesFromConstraint(\n    constraint: Constraint | undefined,\n  ): NormalizedValue[] {\n    if (this.#groupKey.length === 0) {\n      return []; // top-level (ungrouped) — one global group, no constraint\n    }\n    assert(\n      constraint,\n      'Aggregate requires a constraint on the group key (relationship aggregate only)',\n    );\n    return this.#groupKey.map(col => {\n      assert(\n        Object.hasOwn(constraint, col),\n        () => `Aggregate: constraint missing group key column \"${col}\"`,\n      );\n      return normalizeUndefined(constraint[col]);\n    });\n  }\n\n  #groupValuesFromRow(row: Row): NormalizedValue[] {\n    return this.#groupKey.map(col => normalizeUndefined(row[col]));\n  }\n}\n\n/**\n * Orders the values a min/max reduces. A JSON path's leaves can be numbers or\n * strings, decided per value; numbers order before strings, as in JS and\n * SQLite (z2s compiles the same rule rather than Postgres's jsonb ordering,\n * which puts strings first). Otherwise it is {@link compareValues}.\n */\nfunction compareAggregateValues(\n  a: NormalizedValue,\n  b: NormalizedValue,\n): number {\n  if (\n    a !== null &&\n    b !== null &&\n    typeof a !== typeof b &&\n    (typeof a === 'number' || typeof a === 'string') &&\n    (typeof b === 'number' || typeof b === 'string')\n  ) {\n    return typeof a === 'number' ? -1 : 1;\n  }\n  return compareValues(a, b);\n}\n\n/**\n * The storage key of a group's state. A relationship is usually correlated on\n * one column, which gets the cheaper single-value encoding Take and Cap use;\n * an operator's group key has a fixed length, so the two forms never meet.\n */\nfunction stateKey(groupValues: readonly NormalizedValue[]): string {\n  return groupValues.length === 1\n    ? valueToKey(groupValues[0])\n    : JSON.stringify(groupValues);\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/array-view.d.ts

@@ -15,7 +15,7 @@ import type { Format, View } from './view.ts';
  * Also the plain array view is more convenient for consumers since you can dump
  * it into console to see what it is, rather than having to iterate it.
  */
-export declare class ArrayView<V extends View> implements Output, TypedView<V> {
+export declare class ArrayView<V = View> implements Output, TypedView<V> {
     #private;
     onDestroy: (() => void) | undefined;
     constructor(input: Input, format: Format, queryComplete: true | ErroredQuery | Promise<true>, updateTTL: (ttl: TTL) => void);

package/out/zql/src/ivm/array-view.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array-view.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/array-view.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,8CAA8C,CAAC;AAC/E,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,KAAK,EAAC,QAAQ,EAAc,SAAS,EAAC,MAAM,wBAAwB,CAAC;AAG5E,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAAa,KAAK,KAAK,EAAE,KAAK,MAAM,EAAC,MAAM,eAAe,CAAC;AAGlE,OAAO,KAAK,EAAQ,MAAM,EAAE,IAAI,EAAC,MAAM,WAAW,CAAC;AA0BnD;;;;;;;;;;GAUG;AACH,qBAAa,SAAS,CAAC,CAAC,SAAS,IAAI,CAAE,YAAW,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;;IAgBpE,SAAS,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IAyBpC,YACE,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,IAAI,GAAG,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,EAClD,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,EAmB9B;IAED,IAAI,IAAI,IAC4C,CAAC,CACpD;IAMD,WAAW,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,cAShC;IAoBD,OAAO,SAEN;IAqBD,IAAI,CAAC,MAAM,EAAE,MAAM,oBAuBlB;IAED;;;;;;;;;;OAUG;IACH,QAAQ,IAAI,IAAI,CAKf;IAED;;;;;OAKG;IACH,WAAW,IAAI,IAAI,CAElB;IAED,KAAK,SAkBJ;IAED,SAAS,CAAC,GAAG,EAAE,GAAG,QAEjB;IAED;;;;;;OAMG;IACH,UAAU,IAAI,IAAI,CAIjB;IAED,wEAAwE;IACxE,YAAY,IAAI,IAAI,CAInB;CAkBF"}
+{"version":3,"file":"array-view.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/array-view.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,8CAA8C,CAAC;AAC/E,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,KAAK,EAAC,QAAQ,EAAc,SAAS,EAAC,MAAM,wBAAwB,CAAC;AAG5E,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAAa,KAAK,KAAK,EAAE,KAAK,MAAM,EAAC,MAAM,eAAe,CAAC;AAOlE,OAAO,KAAK,EAAQ,MAAM,EAAE,IAAI,EAAC,MAAM,WAAW,CAAC;AA0BnD;;;;;;;;;;GAUG;AAGH,qBAAa,SAAS,CAAC,CAAC,GAAG,IAAI,CAAE,YAAW,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;;IAgB9D,SAAS,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IAyBpC,YACE,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,IAAI,GAAG,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,EAClD,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,EAmB9B;IAED,IAAI,IAAI,IAC4C,CAAC,CACpD;IAMD,WAAW,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,cAShC;IAoBD,OAAO,SAEN;IAqBD,IAAI,CAAC,MAAM,EAAE,MAAM,oBAuBlB;IAED;;;;;;;;;;OAUG;IACH,QAAQ,IAAI,IAAI,CAKf;IAED;;;;;OAKG;IACH,WAAW,IAAI,IAAI,CAElB;IAED,KAAK,SAkBJ;IAED,SAAS,CAAC,GAAG,EAAE,GAAG,QAEjB;IAED;;;;;;OAMG;IACH,UAAU,IAAI,IAAI,CAIjB;IAED,wEAAwE;IACxE,YAAY,IAAI,IAAI,CAInB;CAkBF"}

package/out/zql/src/ivm/array-view.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../shared/src/asserts.js";
-import { emptyArray } from "../../../shared/src/sentinels.js";
 import { skipYields } from "./skip-yields.js";
-import { applyChange } from "./view-apply-change.js";
+import { emptyArray } from "../../../shared/src/sentinels.js";
+import { applyChange, emptyViewValue } from "./view-apply-change.js";
 //#region ../zql/src/ivm/array-view.ts
 function changeToViewChange(change) {
 	switch (change[0]) {
@@ -59,7 +59,7 @@ var ArrayView = class {
 		this.#input = input;
 		this.#format = format;
 		this.#updateTTL = updateTTL;
-		this.#root = { "": format.singular ? void 0 : [] };
+		this.#root = { "": emptyViewValue(format) };
 		input.setOutput(this);
 		if (queryComplete === true) this.#resultType = "complete";
 		else if ("error" in queryComplete) {

package/out/zql/src/ivm/array-view.js.map

@@ -1 +1 @@
-{"version":3,"file":"array-view.js","names":["#input","#listeners","#format","#updateTTL","#root","#resultType","#error","#setResultType","#hydrate","#committedRoot","#schema","#listenerArgs","#heldResultType","#heldError","#dirty","#getSchema","#txnDirty","#held","#fireListeners"],"sources":["../../../../../zql/src/ivm/array-view.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Immutable} from '../../../shared/src/immutable.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport type {ErroredQuery} from '../../../zero-protocol/src/custom-queries.ts';\nimport type {TTL} from '../query/ttl.ts';\nimport type {Listener, ResultType, TypedView} from '../query/typed-view.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport {skipYields, type Input, type Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {applyChange, type ViewChange} from './view-apply-change.ts';\nimport type {Entry, Format, View} from './view.ts';\n\nfunction changeToViewChange(change: Change): ViewChange {\n  switch (change[ChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      return {type: 'add', node: change[ChangeIndex.NODE]};\n    case ChangeType.REMOVE:\n      return {type: 'remove', node: change[ChangeIndex.NODE]};\n    case ChangeType.CHILD:\n      return {\n        type: 'child',\n        node: change[ChangeIndex.NODE],\n        child: {\n          relationshipName: change[ChangeIndex.CHILD_DATA].relationshipName,\n          change: changeToViewChange(change[ChangeIndex.CHILD_DATA].change),\n        },\n      };\n    case ChangeType.EDIT:\n      return {\n        type: 'edit',\n        node: change[ChangeIndex.NODE],\n        oldNode: change[ChangeIndex.OLD_NODE],\n      };\n  }\n}\n\n/**\n * Implements a materialized view of the output of an operator.\n *\n * It might seem more efficient to use an immutable b-tree for the\n * materialization, but it's not so clear. Inserts in the middle are\n * asymptotically slower in an array, but can often be done with zero\n * allocations, where changes to the b-tree will often require several allocs.\n *\n * Also the plain array view is more convenient for consumers since you can dump\n * it into console to see what it is, rather than having to iterate it.\n */\nexport class ArrayView<V extends View> implements Output, TypedView<V> {\n  readonly #input: Input;\n  readonly #listeners = new Set<Listener<V>>();\n  // Read lazily: a DeferredInput has no schema until its pipeline is attached,\n  // and the schema is only needed once there is a change to apply.\n  #schema: SourceSchema | undefined;\n  readonly #format: Format;\n\n  // Synthetic \"root\" entry that has a single \"\" relationship, so that we can\n  // treat all changes, including the root change, generically.\n  //\n  // applyChange is immutable: it returns a new root, preserving the references\n  // of unchanged subtrees so consumers (React.memo / Solid) can skip them. We\n  // therefore reassign #root on every change rather than mutating in place.\n  #root: Entry;\n\n  onDestroy: (() => void) | undefined;\n\n  #dirty = false;\n  // Set by holdData(): the root that `data` and newly added listeners keep\n  // seeing until releaseData() or the next flush, while pushes build up #root\n  // behind it.\n  #committedRoot: Entry | undefined;\n  // From holdData() until the next flush. Outlasts #committedRoot, which\n  // releaseData() drops first.\n  #held = false;\n  // The result type and error as of holdData(): what a listener added while\n  // held is called with, so it never sees old rows paired with a new type.\n  #heldResultType: ResultType = 'unknown';\n  #heldError: ErroredQuery | undefined;\n  #resultType: ResultType = 'unknown';\n  #error: ErroredQuery | undefined;\n  readonly #updateTTL: (ttl: TTL) => void;\n\n  // Objects/arrays created or cloned during the current (un-flushed)\n  // transaction. applyChange may mutate these in place rather than copying\n  // again, since they are not yet observed by any listener. Replaced at\n  // flush(), after which the committed snapshot must be copied-on-write again.\n  // A WeakSet (not a Set) so it never extends the lifetime of transient clones.\n  #txnDirty: WeakSet<object> = new WeakSet();\n\n  constructor(\n    input: Input,\n    format: Format,\n    queryComplete: true | ErroredQuery | Promise<true>,\n    updateTTL: (ttl: TTL) => void,\n  ) {\n    this.#input = input;\n    this.#format = format;\n    this.#updateTTL = updateTTL;\n    this.#root = {'': format.singular ? undefined : []};\n    input.setOutput(this);\n\n    if (queryComplete === true) {\n      this.#resultType = 'complete';\n    } else if ('error' in queryComplete) {\n      this.#resultType = 'error';\n      this.#error = queryComplete;\n    } else {\n      void queryComplete\n        .then(() => this.#setResultType('complete'))\n        .catch(e => this.#setResultType('error', e));\n    }\n    this.#hydrate();\n  }\n\n  get data() {\n    return (this.#committedRoot ?? this.#root)[''] as V;\n  }\n\n  #getSchema(): SourceSchema {\n    return (this.#schema ??= this.#input.getSchema());\n  }\n\n  addListener(listener: Listener<V>) {\n    assert(!this.#listeners.has(listener), 'Listener already registered');\n    this.#listeners.add(listener);\n\n    listener(...this.#listenerArgs());\n\n    return () => {\n      this.#listeners.delete(listener);\n    };\n  }\n\n  #fireListeners() {\n    // Read the snapshot once: a listener may push() synchronously, and the\n    // listeners after it must not be handed the root that push is building,\n    // which the rest of the transaction would then mutate in place.\n    const args = this.#listenerArgs();\n    for (const listener of this.#listeners) {\n      listener(...args);\n    }\n  }\n\n  #listenerArgs(): Parameters<Listener<V>> {\n    if (this.#committedRoot !== undefined) {\n      // Held rows go with the held type; after releaseData() both are current.\n      return [this.data as Immutable<V>, this.#heldResultType, this.#heldError];\n    }\n    return [this.data as Immutable<V>, this.#resultType, this.#error];\n  }\n\n  destroy() {\n    this.onDestroy?.();\n  }\n\n  #hydrate() {\n    this.#dirty = true;\n    for (const node of skipYields(this.#input.fetch({}))) {\n      this.#root = applyChange(\n        this.#root,\n        {type: 'add', node},\n        this.#getSchema(),\n        '',\n        this.#format,\n        false /* withIDs */,\n        true /* mutate: #root is freshly created and not yet observed by any\n                 consumer, so build it in place to avoid O(N^2) array copies.\n                 Every later push() is immutable, preserving reference\n                 stability for unchanged subtrees. */,\n      );\n    }\n    this.flush();\n  }\n\n  push(change: Change) {\n    const newRoot = applyChange(\n      this.#root,\n      changeToViewChange(change),\n      this.#getSchema(),\n      '',\n      this.#format,\n      false /* withIDs */,\n      this.#txnDirty /* mutate: copy-on-write within this transaction */,\n    );\n    // applyChange returns the same root when the change did not affect the\n    // view — e.g. a child change for a relationship that is not in the format,\n    // such as a whereExists subquery (zsubq_*). Only mark dirty when the root\n    // actually changed so flush() does not notify listeners with identical\n    // data. Within a transaction the root keeps its reference across a *real*\n    // change only if an earlier change in the same transaction already cloned\n    // it (copy-on-write) — and that earlier change set #dirty, so an unchanged\n    // reference here never hides a real change.\n    if (newRoot !== this.#root) {\n      this.#root = newRoot;\n      this.#dirty = true;\n    }\n    return emptyArray;\n  }\n\n  /**\n   * Keep exposing the current snapshot, whatever is pushed in the meantime,\n   * until {@link releaseData} or the next {@link flush}. Result type\n   * notifications are held back until that flush.\n   *\n   * A transaction is normally one synchronous task, so nobody can look at a\n   * view between its pushes and its flush. Deferred pipelines are different:\n   * they are hydrated over several tasks and flushed together (see\n   * `QueryDelegate.onPipelinesReady`), and a view that already has its rows\n   * must not show them early.\n   */\n  holdData(): void {\n    this.#committedRoot = this.#root;\n    this.#held = true;\n    this.#heldResultType = this.#resultType;\n    this.#heldError = this.#error;\n  }\n\n  /**\n   * Make `data` current again without notifying anyone yet; listeners are\n   * still only called by the next {@link flush}. Views released together get\n   * this called on all of them before any is flushed, so a listener of one\n   * that reads another sees its rows too.\n   */\n  releaseData(): void {\n    this.#committedRoot = undefined;\n  }\n\n  flush() {\n    this.#committedRoot = undefined;\n    this.#held = false;\n    if (!this.#dirty) {\n      return;\n    }\n    this.#dirty = false;\n    // The snapshot about to be handed to listeners becomes observed; the next\n    // transaction must copy-on-write rather than mutate these objects. A fresh\n    // WeakSet drops all \"owned\" marks (WeakSet has no clear()).\n    //\n    // Reset BEFORE notifying: a listener may throw (swallowed by\n    // ZeroContext#endTransaction) or re-enter push(). If the committed root\n    // kept its \"owned\" marks, a later transaction would mutate it in place and\n    // return an identical reference — which push() would read as \"no change\",\n    // permanently silencing the view.\n    this.#txnDirty = new WeakSet();\n    this.#fireListeners();\n  }\n\n  updateTTL(ttl: TTL) {\n    this.#updateTTL(ttl);\n  }\n\n  /**\n   * The store holds the server-confirmed complete result of this query from a\n   * previous sync (the persisted got-queries key exists, pre-authoritative).\n   * Never downgrades 'complete'/'error', and never resolves anything that\n   * waits on 'complete' — freshness stays a promise only the connection can\n   * keep.\n   */\n  markCached(): void {\n    if (this.#resultType === 'unknown') {\n      this.#setResultType('cached');\n    }\n  }\n\n  /** The got key was deleted (eviction) while still pre-authoritative. */\n  unmarkCached(): void {\n    if (this.#resultType === 'cached') {\n      this.#setResultType('unknown');\n    }\n  }\n\n  #setResultType(resultType: ResultType, error?: ErroredQuery) {\n    this.#resultType = resultType;\n    this.#error = error;\n    // A dirty view is mid-transaction: rows were pushed and not yet flushed,\n    // and the objects in #txnDirty are still mutable. Firing now would hand\n    // those to listeners and then fire again at flush() with the same data, so\n    // let the pending flush deliver the new result type instead.\n    // A held view is waiting to be exposed together with others at the next\n    // flush; that goes for its result type as much as for its rows.\n    if (this.#held) {\n      // Dirty so that the flush notifies even when no rows were pushed.\n      this.#dirty = true;\n    } else if (!this.#dirty) {\n      this.#fireListeners();\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"array-view.js","names":[],"sources":["../../../../../zql/src/ivm/array-view.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Immutable} from '../../../shared/src/immutable.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport type {ErroredQuery} from '../../../zero-protocol/src/custom-queries.ts';\nimport type {TTL} from '../query/ttl.ts';\nimport type {Listener, ResultType, TypedView} from '../query/typed-view.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport {skipYields, type Input, type Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {\n  applyChange,\n  emptyViewValue,\n  type ViewChange,\n} from './view-apply-change.ts';\nimport type {Entry, Format, View} from './view.ts';\n\nfunction changeToViewChange(change: Change): ViewChange {\n  switch (change[ChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      return {type: 'add', node: change[ChangeIndex.NODE]};\n    case ChangeType.REMOVE:\n      return {type: 'remove', node: change[ChangeIndex.NODE]};\n    case ChangeType.CHILD:\n      return {\n        type: 'child',\n        node: change[ChangeIndex.NODE],\n        child: {\n          relationshipName: change[ChangeIndex.CHILD_DATA].relationshipName,\n          change: changeToViewChange(change[ChangeIndex.CHILD_DATA].change),\n        },\n      };\n    case ChangeType.EDIT:\n      return {\n        type: 'edit',\n        node: change[ChangeIndex.NODE],\n        oldNode: change[ChangeIndex.OLD_NODE],\n      };\n  }\n}\n\n/**\n * Implements a materialized view of the output of an operator.\n *\n * It might seem more efficient to use an immutable b-tree for the\n * materialization, but it's not so clear. Inserts in the middle are\n * asymptotically slower in an array, but can often be done with zero\n * allocations, where changes to the b-tree will often require several allocs.\n *\n * Also the plain array view is more convenient for consumers since you can dump\n * it into console to see what it is, rather than having to iterate it.\n */\n// `V` is unconstrained: besides a `View` it may be a scalar `Value` for a\n// top-level aggregate query, whose materialized result is the bare value.\nexport class ArrayView<V = View> implements Output, TypedView<V> {\n  readonly #input: Input;\n  readonly #listeners = new Set<Listener<V>>();\n  // Read lazily: a DeferredInput has no schema until its pipeline is attached,\n  // and the schema is only needed once there is a change to apply.\n  #schema: SourceSchema | undefined;\n  readonly #format: Format;\n\n  // Synthetic \"root\" entry that has a single \"\" relationship, so that we can\n  // treat all changes, including the root change, generically.\n  //\n  // applyChange is immutable: it returns a new root, preserving the references\n  // of unchanged subtrees so consumers (React.memo / Solid) can skip them. We\n  // therefore reassign #root on every change rather than mutating in place.\n  #root: Entry;\n\n  onDestroy: (() => void) | undefined;\n\n  #dirty = false;\n  // Set by holdData(): the root that `data` and newly added listeners keep\n  // seeing until releaseData() or the next flush, while pushes build up #root\n  // behind it.\n  #committedRoot: Entry | undefined;\n  // From holdData() until the next flush. Outlasts #committedRoot, which\n  // releaseData() drops first.\n  #held = false;\n  // The result type and error as of holdData(): what a listener added while\n  // held is called with, so it never sees old rows paired with a new type.\n  #heldResultType: ResultType = 'unknown';\n  #heldError: ErroredQuery | undefined;\n  #resultType: ResultType = 'unknown';\n  #error: ErroredQuery | undefined;\n  readonly #updateTTL: (ttl: TTL) => void;\n\n  // Objects/arrays created or cloned during the current (un-flushed)\n  // transaction. applyChange may mutate these in place rather than copying\n  // again, since they are not yet observed by any listener. Replaced at\n  // flush(), after which the committed snapshot must be copied-on-write again.\n  // A WeakSet (not a Set) so it never extends the lifetime of transient clones.\n  #txnDirty: WeakSet<object> = new WeakSet();\n\n  constructor(\n    input: Input,\n    format: Format,\n    queryComplete: true | ErroredQuery | Promise<true>,\n    updateTTL: (ttl: TTL) => void,\n  ) {\n    this.#input = input;\n    this.#format = format;\n    this.#updateTTL = updateTTL;\n    this.#root = {'': emptyViewValue(format)};\n    input.setOutput(this);\n\n    if (queryComplete === true) {\n      this.#resultType = 'complete';\n    } else if ('error' in queryComplete) {\n      this.#resultType = 'error';\n      this.#error = queryComplete;\n    } else {\n      void queryComplete\n        .then(() => this.#setResultType('complete'))\n        .catch(e => this.#setResultType('error', e));\n    }\n    this.#hydrate();\n  }\n\n  get data() {\n    return (this.#committedRoot ?? this.#root)[''] as V;\n  }\n\n  #getSchema(): SourceSchema {\n    return (this.#schema ??= this.#input.getSchema());\n  }\n\n  addListener(listener: Listener<V>) {\n    assert(!this.#listeners.has(listener), 'Listener already registered');\n    this.#listeners.add(listener);\n\n    listener(...this.#listenerArgs());\n\n    return () => {\n      this.#listeners.delete(listener);\n    };\n  }\n\n  #fireListeners() {\n    // Read the snapshot once: a listener may push() synchronously, and the\n    // listeners after it must not be handed the root that push is building,\n    // which the rest of the transaction would then mutate in place.\n    const args = this.#listenerArgs();\n    for (const listener of this.#listeners) {\n      listener(...args);\n    }\n  }\n\n  #listenerArgs(): Parameters<Listener<V>> {\n    if (this.#committedRoot !== undefined) {\n      // Held rows go with the held type; after releaseData() both are current.\n      return [this.data as Immutable<V>, this.#heldResultType, this.#heldError];\n    }\n    return [this.data as Immutable<V>, this.#resultType, this.#error];\n  }\n\n  destroy() {\n    this.onDestroy?.();\n  }\n\n  #hydrate() {\n    this.#dirty = true;\n    for (const node of skipYields(this.#input.fetch({}))) {\n      this.#root = applyChange(\n        this.#root,\n        {type: 'add', node},\n        this.#getSchema(),\n        '',\n        this.#format,\n        false /* withIDs */,\n        true /* mutate: #root is freshly created and not yet observed by any\n                 consumer, so build it in place to avoid O(N^2) array copies.\n                 Every later push() is immutable, preserving reference\n                 stability for unchanged subtrees. */,\n      );\n    }\n    this.flush();\n  }\n\n  push(change: Change) {\n    const newRoot = applyChange(\n      this.#root,\n      changeToViewChange(change),\n      this.#getSchema(),\n      '',\n      this.#format,\n      false /* withIDs */,\n      this.#txnDirty /* mutate: copy-on-write within this transaction */,\n    );\n    // applyChange returns the same root when the change did not affect the\n    // view — e.g. a child change for a relationship that is not in the format,\n    // such as a whereExists subquery (zsubq_*). Only mark dirty when the root\n    // actually changed so flush() does not notify listeners with identical\n    // data. Within a transaction the root keeps its reference across a *real*\n    // change only if an earlier change in the same transaction already cloned\n    // it (copy-on-write) — and that earlier change set #dirty, so an unchanged\n    // reference here never hides a real change.\n    if (newRoot !== this.#root) {\n      this.#root = newRoot;\n      this.#dirty = true;\n    }\n    return emptyArray;\n  }\n\n  /**\n   * Keep exposing the current snapshot, whatever is pushed in the meantime,\n   * until {@link releaseData} or the next {@link flush}. Result type\n   * notifications are held back until that flush.\n   *\n   * A transaction is normally one synchronous task, so nobody can look at a\n   * view between its pushes and its flush. Deferred pipelines are different:\n   * they are hydrated over several tasks and flushed together (see\n   * `QueryDelegate.onPipelinesReady`), and a view that already has its rows\n   * must not show them early.\n   */\n  holdData(): void {\n    this.#committedRoot = this.#root;\n    this.#held = true;\n    this.#heldResultType = this.#resultType;\n    this.#heldError = this.#error;\n  }\n\n  /**\n   * Make `data` current again without notifying anyone yet; listeners are\n   * still only called by the next {@link flush}. Views released together get\n   * this called on all of them before any is flushed, so a listener of one\n   * that reads another sees its rows too.\n   */\n  releaseData(): void {\n    this.#committedRoot = undefined;\n  }\n\n  flush() {\n    this.#committedRoot = undefined;\n    this.#held = false;\n    if (!this.#dirty) {\n      return;\n    }\n    this.#dirty = false;\n    // The snapshot about to be handed to listeners becomes observed; the next\n    // transaction must copy-on-write rather than mutate these objects. A fresh\n    // WeakSet drops all \"owned\" marks (WeakSet has no clear()).\n    //\n    // Reset BEFORE notifying: a listener may throw (swallowed by\n    // ZeroContext#endTransaction) or re-enter push(). If the committed root\n    // kept its \"owned\" marks, a later transaction would mutate it in place and\n    // return an identical reference — which push() would read as \"no change\",\n    // permanently silencing the view.\n    this.#txnDirty = new WeakSet();\n    this.#fireListeners();\n  }\n\n  updateTTL(ttl: TTL) {\n    this.#updateTTL(ttl);\n  }\n\n  /**\n   * The store holds the server-confirmed complete result of this query from a\n   * previous sync (the persisted got-queries key exists, pre-authoritative).\n   * Never downgrades 'complete'/'error', and never resolves anything that\n   * waits on 'complete' — freshness stays a promise only the connection can\n   * keep.\n   */\n  markCached(): void {\n    if (this.#resultType === 'unknown') {\n      this.#setResultType('cached');\n    }\n  }\n\n  /** The got key was deleted (eviction) while still pre-authoritative. */\n  unmarkCached(): void {\n    if (this.#resultType === 'cached') {\n      this.#setResultType('unknown');\n    }\n  }\n\n  #setResultType(resultType: ResultType, error?: ErroredQuery) {\n    this.#resultType = resultType;\n    this.#error = error;\n    // A dirty view is mid-transaction: rows were pushed and not yet flushed,\n    // and the objects in #txnDirty are still mutable. Firing now would hand\n    // those to listeners and then fire again at flush() with the same data, so\n    // let the pending flush deliver the new result type instead.\n    // A held view is waiting to be exposed together with others at the next\n    // flush; that goes for its result type as much as for its rows.\n    if (this.#held) {\n      // Dirty so that the flush notifies even when no rows were pushed.\n      this.#dirty = true;\n    } else if (!this.#dirty) {\n      this.#fireListeners();\n    }\n  }\n}\n"],"mappings":"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"}

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

@@ -1,5 +1,5 @@
 import { type Change } from './change.ts';
-import type { Node } from './data.ts';
+import { type Node } from './data.ts';
 import { type FetchRequest, type Input, type InputBase, type Operator, type Output, type Storage } from './operator.ts';
 import type { SourceSchema } from './schema.ts';
 import { type Stream } from './stream.ts';

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

@@ -1 +1 @@
-{"version":3,"file":"cap.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/cap.ts"],"names":[],"mappings":"AAMA,OAAO,EAAgB,KAAK,MAAM,EAAkB,MAAM,aAAa,CAAC;AAExE,OAAO,KAAK,EAAa,IAAI,EAAC,MAAM,WAAW,CAAC;AAChD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,WAAW,CAAC;AAcnB;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,GAAI,YAAW,QAAQ;;IAUlC,YACE,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY,EAW5B;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAyChD;IAsDA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAiFrC;IAsCD,OAAO,IAAI,IAAI,CAGd;IAEA,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAI9C;CACF"}
+{"version":3,"file":"cap.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/cap.ts"],"names":[],"mappings":"AAMA,OAAO,EAAgB,KAAK,MAAM,EAAkB,MAAM,aAAa,CAAC;AAExE,OAAO,EAA8B,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AACjE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,WAAW,CAAC;AAcnB;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,GAAI,YAAW,QAAQ;;IAUlC,YACE,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY,EAW5B;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CA+ChD;IAsDA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAiFrC;IAsCD,OAAO,IAAI,IAAI,CAGd;IAEA,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAI9C;CACF"}

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

@@ -1,7 +1,8 @@
 import { assert } from "../../../shared/src/asserts.js";
-import { emptyArray } from "../../../shared/src/sentinels.js";
-import { throwOutput } from "./operator.js";
 import { makeAddChange } from "./change.js";
+import { valueToKey } from "./data.js";
+import { throwOutput } from "./operator.js";
+import { emptyArray } from "../../../shared/src/sentinels.js";
 import { constraintMatchesPartitionKey, makePartitionKeyComparator } from "./take.js";
 //#region ../zql/src/ivm/cap.ts
 /**
@@ -51,10 +52,14 @@ var Cap = class {
 		const capStateKey = getCapStateKey(this.#partitionKey, req.constraint);
 		const capState = this.#storage.get(capStateKey);
 		if (!capState) {
-			yield* this.#initialFetch(req);
+			yield* this.#initialFetch(req, capStateKey);
 			return;
 		}
 		if (capState.size === 0) return;
+		if (req.countOnly) {
+			for (let i = 0; i < capState.size; i++) yield placeholderNode;
+			return;
+		}
 		for (const pk of capState.pks) {
 			const pkConstraint = deserializePKToConstraint(pk, this.#primaryKey);
 			const constraint = req.constraint ? {
@@ -70,11 +75,9 @@ var Cap = class {
 			}
 		}
 	}
-	*#initialFetch(req) {
+	*#initialFetch(req, capStateKey) {
 		if (this.#limit === 0) return;
 		assert(constraintMatchesPartitionKey(req.constraint, this.#partitionKey), "Constraint should match partition key");
-		const capStateKey = getCapStateKey(this.#partitionKey, req.constraint);
-		assert(this.#storage.get(capStateKey) === void 0, "Cap state should be undefined");
 		let size = 0;
 		const pks = [];
 		let downstreamEarlyReturn = true;
@@ -195,7 +198,12 @@ var Cap = class {
 		if (this.#output.reconcile) yield* this.#output.reconcile(this);
 	}
 };
+var placeholderNode = Object.freeze({
+	row: Object.freeze({}),
+	relationships: Object.freeze({})
+});
 function getCapStateKey(partitionKey, rowOrConstraint) {
+	if (partitionKey?.length === 1 && rowOrConstraint) return "cap:" + valueToKey(rowOrConstraint[partitionKey[0]]);
 	const partitionValues = [];
 	if (partitionKey && rowOrConstraint) for (const key of partitionKey) partitionValues.push(rowOrConstraint[key]);
 	return JSON.stringify(["cap", ...partitionValues]);

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

@@ -1 +1 @@
-{"version":3,"file":"cap.js","names":["#input","#storage","#limit","#partitionKey","#partitionKeyComparator","#primaryKey","#output","#initialFetch","#pushEditChange"],"sources":["../../../../../zql/src/ivm/cap.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {makeAddChange, type Change, type EditChange} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n  type Storage,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\nimport {\n  constraintMatchesPartitionKey,\n  makePartitionKeyComparator,\n  type PartitionKey,\n} from './take.ts';\n\ntype CapState = {\n  size: number;\n  pks: string[];\n};\n\ninterface CapStorage {\n  get(key: string): CapState | undefined;\n  set(key: string, value: CapState): void;\n  del(key: string): void;\n  destroy(): void;\n}\n\n/**\n * The Cap operator is a count-based limiter for EXISTS subqueries that\n * does not require ordering. Unlike Take, it tracks membership by primary\n * key set rather than by a sorted bound. This means:\n *\n * - No comparator needed (no ordering requirement)\n * - No `start` or `reverse` fetch support\n * - No `#rowHiddenFromFetch` complexity (we can defer when adding to the pk set)\n *\n * Cap is used in EXISTS child pipelines where only the count of matching\n * rows matters, not their order. This allows SQLite to skip ORDER BY\n * entirely, enabling much faster query plans.\n *\n * Cap can count rows globally or by unique value of some partition key\n * (same as Take).\n */\nexport class Cap implements Operator {\n  readonly #input: Input;\n  readonly #storage: CapStorage;\n  readonly #limit: number;\n  readonly #partitionKey: PartitionKey | undefined;\n  readonly #partitionKeyComparator: Comparator | undefined;\n  readonly #primaryKey: PrimaryKey;\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    input.setOutput(this);\n    this.#input = input;\n    this.#storage = storage as CapStorage;\n    this.#limit = limit;\n    this.#partitionKey = partitionKey;\n    this.#partitionKeyComparator =\n      partitionKey && makePartitionKeyComparator(partitionKey);\n    this.#primaryKey = input.getSchema().primaryKey;\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    assert(!req.start, 'Cap does not support start');\n    assert(!req.reverse, 'Cap does not support reverse');\n\n    // Cap is only built for non-flipped EXISTS subqueries, whose only\n    // downstream consumer is a Join that always fetches with a constraint\n    // built from the correlation's childField — which is Cap's partition\n    // key. So either partitionKey is undefined, or constraint matches.\n    assert(\n      !this.#partitionKey ||\n        (req.constraint !== undefined &&\n          constraintMatchesPartitionKey(req.constraint, this.#partitionKey)),\n      'Cap fetch: constraint must match partition key when partitioned',\n    );\n\n    const capStateKey = getCapStateKey(this.#partitionKey, req.constraint);\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      yield* this.#initialFetch(req);\n      return;\n    }\n    if (capState.size === 0) {\n      return;\n    }\n    // PK-based point lookups: fetch each tracked row by its PK directly,\n    // rather than scanning the partition and filtering.\n    for (const pk of capState.pks) {\n      const pkConstraint = deserializePKToConstraint(pk, this.#primaryKey);\n      // Preserve req.constraint (the partition key) so upstream partitioned\n      // operators (e.g. Take) retain their partition scope and do not throw.\n      const constraint = req.constraint\n        ? {...req.constraint, ...pkConstraint}\n        : pkConstraint;\n      for (const inputNode of this.#input.fetch({constraint})) {\n        if (inputNode === 'yield') {\n          yield inputNode;\n          continue;\n        }\n        yield inputNode;\n      }\n    }\n  }\n\n  *#initialFetch(req: FetchRequest): Stream<Node | 'yield'> {\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 capStateKey = getCapStateKey(this.#partitionKey, req.constraint);\n    assert(\n      this.#storage.get(capStateKey) === undefined,\n      'Cap state should be undefined',\n    );\n\n    let size = 0;\n    const pks: string[] = [];\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        pks.push(serializePK(inputNode.row, this.#primaryKey));\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.#storage.set(capStateKey, {size, pks});\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 capState is properly hydrated.\n        assert(\n          !downstreamEarlyReturn,\n          'Unexpected early return prevented full hydration',\n        );\n      }\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 capStateKey = getCapStateKey(\n      this.#partitionKey,\n      change[ChangeIndex.NODE].row,\n    );\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      return;\n    }\n\n    const pk = serializePK(change[ChangeIndex.NODE].row, this.#primaryKey);\n\n    if (change[ChangeIndex.TYPE] === ChangeType.ADD) {\n      if (capState.size < this.#limit) {\n        const pks = [...capState.pks, pk];\n        this.#storage.set(capStateKey, {size: capState.size + 1, pks});\n        yield* this.#output.push(change, this);\n        return;\n      }\n      // Full — drop\n      return;\n    } else if (change[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      const pkIndex = capState.pks.indexOf(pk);\n      if (pkIndex === -1) {\n        // Not in our set — drop\n        return;\n      }\n      // Remove from set\n      const pks = [...capState.pks];\n      pks.splice(pkIndex, 1);\n      const newSize = capState.size - 1;\n\n      // Try to refill: fetch from input with partition constraint,\n      // find first row NOT in PK set\n      const pkSet = new Set(pks);\n      const constraint = this.#partitionKey\n        ? (Object.fromEntries(\n            this.#partitionKey.map(\n              key => [key, change[ChangeIndex.NODE].row[key]] as const,\n            ),\n          ) as Constraint)\n        : undefined;\n\n      let replacement: Node | undefined;\n      for (const node of this.#input.fetch({constraint})) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        const nodePK = serializePK(node.row, this.#primaryKey);\n        if (!pkSet.has(nodePK)) {\n          replacement = node;\n          break;\n        }\n      }\n\n      if (replacement) {\n        // Store state WITHOUT replacement during remove forward,\n        // matching Take's pattern of hiding in-flight changes from re-fetches.\n        this.#storage.set(capStateKey, {size: newSize, pks});\n        yield* this.#output.push(change, this);\n        // Now add replacement to set and forward the add.\n        const replacementPK = serializePK(replacement.row, this.#primaryKey);\n        pks.push(replacementPK);\n        this.#storage.set(capStateKey, {size: newSize + 1, pks});\n        yield* this.#output.push(makeAddChange(replacement), this);\n      } else {\n        this.#storage.set(capStateKey, {size: newSize, pks});\n        yield* this.#output.push(change, this);\n      }\n    } else if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      const pkSet = new Set(capState.pks);\n      if (pkSet.has(pk)) {\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    const capStateKey = getCapStateKey(\n      this.#partitionKey,\n      change[ChangeIndex.OLD_NODE].row,\n    );\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      return emptyArray;\n    }\n\n    const oldPK = serializePK(\n      change[ChangeIndex.OLD_NODE].row,\n      this.#primaryKey,\n    );\n    const pkSet = new Set(capState.pks);\n    if (pkSet.has(oldPK)) {\n      // Update the PK in our set if it changed\n      const newPK = serializePK(change[ChangeIndex.NODE].row, this.#primaryKey);\n      if (oldPK !== newPK) {\n        const pks = capState.pks.map(p => (p === oldPK ? newPK : p));\n        this.#storage.set(capStateKey, {size: capState.size, pks});\n      }\n      return this.#output.push(change, this);\n    }\n    // If not in our set, drop\n    return emptyArray;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n    this.#storage.destroy();\n  }\n\n  *reconcile(_pusher: InputBase): Stream<'yield'> {\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n}\n\nfunction getCapStateKey(\n  partitionKey: PartitionKey | undefined,\n  rowOrConstraint: Row | Constraint | undefined,\n): string {\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(['cap', ...partitionValues]);\n}\n\nfunction serializePK(row: Row, primaryKey: PrimaryKey): string {\n  return JSON.stringify(primaryKey.map(k => row[k]));\n}\n\nfunction deserializePKToConstraint(\n  pk: string,\n  primaryKey: PrimaryKey,\n): Constraint {\n  const values = JSON.parse(pk) as Value[];\n  const constraint: Record<string, Value> = {};\n  for (let i = 0; i < primaryKey.length; i++) {\n    constraint[primaryKey[i]] = values[i];\n  }\n  return constraint;\n}\n"],"mappings":"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"}
+{"version":3,"file":"cap.js","names":[],"sources":["../../../../../zql/src/ivm/cap.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {makeAddChange, type Change, type EditChange} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport {valueToKey, type Comparator, type Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n  type Storage,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\nimport {\n  constraintMatchesPartitionKey,\n  makePartitionKeyComparator,\n  type PartitionKey,\n} from './take.ts';\n\ntype CapState = {\n  size: number;\n  pks: string[];\n};\n\ninterface CapStorage {\n  get(key: string): CapState | undefined;\n  set(key: string, value: CapState): void;\n  del(key: string): void;\n  destroy(): void;\n}\n\n/**\n * The Cap operator is a count-based limiter for EXISTS subqueries that\n * does not require ordering. Unlike Take, it tracks membership by primary\n * key set rather than by a sorted bound. This means:\n *\n * - No comparator needed (no ordering requirement)\n * - No `start` or `reverse` fetch support\n * - No `#rowHiddenFromFetch` complexity (we can defer when adding to the pk set)\n *\n * Cap is used in EXISTS child pipelines where only the count of matching\n * rows matters, not their order. This allows SQLite to skip ORDER BY\n * entirely, enabling much faster query plans.\n *\n * Cap can count rows globally or by unique value of some partition key\n * (same as Take).\n */\nexport class Cap implements Operator {\n  readonly #input: Input;\n  readonly #storage: CapStorage;\n  readonly #limit: number;\n  readonly #partitionKey: PartitionKey | undefined;\n  readonly #partitionKeyComparator: Comparator | undefined;\n  readonly #primaryKey: PrimaryKey;\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    input.setOutput(this);\n    this.#input = input;\n    this.#storage = storage as CapStorage;\n    this.#limit = limit;\n    this.#partitionKey = partitionKey;\n    this.#partitionKeyComparator =\n      partitionKey && makePartitionKeyComparator(partitionKey);\n    this.#primaryKey = input.getSchema().primaryKey;\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    assert(!req.start, 'Cap does not support start');\n    assert(!req.reverse, 'Cap does not support reverse');\n\n    // Cap is only built for non-flipped EXISTS subqueries, whose only\n    // downstream consumer is a Join that always fetches with a constraint\n    // built from the correlation's childField — which is Cap's partition\n    // key. So either partitionKey is undefined, or constraint matches.\n    assert(\n      !this.#partitionKey ||\n        (req.constraint !== undefined &&\n          constraintMatchesPartitionKey(req.constraint, this.#partitionKey)),\n      'Cap fetch: constraint must match partition key when partitioned',\n    );\n\n    const capStateKey = getCapStateKey(this.#partitionKey, req.constraint);\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      yield* this.#initialFetch(req, capStateKey);\n      return;\n    }\n    if (capState.size === 0) {\n      return;\n    }\n    if (req.countOnly) {\n      for (let i = 0; i < capState.size; i++) {\n        yield placeholderNode;\n      }\n      return;\n    }\n    // PK-based point lookups: fetch each tracked row by its PK directly,\n    // rather than scanning the partition and filtering.\n    for (const pk of capState.pks) {\n      const pkConstraint = deserializePKToConstraint(pk, this.#primaryKey);\n      // Preserve req.constraint (the partition key) so upstream partitioned\n      // operators (e.g. Take) retain their partition scope and do not throw.\n      const constraint = req.constraint\n        ? {...req.constraint, ...pkConstraint}\n        : pkConstraint;\n      for (const inputNode of this.#input.fetch({constraint})) {\n        if (inputNode === 'yield') {\n          yield inputNode;\n          continue;\n        }\n        yield inputNode;\n      }\n    }\n  }\n\n  *#initialFetch(\n    req: FetchRequest,\n    capStateKey: string,\n  ): Stream<Node | 'yield'> {\n    if (this.#limit === 0) {\n      return;\n    }\n\n    assert(\n      constraintMatchesPartitionKey(req.constraint, this.#partitionKey),\n      'Constraint should match partition key',\n    );\n\n    // The caller (fetch) has already checked that there is no state for\n    // capStateKey.\n\n    let size = 0;\n    const pks: string[] = [];\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        pks.push(serializePK(inputNode.row, this.#primaryKey));\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.#storage.set(capStateKey, {size, pks});\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 capState is properly hydrated.\n        assert(\n          !downstreamEarlyReturn,\n          'Unexpected early return prevented full hydration',\n        );\n      }\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 capStateKey = getCapStateKey(\n      this.#partitionKey,\n      change[ChangeIndex.NODE].row,\n    );\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      return;\n    }\n\n    const pk = serializePK(change[ChangeIndex.NODE].row, this.#primaryKey);\n\n    if (change[ChangeIndex.TYPE] === ChangeType.ADD) {\n      if (capState.size < this.#limit) {\n        const pks = [...capState.pks, pk];\n        this.#storage.set(capStateKey, {size: capState.size + 1, pks});\n        yield* this.#output.push(change, this);\n        return;\n      }\n      // Full — drop\n      return;\n    } else if (change[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      const pkIndex = capState.pks.indexOf(pk);\n      if (pkIndex === -1) {\n        // Not in our set — drop\n        return;\n      }\n      // Remove from set\n      const pks = [...capState.pks];\n      pks.splice(pkIndex, 1);\n      const newSize = capState.size - 1;\n\n      // Try to refill: fetch from input with partition constraint,\n      // find first row NOT in PK set\n      const pkSet = new Set(pks);\n      const constraint = this.#partitionKey\n        ? (Object.fromEntries(\n            this.#partitionKey.map(\n              key => [key, change[ChangeIndex.NODE].row[key]] as const,\n            ),\n          ) as Constraint)\n        : undefined;\n\n      let replacement: Node | undefined;\n      for (const node of this.#input.fetch({constraint})) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        const nodePK = serializePK(node.row, this.#primaryKey);\n        if (!pkSet.has(nodePK)) {\n          replacement = node;\n          break;\n        }\n      }\n\n      if (replacement) {\n        // Store state WITHOUT replacement during remove forward,\n        // matching Take's pattern of hiding in-flight changes from re-fetches.\n        this.#storage.set(capStateKey, {size: newSize, pks});\n        yield* this.#output.push(change, this);\n        // Now add replacement to set and forward the add.\n        const replacementPK = serializePK(replacement.row, this.#primaryKey);\n        pks.push(replacementPK);\n        this.#storage.set(capStateKey, {size: newSize + 1, pks});\n        yield* this.#output.push(makeAddChange(replacement), this);\n      } else {\n        this.#storage.set(capStateKey, {size: newSize, pks});\n        yield* this.#output.push(change, this);\n      }\n    } else if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      const pkSet = new Set(capState.pks);\n      if (pkSet.has(pk)) {\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    const capStateKey = getCapStateKey(\n      this.#partitionKey,\n      change[ChangeIndex.OLD_NODE].row,\n    );\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      return emptyArray;\n    }\n\n    const oldPK = serializePK(\n      change[ChangeIndex.OLD_NODE].row,\n      this.#primaryKey,\n    );\n    const pkSet = new Set(capState.pks);\n    if (pkSet.has(oldPK)) {\n      // Update the PK in our set if it changed\n      const newPK = serializePK(change[ChangeIndex.NODE].row, this.#primaryKey);\n      if (oldPK !== newPK) {\n        const pks = capState.pks.map(p => (p === oldPK ? newPK : p));\n        this.#storage.set(capStateKey, {size: capState.size, pks});\n      }\n      return this.#output.push(change, this);\n    }\n    // If not in our set, drop\n    return emptyArray;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n    this.#storage.destroy();\n  }\n\n  *reconcile(_pusher: InputBase): Stream<'yield'> {\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n}\n\n// Yielded for each tracked row of a countOnly fetch.\nconst placeholderNode: Node = Object.freeze({\n  row: Object.freeze({}),\n  relationships: Object.freeze({}),\n});\n\nfunction getCapStateKey(\n  partitionKey: PartitionKey | undefined,\n  rowOrConstraint: Row | Constraint | undefined,\n): string {\n  if (partitionKey?.length === 1 && rowOrConstraint) {\n    return 'cap:' + valueToKey(rowOrConstraint[partitionKey[0]]);\n  }\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(['cap', ...partitionValues]);\n}\n\nfunction serializePK(row: Row, primaryKey: PrimaryKey): string {\n  return JSON.stringify(primaryKey.map(k => row[k]));\n}\n\nfunction deserializePKToConstraint(\n  pk: string,\n  primaryKey: PrimaryKey,\n): Constraint {\n  const values = JSON.parse(pk) as Value[];\n  const constraint: Record<string, Value> = {};\n  for (let i = 0; i < primaryKey.length; i++) {\n    constraint[primaryKey[i]] = values[i];\n  }\n  return constraint;\n}\n"],"mappings":"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"}

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

@@ -12,7 +12,6 @@ export declare function constraintMatchesRow(constraint: Constraint, row: Row):
  */
 export declare function constraintsAreCompatible(left: Constraint, right: Constraint): boolean;
 export declare function constraintMatchesPrimaryKey(constraint: Constraint, primary: PrimaryKey): boolean;
-export declare function keyMatchesPrimaryKey(key: Iterable<string>, primary: PrimaryKey): boolean;
 /**
  * Pulls top level `and` components out of a condition tree.
  * The resulting array of simple conditions would match a superset of
@@ -36,10 +35,4 @@ export declare function pullSimpleAndComponents(condition: Condition): SimpleCon
  * If not, returns undefined.
  */
 export declare function primaryKeyConstraintFromFilters(condition: Condition | undefined, primary: PrimaryKey): Constraint | undefined;
-export declare class SetOfConstraint {
-    #private;
-    constructor();
-    has(value: Constraint): boolean;
-    add(value: Constraint): this;
-}
 //# sourceMappingURL=constraint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"constraint.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/constraint.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,SAAS,EACT,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAC,GAAG,EAAE,KAAK,EAAC,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAG1E,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC;CAC/B,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,GAAG,GACP,OAAO,CAOT;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,UAAU,GAChB,OAAO,CAOT;AAED,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,UAAU,GAClB,OAAO,CAET;AAED,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,EACrB,OAAO,EAAE,UAAU,GAClB,OAAO,CAiBT;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,SAAS,GACnB,eAAe,EAAE,CAcnB;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,OAAO,EAAE,UAAU,GAClB,UAAU,GAAG,SAAS,CA4BxB;AAiBD,qBAAa,eAAe;;IAG1B,cAEC;IAMD,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE9B;IAED,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAK3B;CACF"}
+{"version":3,"file":"constraint.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/constraint.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,SAAS,EACT,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAC,GAAG,EAAE,KAAK,EAAC,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAG1E,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC;CAC/B,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,GAAG,GACP,OAAO,CAOT;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,UAAU,GAChB,OAAO,CAOT;AAED,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,UAAU,GAClB,OAAO,CAET;AAwBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,SAAS,GACnB,eAAe,EAAE,CAcnB;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,OAAO,EAAE,UAAU,GAClB,UAAU,GAAG,SAAS,CA4BxB"}

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

@@ -1,5 +1,6 @@
 import { assert } from "../../../shared/src/asserts.js";
 import { stringCompare } from "../../../shared/src/string-compare.js";
+import { assignProperty } from "../../../shared/src/objects.js";
 import { valuesEqual } from "./data.js";
 //#region ../zql/src/ivm/constraint.ts
 function constraintMatchesRow(constraint, row) {
@@ -61,7 +62,7 @@ function primaryKeyConstraintFromFilters(condition, primary) {
 		const column = extractColumn(subCondition);
 		if (column !== void 0) {
 			if (!primary.includes(column.name)) continue;
-			ret[column.name] = column.value;
+			assignProperty(ret, column.name, column.value);
 		}
 	}
 	if (Object.keys(ret).length !== primary.length) return;
@@ -77,6 +78,6 @@ function extractColumn(condition) {
 	}
 }
 //#endregion
-export { constraintMatchesPrimaryKey, constraintMatchesRow, constraintsAreCompatible, primaryKeyConstraintFromFilters };
+export { constraintMatchesPrimaryKey, constraintMatchesRow, constraintsAreCompatible, primaryKeyConstraintFromFilters, pullSimpleAndComponents };
 
 //# sourceMappingURL=constraint.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"constraint.js","names":["#data","#indexOf"],"sources":["../../../../../zql/src/ivm/constraint.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {stringCompare} from '../../../shared/src/string-compare.ts';\nimport {assertTesting} from '../../../shared/src/testing.ts';\nimport type {Writable} from '../../../shared/src/writable.ts';\nimport type {\n  Condition,\n  SimpleCondition,\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 {valuesEqual} from './data.ts';\n\nexport type Constraint = {\n  readonly [key: string]: Value;\n};\n\nexport function constraintMatchesRow(\n  constraint: Constraint,\n  row: Row,\n): boolean {\n  for (const key in constraint) {\n    if (!valuesEqual(row[key], constraint[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Constraints are compatible if:\n * 1. They do not have any keys in common\n * 2. They have keys in common, but the values for those keys are equal\n */\nexport function constraintsAreCompatible(\n  left: Constraint,\n  right: Constraint,\n): boolean {\n  for (const key in left) {\n    if (key in right && !valuesEqual(left[key], right[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function constraintMatchesPrimaryKey(\n  constraint: Constraint,\n  primary: PrimaryKey,\n): boolean {\n  return keyMatchesPrimaryKey(Object.keys(constraint), primary);\n}\n\nexport function keyMatchesPrimaryKey(\n  key: Iterable<string>,\n  primary: PrimaryKey,\n): boolean {\n  const constraintKeys = [...key];\n\n  if (constraintKeys.length !== primary.length) {\n    return false;\n  }\n\n  // Primary key is always sorted\n  // Constraint does not have to be sorted\n  constraintKeys.sort(stringCompare);\n\n  for (let i = 0; i < constraintKeys.length; i++) {\n    if (constraintKeys[i] !== primary[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Pulls top level `and` components out of a condition tree.\n * The resulting array of simple conditions would match a superset of\n * values that the original condition would match.\n *\n * Examples:\n * a AND b OR c\n *\n * In this case we cannot pull anything because the `or` is at the top level.\n *\n * a AND b AND c\n * We can pull all three.\n *\n * a AND (b OR c)\n * We can only pull `a`.\n */\nexport function pullSimpleAndComponents(\n  condition: Condition,\n): SimpleCondition[] {\n  if (condition.type === 'and') {\n    return condition.conditions.flatMap(pullSimpleAndComponents);\n  }\n\n  if (condition.type === 'simple') {\n    return [condition];\n  }\n\n  if (condition.type === 'or' && condition.conditions.length === 1) {\n    return pullSimpleAndComponents(condition.conditions[0]);\n  }\n\n  return [];\n}\n\n/**\n * Checks if the supplied filters constitute a primary key lookup.\n * If so, returns the constraint that would be used to look up the primary key.\n * If not, returns undefined.\n */\nexport function primaryKeyConstraintFromFilters(\n  condition: Condition | undefined,\n  primary: PrimaryKey,\n): Constraint | undefined {\n  if (condition === undefined) {\n    return undefined;\n  }\n\n  const conditions = pullSimpleAndComponents(condition);\n  if (conditions.length === 0) {\n    return undefined;\n  }\n\n  const ret: Writable<Constraint> = {};\n  for (const subCondition of conditions) {\n    if (subCondition.op === '=') {\n      const column = extractColumn(subCondition);\n      if (column !== undefined) {\n        if (!primary.includes(column.name)) {\n          continue;\n        }\n        ret[column.name] = column.value;\n      }\n    }\n  }\n\n  if (Object.keys(ret).length !== primary.length) {\n    return undefined;\n  }\n\n  return ret;\n}\n\nfunction extractColumn(\n  condition: SimpleCondition,\n): {name: string; value: Value} | undefined {\n  if (condition.left.type === 'column') {\n    assert(\n      condition.right.type === 'literal',\n      () =>\n        `extractColumn: expected right side to be literal, got ${condition.right.type}`,\n    );\n    return {name: condition.left.name, value: condition.right.value};\n  }\n\n  return undefined;\n}\n\nexport class SetOfConstraint {\n  #data: Constraint[] = [];\n\n  constructor() {\n    assertTesting('SetOfConstraint is only available in testing');\n  }\n\n  #indexOf(value: Constraint): number {\n    return this.#data.findIndex(v => constraintEquals(v, value));\n  }\n\n  has(value: Constraint): boolean {\n    return this.#indexOf(value) !== -1;\n  }\n\n  add(value: Constraint): this {\n    if (!this.has(value)) {\n      this.#data.push(value);\n    }\n    return this;\n  }\n}\n\nfunction constraintEquals(a: Constraint, b: Constraint): boolean {\n  const aEntries = Object.entries(a);\n  const bEntries = Object.entries(b);\n  if (aEntries.length !== bEntries.length) {\n    return false;\n  }\n  for (let i = 0; i < aEntries.length; i++) {\n    if (\n      aEntries[i][0] !== bEntries[i][0] ||\n      !valuesEqual(aEntries[i][1], bEntries[i][1])\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":";;;;AAgBA,SAAgB,qBACd,YACA,KACS;CACT,KAAK,MAAM,OAAO,YAChB,IAAI,CAAC,YAAY,IAAI,MAAM,WAAW,IAAI,GACxC,OAAO;CAGX,OAAO;AACT;;;;;;AAOA,SAAgB,yBACd,MACA,OACS;CACT,KAAK,MAAM,OAAO,MAChB,IAAI,OAAO,SAAS,CAAC,YAAY,KAAK,MAAM,MAAM,IAAI,GACpD,OAAO;CAGX,OAAO;AACT;AAEA,SAAgB,4BACd,YACA,SACS;CACT,OAAO,qBAAqB,OAAO,KAAK,UAAU,GAAG,OAAO;AAC9D;AAEA,SAAgB,qBACd,KACA,SACS;CACT,MAAM,iBAAiB,CAAC,GAAG,GAAG;CAE9B,IAAI,eAAe,WAAW,QAAQ,QACpC,OAAO;CAKT,eAAe,KAAK,aAAa;CAEjC,KAAK,IAAI,IAAI,GAAG,IAAI,eAAe,QAAQ,KACzC,IAAI,eAAe,OAAO,QAAQ,IAChC,OAAO;CAGX,OAAO;AACT;;;;;;;;;;;;;;;;;AAkBA,SAAgB,wBACd,WACmB;CACnB,IAAI,UAAU,SAAS,OACrB,OAAO,UAAU,WAAW,QAAQ,uBAAuB;CAG7D,IAAI,UAAU,SAAS,UACrB,OAAO,CAAC,SAAS;CAGnB,IAAI,UAAU,SAAS,QAAQ,UAAU,WAAW,WAAW,GAC7D,OAAO,wBAAwB,UAAU,WAAW,EAAE;CAGxD,OAAO,CAAC;AACV;;;;;;AAOA,SAAgB,gCACd,WACA,SACwB;CACxB,IAAI,cAAc,KAAA,GAChB;CAGF,MAAM,aAAa,wBAAwB,SAAS;CACpD,IAAI,WAAW,WAAW,GACxB;CAGF,MAAM,MAA4B,CAAC;CACnC,KAAK,MAAM,gBAAgB,YACzB,IAAI,aAAa,OAAO,KAAK;EAC3B,MAAM,SAAS,cAAc,YAAY;EACzC,IAAI,WAAW,KAAA,GAAW;GACxB,IAAI,CAAC,QAAQ,SAAS,OAAO,IAAI,GAC/B;GAEF,IAAI,OAAO,QAAQ,OAAO;EAC5B;CACF;CAGF,IAAI,OAAO,KAAK,GAAG,EAAE,WAAW,QAAQ,QACtC;CAGF,OAAO;AACT;AAEA,SAAS,cACP,WAC0C;CAC1C,IAAI,UAAU,KAAK,SAAS,UAAU;EACpC,OACE,UAAU,MAAM,SAAS,iBAEvB,yDAAyD,UAAU,MAAM,MAC7E;EACA,OAAO;GAAC,MAAM,UAAU,KAAK;GAAM,OAAO,UAAU,MAAM;EAAK;CACjE;AAGF"}
+{"version":3,"file":"constraint.js","names":[],"sources":["../../../../../zql/src/ivm/constraint.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {assignProperty} from '../../../shared/src/objects.ts';\nimport {stringCompare} from '../../../shared/src/string-compare.ts';\nimport type {Writable} from '../../../shared/src/writable.ts';\nimport type {\n  Condition,\n  SimpleCondition,\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 {valuesEqual} from './data.ts';\n\nexport type Constraint = {\n  readonly [key: string]: Value;\n};\n\nexport function constraintMatchesRow(\n  constraint: Constraint,\n  row: Row,\n): boolean {\n  for (const key in constraint) {\n    if (!valuesEqual(row[key], constraint[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Constraints are compatible if:\n * 1. They do not have any keys in common\n * 2. They have keys in common, but the values for those keys are equal\n */\nexport function constraintsAreCompatible(\n  left: Constraint,\n  right: Constraint,\n): boolean {\n  for (const key in left) {\n    if (key in right && !valuesEqual(left[key], right[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function constraintMatchesPrimaryKey(\n  constraint: Constraint,\n  primary: PrimaryKey,\n): boolean {\n  return keyMatchesPrimaryKey(Object.keys(constraint), primary);\n}\n\nfunction keyMatchesPrimaryKey(\n  key: Iterable<string>,\n  primary: PrimaryKey,\n): boolean {\n  const constraintKeys = [...key];\n\n  if (constraintKeys.length !== primary.length) {\n    return false;\n  }\n\n  // Primary key is always sorted\n  // Constraint does not have to be sorted\n  constraintKeys.sort(stringCompare);\n\n  for (let i = 0; i < constraintKeys.length; i++) {\n    if (constraintKeys[i] !== primary[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Pulls top level `and` components out of a condition tree.\n * The resulting array of simple conditions would match a superset of\n * values that the original condition would match.\n *\n * Examples:\n * a AND b OR c\n *\n * In this case we cannot pull anything because the `or` is at the top level.\n *\n * a AND b AND c\n * We can pull all three.\n *\n * a AND (b OR c)\n * We can only pull `a`.\n */\nexport function pullSimpleAndComponents(\n  condition: Condition,\n): SimpleCondition[] {\n  if (condition.type === 'and') {\n    return condition.conditions.flatMap(pullSimpleAndComponents);\n  }\n\n  if (condition.type === 'simple') {\n    return [condition];\n  }\n\n  if (condition.type === 'or' && condition.conditions.length === 1) {\n    return pullSimpleAndComponents(condition.conditions[0]);\n  }\n\n  return [];\n}\n\n/**\n * Checks if the supplied filters constitute a primary key lookup.\n * If so, returns the constraint that would be used to look up the primary key.\n * If not, returns undefined.\n */\nexport function primaryKeyConstraintFromFilters(\n  condition: Condition | undefined,\n  primary: PrimaryKey,\n): Constraint | undefined {\n  if (condition === undefined) {\n    return undefined;\n  }\n\n  const conditions = pullSimpleAndComponents(condition);\n  if (conditions.length === 0) {\n    return undefined;\n  }\n\n  const ret: Writable<Constraint> = {};\n  for (const subCondition of conditions) {\n    if (subCondition.op === '=') {\n      const column = extractColumn(subCondition);\n      if (column !== undefined) {\n        if (!primary.includes(column.name)) {\n          continue;\n        }\n        assignProperty(ret, column.name, column.value);\n      }\n    }\n  }\n\n  if (Object.keys(ret).length !== primary.length) {\n    return undefined;\n  }\n\n  return ret;\n}\n\nfunction extractColumn(\n  condition: SimpleCondition,\n): {name: string; value: Value} | undefined {\n  if (condition.left.type === 'column') {\n    assert(\n      condition.right.type === 'literal',\n      () =>\n        `extractColumn: expected right side to be literal, got ${condition.right.type}`,\n    );\n    return {name: condition.left.name, value: condition.right.value};\n  }\n\n  // A 'json' reference reads a value *inside* a JSON column. That value is not\n  // a stored/indexed column, so it can never be a primary-key or join\n  // constraint key; it falls through and is excluded from extraction.\n  return undefined;\n}\n"],"mappings":";;;;;AAgBA,SAAgB,qBACd,YACA,KACS;CACT,KAAK,MAAM,OAAO,YAChB,IAAI,CAAC,YAAY,IAAI,MAAM,WAAW,IAAI,GACxC,OAAO;CAGX,OAAO;AACT;;;;;;AAOA,SAAgB,yBACd,MACA,OACS;CACT,KAAK,MAAM,OAAO,MAChB,IAAI,OAAO,SAAS,CAAC,YAAY,KAAK,MAAM,MAAM,IAAI,GACpD,OAAO;CAGX,OAAO;AACT;AAEA,SAAgB,4BACd,YACA,SACS;CACT,OAAO,qBAAqB,OAAO,KAAK,UAAU,GAAG,OAAO;AAC9D;AAEA,SAAS,qBACP,KACA,SACS;CACT,MAAM,iBAAiB,CAAC,GAAG,GAAG;CAE9B,IAAI,eAAe,WAAW,QAAQ,QACpC,OAAO;CAKT,eAAe,KAAK,aAAa;CAEjC,KAAK,IAAI,IAAI,GAAG,IAAI,eAAe,QAAQ,KACzC,IAAI,eAAe,OAAO,QAAQ,IAChC,OAAO;CAGX,OAAO;AACT;;;;;;;;;;;;;;;;;AAkBA,SAAgB,wBACd,WACmB;CACnB,IAAI,UAAU,SAAS,OACrB,OAAO,UAAU,WAAW,QAAQ,uBAAuB;CAG7D,IAAI,UAAU,SAAS,UACrB,OAAO,CAAC,SAAS;CAGnB,IAAI,UAAU,SAAS,QAAQ,UAAU,WAAW,WAAW,GAC7D,OAAO,wBAAwB,UAAU,WAAW,EAAE;CAGxD,OAAO,CAAC;AACV;;;;;;AAOA,SAAgB,gCACd,WACA,SACwB;CACxB,IAAI,cAAc,KAAA,GAChB;CAGF,MAAM,aAAa,wBAAwB,SAAS;CACpD,IAAI,WAAW,WAAW,GACxB;CAGF,MAAM,MAA4B,CAAC;CACnC,KAAK,MAAM,gBAAgB,YACzB,IAAI,aAAa,OAAO,KAAK;EAC3B,MAAM,SAAS,cAAc,YAAY;EACzC,IAAI,WAAW,KAAA,GAAW;GACxB,IAAI,CAAC,QAAQ,SAAS,OAAO,IAAI,GAC/B;GAEF,eAAe,KAAK,OAAO,MAAM,OAAO,KAAK;EAC/C;CACF;CAGF,IAAI,OAAO,KAAK,GAAG,CAAC,CAAC,WAAW,QAAQ,QACtC;CAGF,OAAO;AACT;AAEA,SAAS,cACP,WAC0C;CAC1C,IAAI,UAAU,KAAK,SAAS,UAAU;EACpC,OACE,UAAU,MAAM,SAAS,iBAEvB,yDAAyD,UAAU,MAAM,MAC7E;EACA,OAAO;GAAC,MAAM,UAAU,KAAK;GAAM,OAAO,UAAU,MAAM;EAAK;CACjE;AAMF"}

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

@@ -11,8 +11,11 @@ export type Node = {
      * Relationships are generated lazily as read.
      * The stream may contain 'yield' to indicate the operator has yielded control.
      * See {@link Operator.fetch} for more details about yields.
+     *
+     * A caller that only counts the nodes can pass `countOnly`, see
+     * `FetchRequest.countOnly`.
      */
-    relationships: Record<string, () => Stream<Node | 'yield'>>;
+    relationships: Record<string, (countOnly?: boolean | undefined) => Stream<Node | 'yield'>>;
 };
 /**
  * Compare two values. The values must be of the same type. This function
@@ -34,6 +37,17 @@ export type NormalizedValue = Exclude<Value, undefined>;
  * of input values, so we just normalize at use when necessary.
  */
 export declare function normalizeUndefined(v: Value): NormalizedValue;
+/**
+ * Encodes a single value for use in a string key, more cheaply than
+ * `JSON.stringify` for strings. Distinct values get distinct keys because
+ * `JSON.stringify` of a value that is not a string never starts with `s`.
+ * `undefined` is encoded like `null`.
+ *
+ * Strings with surrogates also use `JSON.stringify`, which escapes lone
+ * surrogates. Encoded as UTF-8 (e.g. by SQLite), distinct lone surrogates
+ * would otherwise become the same key.
+ */
+export declare function valueToKey(v: Value): string;
 export type Comparator = (r1: Row, r2: Row) => number;
 export declare function makeComparator(order: Ordering, reverse?: boolean): Comparator;
 /**
@@ -43,5 +57,4 @@ export declare function makeComparator(order: Ordering, reverse?: boolean): Comp
  * semantic for your application.
  */
 export declare function valuesEqual(a: Value, b: Value): boolean;
-export declare function drainStreams(node: Node | 'yield'): void;
 //# sourceMappingURL=data.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/data.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,mCAAmC,CAAC;AAChE,OAAO,KAAK,EAAC,GAAG,EAAE,KAAK,EAAC,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG;IACjB,GAAG,EAAE,GAAG,CAAC;IACT;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC;CAC7D,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM,CA4CxD;AAED,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AAExD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,GAAG,eAAe,CAE5D;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,KAAK,MAAM,CAAC;AAEtD,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,UAAU,CA0B7E;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,OAAO,CAMvD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,QAShD"}
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/data.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,mCAAmC,CAAC;AAChE,OAAO,KAAK,EAAC,GAAG,EAAE,KAAK,EAAC,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG;IACjB,GAAG,EAAE,GAAG,CAAC;IACT;;;;;;;OAOG;IACH,aAAa,EAAE,MAAM,CACnB,MAAM,EACN,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,KAAK,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAC5D,CAAC;CACH,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM,CA4CxD;AAED,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AAExD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,GAAG,eAAe,CAE5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAI3C;AAID,MAAM,MAAM,UAAU,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,KAAK,MAAM,CAAC;AAEtD,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,UAAU,CA0B7E;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,OAAO,CAMvD"}

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

@@ -32,6 +32,20 @@ function compareValues(a, b) {
 function normalizeUndefined(v) {
 	return v ?? null;
 }
+/**
+* Encodes a single value for use in a string key, more cheaply than
+* `JSON.stringify` for strings. Distinct values get distinct keys because
+* `JSON.stringify` of a value that is not a string never starts with `s`.
+* `undefined` is encoded like `null`.
+*
+* Strings with surrogates also use `JSON.stringify`, which escapes lone
+* surrogates. Encoded as UTF-8 (e.g. by SQLite), distinct lone surrogates
+* would otherwise become the same key.
+*/
+function valueToKey(v) {
+	return typeof v === "string" && !surrogateRe.test(v) ? "s" + v : JSON.stringify(v ?? null);
+}
+var surrogateRe = /[\ud800-\udfff]/;
 function makeComparator(order, reverse) {
 	if (order.length === 1 && order[0][1] === "asc" && !reverse) {
 		const field = order[0][0];
@@ -61,6 +75,6 @@ function valuesEqual(a, b) {
 	return a === b;
 }
 //#endregion
-export { compareValues, makeComparator, normalizeUndefined, valuesEqual };
+export { compareValues, makeComparator, normalizeUndefined, valueToKey, valuesEqual };
 
 //# sourceMappingURL=data.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"data.js","names":[],"sources":["../../../../../zql/src/ivm/data.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport type {Ordering} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {Stream} from './stream.ts';\n\n/**\n * A row flowing through the pipeline, plus its relationships.\n * Relationships are generated lazily as read.\n */\nexport type Node = {\n  row: Row;\n  /**\n   * Relationships are generated lazily as read.\n   * The stream may contain 'yield' to indicate the operator has yielded control.\n   * See {@link Operator.fetch} for more details about yields.\n   */\n  relationships: Record<string, () => Stream<Node | 'yield'>>;\n};\n\n/**\n * Compare two values. The values must be of the same type. This function\n * throws at runtime if the types differ.\n *\n * Note, this function considers `null === null` and\n * `undefined === undefined`. This is different than SQL. In join code,\n * null must be treated separately.\n *\n * See: https://github.com/rocicorp/mono/pull/2116/files#r1704811479\n *\n * @returns < 0 if a < b, 0 if a === b, > 0 if a > b\n */\nexport function compareValues(a: Value, b: Value): number {\n  a = a ?? null;\n  b = b ?? null;\n\n  if (a === b) {\n    return 0;\n  }\n\n  if (typeof a === 'string' && typeof b === 'string') {\n    // We compare all strings in Zero as UTF-8. This is the default on SQLite\n    // and we need to match it. See:\n    // https://blog.replicache.dev/blog/replicache-11-adventures-in-text-encoding.\n    //\n    // TODO: We could change this since SQLite supports UTF-16. Microbenchmark\n    // to see if there's a big win.\n    //\n    // https://www.sqlite.org/c3ref/create_collation.html\n    return compareUTF8(a, b);\n  }\n\n  if (typeof a === 'number' && typeof b === 'number') {\n    return a - b;\n  }\n\n  if (typeof a === 'boolean' && typeof b === 'boolean') {\n    return a ? 1 : -1;\n  }\n\n  // check with null after since it is less likely to be the common case and we\n  // want to avoid the extra checks in that case\n  if (a === null) {\n    return -1;\n  }\n  if (b === null) {\n    return 1;\n  }\n\n  if (typeof a !== typeof b) {\n    throw new Error(\n      `Cannot compare values of different types: ${typeof a} and ${typeof b}`,\n    );\n  }\n\n  throw new Error(`Unsupported type: ${typeof a}`);\n}\n\nexport type NormalizedValue = Exclude<Value, undefined>;\n\n/**\n * We allow undefined to be passed for the convenience of developers, but we\n * treat it equivalently to null. It's better for perf to not create an copy\n * of input values, so we just normalize at use when necessary.\n */\nexport function normalizeUndefined(v: Value): NormalizedValue {\n  return v ?? null;\n}\n\nexport type Comparator = (r1: Row, r2: Row) => number;\n\nexport function makeComparator(order: Ordering, reverse?: boolean): Comparator {\n  // A single ascending field is the common shape -- it is what every source\n  // ordered by a single-column primary key gets -- and specializing it drops\n  // the loop, the direction test and the reverse test from the hottest\n  // function in hydration.\n  if (order.length === 1 && order[0][1] === 'asc' && !reverse) {\n    const field = order[0][0];\n    return (a, b) => compareValues(a[field], b[field]);\n  }\n\n  const length = order.length;\n  return (a, b) => {\n    // Skip destructuring here since it is hot code. An indexed loop rather\n    // than `for...of` for the same reason: Hermes allocates an iterator and\n    // calls `next()` per element, which costs more than the comparison for an\n    // ordering this short.\n    for (let i = 0; i < length; i++) {\n      const ord = order[i];\n      const comp = compareValues(a[ord[0]], b[ord[0]]);\n      if (comp !== 0) {\n        const result = ord[1] === 'asc' ? comp : -comp;\n        return reverse ? -result : result;\n      }\n    }\n    return 0;\n  };\n}\n\n/**\n * Determine if two values are equal. Note that unlike compareValues() above,\n * this function treats `null` as unequal to itself (and same for `undefined`).\n * This is required to make joins work correctly, but may not be the right\n * semantic for your application.\n */\nexport function valuesEqual(a: Value, b: Value): boolean {\n  // oxlint-disable-next-line eqeqeq\n  if (a == null || b == null) {\n    return false;\n  }\n  return a === b;\n}\n\nexport function drainStreams(node: Node | 'yield') {\n  if (node === 'yield') {\n    return;\n  }\n  for (const stream of Object.values(node.relationships)) {\n    for (const node of stream()) {\n      drainStreams(node);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AA+BA,SAAgB,cAAc,GAAU,GAAkB;CACxD,IAAI,KAAK;CACT,IAAI,KAAK;CAET,IAAI,MAAM,GACR,OAAO;CAGT,IAAI,OAAO,MAAM,YAAY,OAAO,MAAM,UASxC,OAAO,YAAY,GAAG,CAAC;CAGzB,IAAI,OAAO,MAAM,YAAY,OAAO,MAAM,UACxC,OAAO,IAAI;CAGb,IAAI,OAAO,MAAM,aAAa,OAAO,MAAM,WACzC,OAAO,IAAI,IAAI;CAKjB,IAAI,MAAM,MACR,OAAO;CAET,IAAI,MAAM,MACR,OAAO;CAGT,IAAI,OAAO,MAAM,OAAO,GACtB,MAAM,IAAI,MACR,6CAA6C,OAAO,EAAE,OAAO,OAAO,GACtE;CAGF,MAAM,IAAI,MAAM,qBAAqB,OAAO,GAAG;AACjD;;;;;;AASA,SAAgB,mBAAmB,GAA2B;CAC5D,OAAO,KAAK;AACd;AAIA,SAAgB,eAAe,OAAiB,SAA+B;CAK7E,IAAI,MAAM,WAAW,KAAK,MAAM,GAAG,OAAO,SAAS,CAAC,SAAS;EAC3D,MAAM,QAAQ,MAAM,GAAG;EACvB,QAAQ,GAAG,MAAM,cAAc,EAAE,QAAQ,EAAE,MAAM;CACnD;CAEA,MAAM,SAAS,MAAM;CACrB,QAAQ,GAAG,MAAM;EAKf,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAAK;GAC/B,MAAM,MAAM,MAAM;GAClB,MAAM,OAAO,cAAc,EAAE,IAAI,KAAK,EAAE,IAAI,GAAG;GAC/C,IAAI,SAAS,GAAG;IACd,MAAM,SAAS,IAAI,OAAO,QAAQ,OAAO,CAAC;IAC1C,OAAO,UAAU,CAAC,SAAS;GAC7B;EACF;EACA,OAAO;CACT;AACF;;;;;;;AAQA,SAAgB,YAAY,GAAU,GAAmB;CAEvD,IAAI,KAAK,QAAQ,KAAK,MACpB,OAAO;CAET,OAAO,MAAM;AACf"}
+{"version":3,"file":"data.js","names":[],"sources":["../../../../../zql/src/ivm/data.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport type {Ordering} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {Stream} from './stream.ts';\n\n/**\n * A row flowing through the pipeline, plus its relationships.\n * Relationships are generated lazily as read.\n */\nexport type Node = {\n  row: Row;\n  /**\n   * Relationships are generated lazily as read.\n   * The stream may contain 'yield' to indicate the operator has yielded control.\n   * See {@link Operator.fetch} for more details about yields.\n   *\n   * A caller that only counts the nodes can pass `countOnly`, see\n   * `FetchRequest.countOnly`.\n   */\n  relationships: Record<\n    string,\n    (countOnly?: boolean | undefined) => Stream<Node | 'yield'>\n  >;\n};\n\n/**\n * Compare two values. The values must be of the same type. This function\n * throws at runtime if the types differ.\n *\n * Note, this function considers `null === null` and\n * `undefined === undefined`. This is different than SQL. In join code,\n * null must be treated separately.\n *\n * See: https://github.com/rocicorp/mono/pull/2116/files#r1704811479\n *\n * @returns < 0 if a < b, 0 if a === b, > 0 if a > b\n */\nexport function compareValues(a: Value, b: Value): number {\n  a = a ?? null;\n  b = b ?? null;\n\n  if (a === b) {\n    return 0;\n  }\n\n  if (typeof a === 'string' && typeof b === 'string') {\n    // We compare all strings in Zero as UTF-8. This is the default on SQLite\n    // and we need to match it. See:\n    // https://blog.replicache.dev/blog/replicache-11-adventures-in-text-encoding.\n    //\n    // TODO: We could change this since SQLite supports UTF-16. Microbenchmark\n    // to see if there's a big win.\n    //\n    // https://www.sqlite.org/c3ref/create_collation.html\n    return compareUTF8(a, b);\n  }\n\n  if (typeof a === 'number' && typeof b === 'number') {\n    return a - b;\n  }\n\n  if (typeof a === 'boolean' && typeof b === 'boolean') {\n    return a ? 1 : -1;\n  }\n\n  // check with null after since it is less likely to be the common case and we\n  // want to avoid the extra checks in that case\n  if (a === null) {\n    return -1;\n  }\n  if (b === null) {\n    return 1;\n  }\n\n  if (typeof a !== typeof b) {\n    throw new Error(\n      `Cannot compare values of different types: ${typeof a} and ${typeof b}`,\n    );\n  }\n\n  throw new Error(`Unsupported type: ${typeof a}`);\n}\n\nexport type NormalizedValue = Exclude<Value, undefined>;\n\n/**\n * We allow undefined to be passed for the convenience of developers, but we\n * treat it equivalently to null. It's better for perf to not create an copy\n * of input values, so we just normalize at use when necessary.\n */\nexport function normalizeUndefined(v: Value): NormalizedValue {\n  return v ?? null;\n}\n\n/**\n * Encodes a single value for use in a string key, more cheaply than\n * `JSON.stringify` for strings. Distinct values get distinct keys because\n * `JSON.stringify` of a value that is not a string never starts with `s`.\n * `undefined` is encoded like `null`.\n *\n * Strings with surrogates also use `JSON.stringify`, which escapes lone\n * surrogates. Encoded as UTF-8 (e.g. by SQLite), distinct lone surrogates\n * would otherwise become the same key.\n */\nexport function valueToKey(v: Value): string {\n  return typeof v === 'string' && !surrogateRe.test(v)\n    ? 's' + v\n    : JSON.stringify(v ?? null);\n}\n\nconst surrogateRe = /[\\ud800-\\udfff]/;\n\nexport type Comparator = (r1: Row, r2: Row) => number;\n\nexport function makeComparator(order: Ordering, reverse?: boolean): Comparator {\n  // A single ascending field is the common shape -- it is what every source\n  // ordered by a single-column primary key gets -- and specializing it drops\n  // the loop, the direction test and the reverse test from the hottest\n  // function in hydration.\n  if (order.length === 1 && order[0][1] === 'asc' && !reverse) {\n    const field = order[0][0];\n    return (a, b) => compareValues(a[field], b[field]);\n  }\n\n  const length = order.length;\n  return (a, b) => {\n    // Skip destructuring here since it is hot code. An indexed loop rather\n    // than `for...of` for the same reason: Hermes allocates an iterator and\n    // calls `next()` per element, which costs more than the comparison for an\n    // ordering this short.\n    for (let i = 0; i < length; i++) {\n      const ord = order[i];\n      const comp = compareValues(a[ord[0]], b[ord[0]]);\n      if (comp !== 0) {\n        const result = ord[1] === 'asc' ? comp : -comp;\n        return reverse ? -result : result;\n      }\n    }\n    return 0;\n  };\n}\n\n/**\n * Determine if two values are equal. Note that unlike compareValues() above,\n * this function treats `null` as unequal to itself (and same for `undefined`).\n * This is required to make joins work correctly, but may not be the right\n * semantic for your application.\n */\nexport function valuesEqual(a: Value, b: Value): boolean {\n  // oxlint-disable-next-line eqeqeq\n  if (a == null || b == null) {\n    return false;\n  }\n  return a === b;\n}\n"],"mappings":";;;;;;;;;;;;;;AAqCA,SAAgB,cAAc,GAAU,GAAkB;CACxD,IAAI,KAAK;CACT,IAAI,KAAK;CAET,IAAI,MAAM,GACR,OAAO;CAGT,IAAI,OAAO,MAAM,YAAY,OAAO,MAAM,UASxC,OAAO,YAAY,GAAG,CAAC;CAGzB,IAAI,OAAO,MAAM,YAAY,OAAO,MAAM,UACxC,OAAO,IAAI;CAGb,IAAI,OAAO,MAAM,aAAa,OAAO,MAAM,WACzC,OAAO,IAAI,IAAI;CAKjB,IAAI,MAAM,MACR,OAAO;CAET,IAAI,MAAM,MACR,OAAO;CAGT,IAAI,OAAO,MAAM,OAAO,GACtB,MAAM,IAAI,MACR,6CAA6C,OAAO,EAAE,OAAO,OAAO,GACtE;CAGF,MAAM,IAAI,MAAM,qBAAqB,OAAO,GAAG;AACjD;;;;;;AASA,SAAgB,mBAAmB,GAA2B;CAC5D,OAAO,KAAK;AACd;;;;;;;;;;;AAYA,SAAgB,WAAW,GAAkB;CAC3C,OAAO,OAAO,MAAM,YAAY,CAAC,YAAY,KAAK,CAAC,IAC/C,MAAM,IACN,KAAK,UAAU,KAAK,IAAI;AAC9B;AAEA,IAAM,cAAc;AAIpB,SAAgB,eAAe,OAAiB,SAA+B;CAK7E,IAAI,MAAM,WAAW,KAAK,MAAM,EAAE,CAAC,OAAO,SAAS,CAAC,SAAS;EAC3D,MAAM,QAAQ,MAAM,EAAE,CAAC;EACvB,QAAQ,GAAG,MAAM,cAAc,EAAE,QAAQ,EAAE,MAAM;CACnD;CAEA,MAAM,SAAS,MAAM;CACrB,QAAQ,GAAG,MAAM;EAKf,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAAK;GAC/B,MAAM,MAAM,MAAM;GAClB,MAAM,OAAO,cAAc,EAAE,IAAI,KAAK,EAAE,IAAI,GAAG;GAC/C,IAAI,SAAS,GAAG;IACd,MAAM,SAAS,IAAI,OAAO,QAAQ,OAAO,CAAC;IAC1C,OAAO,UAAU,CAAC,SAAS;GAC7B;EACF;EACA,OAAO;CACT;AACF;;;;;;;AAQA,SAAgB,YAAY,GAAU,GAAmB;CAEvD,IAAI,KAAK,QAAQ,KAAK,MACpB,OAAO;CAET,OAAO,MAAM;AACf"}

package/out/zql/src/ivm/deferred-input.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../shared/src/asserts.js";
-import { emptyArray } from "../../../shared/src/sentinels.js";
 import { makeAddChange } from "./change.js";
 import { consume } from "./stream.js";
+import { emptyArray } from "../../../shared/src/sentinels.js";
 //#region ../zql/src/ivm/deferred-input.ts
 /**
 * A placeholder `Input` for a view whose pipeline has not been built yet.

package/out/zql/src/ivm/deferred-input.js.map

@@ -1 +1 @@
-{"version":3,"file":"deferred-input.js","names":["#schema","#build","#input","#destroyed","#output"],"sources":["../../../../../zql/src/ivm/deferred-input.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport {makeAddChange} from './change.ts';\nimport type {Node} from './data.ts';\nimport type {FetchRequest, Input, Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {consume, type Stream} from './stream.ts';\n\n/**\n * A placeholder `Input` for a view whose pipeline has not been built yet.\n *\n * Until {@link attach} is called it behaves like an empty pipeline: `fetch`\n * yields nothing and pushes never happen. When the real pipeline is attached\n * the view is hydrated with a single `fetch`, whose rows are delivered to the\n * view as add changes, so the view sees the data exactly as it would see rows\n * arriving incrementally.\n *\n * This lets `materialize()` stay synchronous and return a view immediately\n * while the expensive pipeline construction and hydration are postponed, for\n * example until the client's replica has been loaded into the IVM sources.\n */\nexport class DeferredInput implements Input {\n  readonly #schema: SourceSchema;\n  readonly #build: () => Input;\n  #output: Output | undefined;\n  #input: Input | undefined;\n  #destroyed = false;\n\n  /**\n   * @param schema The schema the built pipeline reports. Passed in so this\n   *   input can answer `getSchema()` unconditionally, as the `Input` contract\n   *   requires, before its pipeline exists.\n   * @param build Builds the real pipeline. Called once, from {@link attach}.\n   */\n  constructor(schema: SourceSchema, build: () => Input) {\n    this.#schema = schema;\n    this.#build = build;\n  }\n\n  get attached(): boolean {\n    return this.#input !== undefined;\n  }\n\n  get destroyed(): boolean {\n    return this.#destroyed;\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n    this.#input?.setOutput(output);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    return this.#input ? this.#input.fetch(req) : emptyArray;\n  }\n\n  destroy(): void {\n    this.#destroyed = true;\n    this.#input?.destroy();\n  }\n\n  /**\n   * Build the real pipeline and hydrate the output with its current contents.\n   *\n   * Must be called inside the delegate's `batchViewUpdates`; the delegate is\n   * responsible for notifying commit listeners afterwards so views flush.\n   *\n   * If building or hydrating throws, the pipeline is torn down again and this\n   * input stays unattached so the caller can report the failure.\n   */\n  attach(): void {\n    assert(!this.#input, 'DeferredInput: pipeline already attached');\n    assert(!this.#destroyed, 'DeferredInput: cannot attach after destroy');\n    const input = this.#build();\n    const output = this.#output;\n    if (!output) {\n      // The view never asked for output; there is nothing to hydrate.\n      this.#input = input;\n      return;\n    }\n    try {\n      input.setOutput(output);\n      for (const node of input.fetch({})) {\n        if (node === 'yield') {\n          continue;\n        }\n        consume(output.push(makeAddChange(node), input));\n      }\n    } catch (e) {\n      input.destroy();\n      throw e;\n    }\n    this.#input = input;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqBA,IAAa,gBAAb,MAA4C;CAC1C;CACA;CACA;CACA;CACA,aAAa;;;;;;;CAQb,YAAY,QAAsB,OAAoB;EACpD,KAAKA,UAAU;EACf,KAAKC,SAAS;CAChB;CAEA,IAAI,WAAoB;EACtB,OAAO,KAAKC,WAAW,KAAA;CACzB;CAEA,IAAI,YAAqB;EACvB,OAAO,KAAKC;CACd;CAEA,UAAU,QAAsB;EAC9B,KAAKC,UAAU;EACf,KAAKF,QAAQ,UAAU,MAAM;CAC/B;CAEA,YAA0B;EACxB,OAAO,KAAKF;CACd;CAEA,MAAM,KAA2C;EAC/C,OAAO,KAAKE,SAAS,KAAKA,OAAO,MAAM,GAAG,IAAI;CAChD;CAEA,UAAgB;EACd,KAAKC,aAAa;EAClB,KAAKD,QAAQ,QAAQ;CACvB;;;;;;;;;;CAWA,SAAe;EACb,OAAO,CAAC,KAAKA,QAAQ,0CAA0C;EAC/D,OAAO,CAAC,KAAKC,YAAY,4CAA4C;EACrE,MAAM,QAAQ,KAAKF,OAAO;EAC1B,MAAM,SAAS,KAAKG;EACpB,IAAI,CAAC,QAAQ;GAEX,KAAKF,SAAS;GACd;EACF;EACA,IAAI;GACF,MAAM,UAAU,MAAM;GACtB,KAAK,MAAM,QAAQ,MAAM,MAAM,CAAC,CAAC,GAAG;IAClC,IAAI,SAAS,SACX;IAEF,QAAQ,OAAO,KAAK,cAAc,IAAI,GAAG,KAAK,CAAC;GACjD;EACF,SAAS,GAAG;GACV,MAAM,QAAQ;GACd,MAAM;EACR;EACA,KAAKA,SAAS;CAChB;AACF"}
+{"version":3,"file":"deferred-input.js","names":[],"sources":["../../../../../zql/src/ivm/deferred-input.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport {makeAddChange} from './change.ts';\nimport type {Node} from './data.ts';\nimport type {FetchRequest, Input, Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {consume, type Stream} from './stream.ts';\n\n/**\n * A placeholder `Input` for a view whose pipeline has not been built yet.\n *\n * Until {@link attach} is called it behaves like an empty pipeline: `fetch`\n * yields nothing and pushes never happen. When the real pipeline is attached\n * the view is hydrated with a single `fetch`, whose rows are delivered to the\n * view as add changes, so the view sees the data exactly as it would see rows\n * arriving incrementally.\n *\n * This lets `materialize()` stay synchronous and return a view immediately\n * while the expensive pipeline construction and hydration are postponed, for\n * example until the client's replica has been loaded into the IVM sources.\n */\nexport class DeferredInput implements Input {\n  readonly #schema: SourceSchema;\n  readonly #build: () => Input;\n  #output: Output | undefined;\n  #input: Input | undefined;\n  #destroyed = false;\n\n  /**\n   * @param schema The schema the built pipeline reports. Passed in so this\n   *   input can answer `getSchema()` unconditionally, as the `Input` contract\n   *   requires, before its pipeline exists.\n   * @param build Builds the real pipeline. Called once, from {@link attach}.\n   */\n  constructor(schema: SourceSchema, build: () => Input) {\n    this.#schema = schema;\n    this.#build = build;\n  }\n\n  get attached(): boolean {\n    return this.#input !== undefined;\n  }\n\n  get destroyed(): boolean {\n    return this.#destroyed;\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n    this.#input?.setOutput(output);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    return this.#input ? this.#input.fetch(req) : emptyArray;\n  }\n\n  destroy(): void {\n    this.#destroyed = true;\n    this.#input?.destroy();\n  }\n\n  /**\n   * Build the real pipeline and hydrate the output with its current contents.\n   *\n   * Must be called inside the delegate's `batchViewUpdates`; the delegate is\n   * responsible for notifying commit listeners afterwards so views flush.\n   *\n   * If building or hydrating throws, the pipeline is torn down again and this\n   * input stays unattached so the caller can report the failure.\n   */\n  attach(): void {\n    assert(!this.#input, 'DeferredInput: pipeline already attached');\n    assert(!this.#destroyed, 'DeferredInput: cannot attach after destroy');\n    const input = this.#build();\n    const output = this.#output;\n    if (!output) {\n      // The view never asked for output; there is nothing to hydrate.\n      this.#input = input;\n      return;\n    }\n    try {\n      input.setOutput(output);\n      for (const node of input.fetch({})) {\n        if (node === 'yield') {\n          continue;\n        }\n        consume(output.push(makeAddChange(node), input));\n      }\n    } catch (e) {\n      input.destroy();\n      throw e;\n    }\n    this.#input = input;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqBA,IAAa,gBAAb,MAA4C;CAC1C;CACA;CACA;CACA;CACA,aAAa;;;;;;;CAQb,YAAY,QAAsB,OAAoB;EACpD,KAAK,UAAU;EACf,KAAK,SAAS;CAChB;CAEA,IAAI,WAAoB;EACtB,OAAO,KAAK,WAAW,KAAA;CACzB;CAEA,IAAI,YAAqB;EACvB,OAAO,KAAK;CACd;CAEA,UAAU,QAAsB;EAC9B,KAAK,UAAU;EACf,KAAK,QAAQ,UAAU,MAAM;CAC/B;CAEA,YAA0B;EACxB,OAAO,KAAK;CACd;CAEA,MAAM,KAA2C;EAC/C,OAAO,KAAK,SAAS,KAAK,OAAO,MAAM,GAAG,IAAI;CAChD;CAEA,UAAgB;EACd,KAAK,aAAa;EAClB,KAAK,QAAQ,QAAQ;CACvB;;;;;;;;;;CAWA,SAAe;EACb,OAAO,CAAC,KAAK,QAAQ,0CAA0C;EAC/D,OAAO,CAAC,KAAK,YAAY,4CAA4C;EACrE,MAAM,QAAQ,KAAK,OAAO;EAC1B,MAAM,SAAS,KAAK;EACpB,IAAI,CAAC,QAAQ;GAEX,KAAK,SAAS;GACd;EACF;EACA,IAAI;GACF,MAAM,UAAU,MAAM;GACtB,KAAK,MAAM,QAAQ,MAAM,MAAM,CAAC,CAAC,GAAG;IAClC,IAAI,SAAS,SACX;IAEF,QAAQ,OAAO,KAAK,cAAc,IAAI,GAAG,KAAK,CAAC;GACjD;EACF,SAAS,GAAG;GACV,MAAM,QAAQ;GACd,MAAM;EACR;EACA,KAAK,SAAS;CAChB;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/exists.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;AAGnE,OAAO,EAAkC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACzE,OAAO,EAAqB,KAAK,IAAI,EAAuB,MAAM,WAAW,CAAC;AAC9E,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC;;;GAGG;AACH,qBAAa,MAAO,YAAW,cAAc;;IAoB3C,YACE,KAAK,EAAE,WAAW,EAClB,gBAAgB,EAAE,MAAM,EACxB,aAAa,EAAE,WAAW,EAC1B,IAAI,EAAE,QAAQ,GAAG,YAAY,EAC7B,wBAAwB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAoB/C;IAED,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAE1C;IAED,WAAW,SAEV;IAED,SAAS,SAGR;IAEA,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,CAmBtD;IAED,OAAO,IAAI,IAAI,CAEd;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAI9C;IAEA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAmGrC;CAyDF"}
+{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/exists.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;AAGnE,OAAO,EAAkC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACzE,OAAO,EAGL,KAAK,IAAI,EAEV,MAAM,WAAW,CAAC;AACnB,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC;;;GAGG;AACH,qBAAa,MAAO,YAAW,cAAc;;IAoB3C,YACE,KAAK,EAAE,WAAW,EAClB,gBAAgB,EAAE,MAAM,EACxB,aAAa,EAAE,WAAW,EAC1B,IAAI,EAAE,QAAQ,GAAG,YAAY,EAC7B,wBAAwB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAoB/C;IAED,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAE1C;IAED,WAAW,SAEV;IAED,SAAS,SAGR;IAEA,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,CAmBtD;IAED,OAAO,IAAI,IAAI,CAEd;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAI9C;IAEA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAmGrC;CA6EF"}