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

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"union-fan-in.js","names":["#inputs","#schema","#fanOutPushStarted","#pushInternalChange","#accumulatedPushes","#output"],"sources":["../../../../../zql/src/ivm/union-fan-in.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Writable} from '../../../shared/src/writable.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport type {Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n} from './operator.ts';\nimport {\n  makeAddEmptyRelationships,\n  mergeRelationships,\n  pushAccumulatedChanges,\n} from './push-accumulated.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {first, type Stream} from './stream.ts';\nimport type {UnionFanOut} from './union-fan-out.ts';\n\nexport class UnionFanIn implements Operator {\n  readonly #inputs: readonly Input[];\n  readonly #schema: SourceSchema;\n  #fanOutPushStarted: boolean = false;\n  #output: Output = throwOutput;\n  #accumulatedPushes: Change[] = [];\n\n  constructor(fanOut: UnionFanOut, inputs: Input[]) {\n    this.#inputs = inputs;\n    const fanOutSchema = fanOut.getSchema();\n    fanOut.setFanIn(this);\n    assert(fanOutSchema.sort !== undefined, 'UnionFanIn requires sorted input');\n\n    const schema: Writable<SourceSchema> = {\n      tableName: fanOutSchema.tableName,\n      columns: fanOutSchema.columns,\n      primaryKey: fanOutSchema.primaryKey,\n      relationships: {\n        ...fanOutSchema.relationships,\n      },\n      isHidden: fanOutSchema.isHidden,\n      system: fanOutSchema.system,\n      compareRows: fanOutSchema.compareRows,\n      sort: fanOutSchema.sort,\n    };\n\n    // now go through inputs and merge relationships\n    const relationshipsFromBranches: Set<string> = new Set();\n    for (const input of inputs) {\n      const inputSchema = input.getSchema();\n      assert(\n        schema.tableName === inputSchema.tableName,\n        `Table name mismatch in union fan-in: ${schema.tableName} !== ${inputSchema.tableName}`,\n      );\n      assert(\n        schema.primaryKey === inputSchema.primaryKey,\n        `Primary key mismatch in union fan-in`,\n      );\n      assert(\n        schema.system === inputSchema.system,\n        `System mismatch in union fan-in: ${schema.system} !== ${inputSchema.system}`,\n      );\n      assert(\n        schema.compareRows === inputSchema.compareRows,\n        `compareRows mismatch in union fan-in`,\n      );\n      assert(schema.sort === inputSchema.sort, `Sort mismatch in union fan-in`);\n\n      for (const [relName, relSchema] of Object.entries(\n        inputSchema.relationships,\n      )) {\n        if (relName in fanOutSchema.relationships) {\n          continue;\n        }\n\n        // All branches will have unique relationship names except for relationships\n        // that come in from `fanOut`.\n        assert(\n          !relationshipsFromBranches.has(relName),\n          `Relationship ${relName} exists in multiple upstream inputs to union fan-in`,\n        );\n        schema.relationships[relName] = relSchema;\n        relationshipsFromBranches.add(relName);\n      }\n\n      input.setOutput(this);\n    }\n\n    this.#schema = schema;\n    this.#inputs = inputs;\n  }\n\n  destroy(): void {\n    for (const input of this.#inputs) {\n      input.destroy();\n    }\n  }\n\n  fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    const iterables = this.#inputs.map(input => input.fetch(req));\n    return mergeFetches(iterables, (l, r) =>\n      this.#schema.compareRows(l.row, r.row),\n    );\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  *push(change: Change, pusher: InputBase): Stream<'yield'> {\n    if (!this.#fanOutPushStarted) {\n      yield* this.#pushInternalChange(change, pusher);\n    } else {\n      this.#accumulatedPushes.push(change);\n    }\n  }\n\n  /**\n   * An internal change means that a change was received inside the fan-out/fan-in sub-graph.\n   *\n   * These changes always come from children of a flip-join as no other push generating operators\n   * currently exist between union-fan-in and union-fan-out. All other pushes\n   * enter into union-fan-out before reaching union-fan-in.\n   *\n   * - normal joins for `exists` come before `union-fan-out`\n   * - joins for `related` come after `union-fan-out`\n   * - take comes after `union-fan-out`\n   *\n   * The algorithm for deciding whether or not to forward a push that came from inside the ufo/ufi sub-graph:\n   * 1. If the change is a `child` change we can forward it. This is because all child branches in the ufo/ufi sub-graph are unique.\n   * 2. If the change is `add` we can forward it iff no `fetches` for the row return any results.\n   *    If another branch has it, the add was already emitted in the past.\n   * 3. If the change is `remove` we can forward it iff no `fetches` for the row return any results.\n   *    If no other branches have the change, the remove can be sent as the value is no longer present.\n   *    If other branches have it, the last branch the processes the remove will send the remove.\n   * 4. Edits will always come through as child changes as flip join will flip them into children.\n   *    An edit that would result in a remove or add will have been split into an add/remove pair rather than being an edit.\n   */\n  *#pushInternalChange(change: Change, pusher: InputBase): Stream<'yield'> {\n    if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      yield* this.#output.push(change, this);\n      return;\n    }\n\n    assert(\n      change[ChangeIndex.TYPE] === ChangeType.ADD ||\n        change[ChangeIndex.TYPE] === ChangeType.REMOVE,\n      () =>\n        `UnionFanIn: expected add or remove change type, got ${change[ChangeIndex.TYPE]}`,\n    );\n\n    let hadMatch = false;\n    for (const input of this.#inputs) {\n      if (input === pusher) {\n        hadMatch = true;\n        continue;\n      }\n\n      const constraint: Writable<Constraint> = {};\n      for (const key of this.#schema.primaryKey) {\n        constraint[key] = change[ChangeIndex.NODE].row[key];\n      }\n      const fetchResult = input.fetch({\n        constraint,\n      });\n\n      if (first(fetchResult) !== undefined) {\n        // Another branch has the row, so the add/remove is not needed.\n        return;\n      }\n    }\n\n    assert(hadMatch, 'Pusher was not one of the inputs to union-fan-in!');\n\n    // No other branches have the row, so we can push the change.\n    yield* this.#output.push(change, this);\n  }\n\n  fanOutStartedPushing() {\n    assert(\n      this.#fanOutPushStarted === false,\n      'UnionFanIn: fanOutStartedPushing called while already pushing',\n    );\n    this.#fanOutPushStarted = true;\n  }\n\n  *fanOutDonePushing(fanOutChangeType: ChangeType): Stream<'yield'> {\n    assert(\n      this.#fanOutPushStarted,\n      'UnionFanIn: fanOutDonePushing called without fanOutStartedPushing',\n    );\n    this.#fanOutPushStarted = false;\n    if (this.#inputs.length === 0) {\n      return;\n    }\n\n    if (this.#accumulatedPushes.length === 0) {\n      // It is possible for no forks to pass along the push.\n      // E.g., if no filters match in any fork.\n      return;\n    }\n\n    yield* pushAccumulatedChanges(\n      this.#accumulatedPushes,\n      this.#output,\n      this,\n      fanOutChangeType,\n      mergeRelationships,\n      makeAddEmptyRelationships(this.#schema),\n    );\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n}\n\nexport function* mergeFetches(\n  fetches: Iterable<Node | 'yield'>[],\n  comparator: (l: Node, r: Node) => number,\n): IterableIterator<Node | 'yield'> {\n  const iterators = fetches.map(i => i[Symbol.iterator]());\n  let threw = false;\n  try {\n    const current: (Node | null)[] = [];\n    let lastNodeYielded: Node | undefined;\n    for (let i = 0; i < iterators.length; i++) {\n      const iter = iterators[i];\n      let result = iter.next();\n      // yield yields when initializing\n      while (!result.done && result.value === 'yield') {\n        yield result.value;\n        result = iter.next();\n      }\n      current[i] = result.done ? null : (result.value as Node);\n    }\n    while (current.some(c => c !== null)) {\n      const min = current.reduce(\n        (acc: [Node, number] | undefined, c, i): [Node, number] | undefined => {\n          if (c === null) {\n            return acc;\n          }\n          if (acc === undefined || comparator(c, acc[0]) < 0) {\n            return [c, i];\n          }\n          return acc;\n        },\n        undefined,\n      );\n\n      assert(min !== undefined, 'min is undefined');\n      const [minNode, minIndex] = min;\n      const iter = iterators[minIndex];\n      let result = iter.next();\n      while (!result.done && result.value === 'yield') {\n        yield result.value;\n        result = iter.next();\n      }\n      current[minIndex] = result.done ? null : (result.value as Node);\n      if (\n        lastNodeYielded !== undefined &&\n        comparator(lastNodeYielded, minNode) === 0\n      ) {\n        continue;\n      }\n      lastNodeYielded = minNode;\n      yield minNode;\n    }\n  } catch (e) {\n    threw = true;\n    for (const iter of iterators) {\n      try {\n        iter.throw?.(e);\n      } catch (_cleanupError) {\n        // error in the iter.throw cleanup,\n        // catch so other iterators are cleaned up\n      }\n    }\n    throw e;\n  } finally {\n    if (!threw) {\n      for (const iter of iterators) {\n        try {\n          iter.return?.();\n        } catch (_cleanupError) {\n          // error in the iter.return cleanup,\n          // catch so other iterators are cleaned up\n        }\n      }\n    }\n  }\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"union-fan-out.js","names":["#input","#outputs","#unionFanIn","#destroyCount"],"sources":["../../../../../zql/src/ivm/union-fan-out.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport type {Change} from './change.ts';\nimport type {Node} from './data.ts';\nimport type {FetchRequest, Input, Operator, Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\nimport type {UnionFanIn} from './union-fan-in.ts';\n\nexport class UnionFanOut implements Operator {\n  #destroyCount: number = 0;\n  #unionFanIn?: UnionFanIn;\n  readonly #input: Input;\n  readonly #outputs: Output[] = [];\n\n  constructor(input: Input) {\n    this.#input = input;\n    input.setOutput(this);\n  }\n\n  setFanIn(fanIn: UnionFanIn) {\n    assert(!this.#unionFanIn, 'FanIn already set for this FanOut');\n    this.#unionFanIn = fanIn;\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    must(this.#unionFanIn).fanOutStartedPushing();\n    for (const output of this.#outputs) {\n      yield* output.push(change, this);\n    }\n    yield* must(this.#unionFanIn).fanOutDonePushing(change[ChangeIndex.TYPE]);\n  }\n\n  setOutput(output: Output): void {\n    this.#outputs.push(output);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    return this.#input.fetch(req);\n  }\n\n  destroy(): void {\n    if (this.#destroyCount < this.#outputs.length) {\n      ++this.#destroyCount;\n      if (this.#destroyCount === this.#outputs.length) {\n        this.#input.destroy();\n      }\n    } else {\n      throw new Error('FanOut already destroyed once for each output');\n    }\n  }\n}\n"],"mappings":";;;AAUA,IAAa,cAAb,MAA6C;CAC3C,gBAAwB;CACxB;CACA;CACA,WAA8B,EAAE;CAEhC,YAAY,OAAc;AACxB,QAAA,QAAc;AACd,QAAM,UAAU,KAAK;;CAGvB,SAAS,OAAmB;AAC1B,SAAO,CAAC,MAAA,YAAkB,oCAAoC;AAC9D,QAAA,aAAmB;;CAGrB,CAAC,KAAK,QAAiC;AACrC,OAAK,MAAA,WAAiB,CAAC,sBAAsB;AAC7C,OAAK,MAAM,UAAU,MAAA,QACnB,QAAO,OAAO,KAAK,QAAQ,KAAK;AAElC,SAAO,KAAK,MAAA,WAAiB,CAAC,kBAAkB,OAAO,GAAkB;;CAG3E,UAAU,QAAsB;AAC9B,QAAA,QAAc,KAAK,OAAO;;CAG5B,YAA0B;AACxB,SAAO,MAAA,MAAY,WAAW;;CAGhC,MAAM,KAA2C;AAC/C,SAAO,MAAA,MAAY,MAAM,IAAI;;CAG/B,UAAgB;AACd,MAAI,MAAA,eAAqB,MAAA,QAAc,QAAQ;AAC7C,KAAE,MAAA;AACF,OAAI,MAAA,iBAAuB,MAAA,QAAc,OACvC,OAAA,MAAY,SAAS;QAGvB,OAAM,IAAI,MAAM,gDAAgD"}

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

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

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

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

package/out/zql/src/mutate/custom.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"custom.js","names":[],"sources":["../../../../../zql/src/mutate/custom.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {\n  DefaultSchema,\n  DefaultWrappedTransaction,\n} from '../../../zero-types/src/default-types.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {ServerSchema} from '../../../zero-types/src/server-schema.ts';\nimport type {Format} from '../ivm/view.ts';\nimport type {HumanReadable, Query, RunOptions} from '../query/query.ts';\nimport type {ConditionalSchemaQuery} from '../query/schema-query.ts';\nimport type {CRUDMutateRequest, SchemaCRUD, TransactionMutate} from './crud.ts';\n\ntype ClientID = string;\n\n/**\n * A base transaction interface that any Transaction<S, T> is assignable to.\n * Used in places where the schema type doesn't need to be preserved,\n * like the public signature of Mutator.fn.\n */\nexport interface AnyTransaction {\n  readonly location: Location;\n  readonly clientID: string;\n  readonly mutationID: number;\n  readonly reason: TransactionReason;\n}\n\nexport type Location = 'client' | 'server';\nexport type TransactionReason = 'optimistic' | 'rebase' | 'authoritative';\n\nexport interface TransactionBase<S extends Schema> {\n  readonly location: Location;\n  readonly clientID: ClientID;\n  /**\n   * The ID of the mutation that is being applied.\n   */\n  readonly mutationID: number;\n\n  /**\n   * The reason for the transaction.\n   */\n  readonly reason: TransactionReason;\n\n  readonly mutate: TransactionMutate<S>;\n  /**\n   * @deprecated Use {@linkcode createBuilder} with `tx.run(zql.table.where(...))` instead.\n   */\n  readonly query: ConditionalSchemaQuery<S>;\n\n  run<TTable extends keyof S['tables'] & string, TReturn>(\n    query: Query<TTable, S, TReturn>,\n    options?: RunOptions,\n  ): Promise<HumanReadable<TReturn>>;\n}\n\nexport type Transaction<\n  S extends Schema = DefaultSchema,\n  TWrappedTransaction = DefaultWrappedTransaction,\n> = ServerTransaction<S, TWrappedTransaction> | ClientTransaction<S>;\n\nexport interface ServerTransaction<\n  S extends Schema = DefaultSchema,\n  TWrappedTransaction = DefaultWrappedTransaction,\n> extends TransactionBase<S> {\n  readonly location: 'server';\n  readonly reason: 'authoritative';\n  readonly dbTransaction: DBTransaction<TWrappedTransaction>;\n}\n\n/**\n * An instance of this is passed to custom mutator implementations and\n * allows reading and writing to the database and IVM at the head at which the\n * mutator is being applied.\n */\nexport interface ClientTransaction<\n  S extends Schema = DefaultSchema,\n> extends TransactionBase<S> {\n  readonly location: 'client';\n  readonly reason: 'optimistic' | 'rebase';\n}\n\nexport interface Row {\n  [column: string]: unknown;\n}\n\nexport interface DBConnection<TWrappedTransaction> {\n  transaction: <T>(\n    cb: (tx: DBTransaction<TWrappedTransaction>) => Promise<T>,\n  ) => Promise<T>;\n}\n\nexport interface DBTransaction<T> extends Queryable {\n  readonly wrappedTransaction: T;\n  runQuery<TReturn>(\n    ast: AST,\n    format: Format,\n    schema: Schema,\n    serverSchema: ServerSchema,\n  ): Promise<HumanReadable<TReturn>>;\n}\n\ninterface Queryable {\n  query: (query: string, args: unknown[]) => Promise<Iterable<Row>>;\n}\n\n/**\n * A callable mutate shape with optional table helpers used by helper factories\n * like `makeMutateCRUD`. Transactions expose `SchemaCRUD` instead of this type.\n */\nexport type MutateCRUD<S extends Schema, AddSchemaCRUD extends boolean> = {\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  (request: CRUDMutateRequest<S, any, any, any>): Promise<void>;\n} & (AddSchemaCRUD extends true ? SchemaCRUD<S> : {});\n\nexport function customMutatorKey(sep: string, parts: string[]) {\n  for (const part of parts) {\n    assert(\n      !part.includes(sep),\n      `mutator names/namespaces must not include a ${sep}`,\n    );\n  }\n  return parts.join(sep);\n}\n"],"mappings":";;AAkHA,SAAgB,iBAAiB,KAAa,OAAiB;AAC7D,MAAK,MAAM,QAAQ,MACjB,QACE,CAAC,KAAK,SAAS,IAAI,EACnB,+CAA+C,MAChD;AAEH,QAAO,MAAM,KAAK,IAAI"}

package/out/zql/src/mutate/mutator-registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutator-registry.js","names":[],"sources":["../../../../../zql/src/mutate/mutator-registry.ts"],"sourcesContent":["import {\n  deepMerge,\n  isPlainObject,\n  type DeepMerge,\n} from '../../../shared/src/deep-merge.ts';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {\n  getValueAtPath,\n  iterateLeaves,\n} from '../../../shared/src/object-traversal.ts';\nimport type {\n  BaseDefaultSchema,\n  DefaultSchema,\n} from '../../../zero-types/src/default-types.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport {validateInput} from '../query/validate-input.ts';\nimport type {Transaction} from './custom.ts';\nimport {\n  isMutator,\n  isMutatorDefinition,\n  type AnyMutator,\n  type AnyMutatorDefinition,\n  type MutateRequest,\n  type MutateRequestTypes,\n  type Mutator,\n  type MutatorDefinition,\n  type MutatorExecutionFunction,\n  type MutatorTypes,\n} from './mutator.ts';\n\n/**\n * Creates a MutatorRegistry from a tree of MutatorDefinitions,\n * optionally extending a base MutatorRegistry.\n *\n * @example\n * ```ts\n * // Create a new registry\n * const mutators = defineMutators({\n *   user: {\n *     create: defineMutator(...),\n *     delete: defineMutator(...),\n *   },\n *   post: {\n *     publish: defineMutator(...),\n *   },\n * });\n *\n * // Extend an existing registry (e.g., for server-side overrides)\n * const serverMutators = defineMutators(mutators, {\n *   user: {\n *     create: defineMutator(...),  // overrides mutators.user.create\n *   },\n *   // post.publish is inherited from mutators\n * });\n *\n * // Access mutators by path\n * const mr = mutators.user.create({name: 'Alice'});\n *\n * // Execute on client\n * zero.mutate(mr);\n *\n * // Execute on server\n * mr.mutator.fn({tx, ctx, args: mr.args});\n *\n * // Lookup by name (for server-side dispatch)\n * const mutator = getMutator(mutators, 'user.create');\n * ```\n */\nexport function defineMutators<\n  // let MD infer freely so defaults aren't erased by a MutatorDefinitions constraint\n  const MD,\n  S extends BaseDefaultSchema = DefaultSchema,\n>(\n  // we assert types here for clear error messages\n  definitions: MD & AssertMutatorDefinitions<MD>,\n): MutatorRegistry<EnsureMutatorDefinitions<MD>, S>;\n\nexport function defineMutators<\n  // same as MD above, but for TBase and TOverrides\n  const TBase,\n  const TOverrides,\n  S extends BaseDefaultSchema = DefaultSchema,\n>(\n  base:\n    | MutatorRegistry<EnsureMutatorDefinitions<TBase>, S>\n    | (TBase & AssertMutatorDefinitions<TBase>),\n  overrides: TOverrides & AssertMutatorDefinitions<TOverrides>,\n): MutatorRegistry<\n  DeepMerge<\n    EnsureMutatorDefinitions<TBase>,\n    EnsureMutatorDefinitions<TOverrides>,\n    AnyMutatorDefinition\n  >,\n  S\n>;\n\nexport function defineMutators(\n  definitionsOrBase: MutatorDefinitions | AnyMutatorRegistry,\n  maybeOverrides?: MutatorDefinitions,\n): AnyMutatorRegistry {\n  function processDefinitions(\n    definitions: MutatorDefinitions,\n    path: string[],\n  ): Record<string | symbol, unknown> {\n    const result: Record<string | symbol, unknown> = {\n      ['~']: 'MutatorRegistry',\n    };\n\n    for (const [key, value] of Object.entries(definitions)) {\n      path.push(key);\n      const name = path.join('.');\n\n      if (isMutatorDefinition(value)) {\n        result[key] = createMutator(name, value);\n      } else {\n        // Nested definitions\n        result[key] = processDefinitions(value, path);\n      }\n      path.pop();\n    }\n\n    return result;\n  }\n\n  if (maybeOverrides !== undefined) {\n    // Merge base and overrides\n    let base: Record<string | symbol, unknown>;\n    if (!isMutatorRegistry(definitionsOrBase)) {\n      base = processDefinitions(definitionsOrBase, []);\n    } else {\n      base = definitionsOrBase;\n    }\n\n    const processed = processDefinitions(maybeOverrides, []);\n\n    const merged = deepMerge(base, processed, isMutatorLeaf);\n    merged['~'] = 'MutatorRegistry';\n    return merged as AnyMutatorRegistry;\n  }\n\n  return processDefinitions(\n    definitionsOrBase as MutatorDefinitions,\n    [],\n  ) as AnyMutatorRegistry;\n}\n\nconst isMutatorLeaf = (value: unknown): boolean =>\n  !isPlainObject(value) || isMutator(value);\n\n/**\n * Creates a function that can be used to define mutators with a specific schema.\n */\nexport function defineMutatorsWithType<\n  TSchema extends Schema,\n>(): TypedDefineMutators<TSchema> {\n  return defineMutators;\n}\n\n/**\n * The return type of defineMutatorsWithType. A function matching the\n * defineMutators overloads but with Schema pre-bound.\n */\ntype TypedDefineMutators<S extends Schema> = {\n  // Single definitions\n  <MD>(\n    definitions: MD & AssertMutatorDefinitions<MD>,\n  ): MutatorRegistry<EnsureMutatorDefinitions<MD>, S>;\n\n  // Base and overrides\n  <TBase, TOverrides>(\n    base:\n      | MutatorRegistry<EnsureMutatorDefinitions<TBase>, S>\n      | (TBase & AssertMutatorDefinitions<TBase>),\n    overrides: TOverrides,\n  ): MutatorRegistry<\n    DeepMerge<\n      EnsureMutatorDefinitions<TBase>,\n      EnsureMutatorDefinitions<TOverrides>,\n      AnyMutatorDefinition\n    >,\n    S\n  >;\n};\n\nexport type AssertMutatorDefinitions<MD> = MD extends MutatorDefinitions\n  ? unknown\n  : never;\n\nexport type EnsureMutatorDefinitions<MD> = MD extends MutatorDefinitions\n  ? MD\n  : never;\n\n/**\n * Checks if a value is a MutatorRegistry.\n */\nexport function isMutatorRegistry(value: unknown): value is AnyMutatorRegistry {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as Record<string, unknown>)['~'] === 'MutatorRegistry'\n  );\n}\n\nexport type MutatorRegistryTypes<TSchema extends Schema> = 'MutatorRegistry' & {\n  readonly $schema: TSchema;\n};\n\n/**\n * The result of defineMutators(). A tree of Mutators with a tag for detection.\n */\nexport type MutatorRegistry<\n  MD extends MutatorDefinitions,\n  TSchema extends Schema,\n> = ToMutatorTree<MD, TSchema> & {\n  ['~']: MutatorRegistryTypes<TSchema>;\n};\n\n/**\n * A branded type for use in type constraints. Use this instead of\n * `MutatorRegistry<S, C, any>` to avoid TypeScript drilling into\n * the complex ToMutatorTree structure and hitting variance issues.\n */\nexport type AnyMutatorRegistry = {\n  ['~']: MutatorRegistryTypes<Schema>;\n  [key: string]: unknown;\n};\n\n/**\n * Transforms a MutatorDefinitions into a tree of Mutators.\n * Each MutatorDefinition becomes a Mutator at the same path.\n * Uses TInput for the callable args (TOutput is only used internally for validation).\n */\nexport type ToMutatorTree<\n  MD extends MutatorDefinitions,\n  TSchema extends Schema,\n> = {\n  readonly [K in keyof MD]: MD[K] extends AnyMutatorDefinition\n    ? // pull types from the phantom property\n      Mutator<\n        MD[K]['~']['$input'],\n        TSchema,\n        MD[K]['~']['$context'],\n        MD[K]['~']['$wrappedTransaction']\n      >\n    : MD[K] extends MutatorDefinitions\n      ? ToMutatorTree<MD[K], TSchema>\n      : never;\n};\n\nexport type FromMutatorTree<\n  MD extends MutatorDefinitions,\n  TSchema extends Schema,\n> = {\n  readonly [K in keyof MD]: MD[K] extends AnyMutatorDefinition\n    ? // pull types from the phantom property\n      Mutator<\n        ReadonlyJSONValue | undefined, // intentionally left as generic to avoid variance issues\n        TSchema,\n        MD[K]['~']['$context'],\n        MD[K]['~']['$wrappedTransaction']\n      >\n    : MD[K] extends MutatorDefinitions\n      ? FromMutatorTree<MD[K], TSchema>\n      : never;\n}[keyof MD];\n\n/**\n * A tree of MutatorDefinitions, possibly nested.\n */\nexport type MutatorDefinitions = {\n  readonly [key: string]: AnyMutatorDefinition | MutatorDefinitions;\n};\n\nfunction createMutator<\n  ArgsInput extends ReadonlyJSONValue | undefined,\n  ArgsOutput extends ReadonlyJSONValue | undefined,\n  TSchema extends Schema,\n  C,\n  TWrappedTransaction,\n>(\n  name: string,\n  definition: MutatorDefinition<ArgsInput, ArgsOutput, C, TWrappedTransaction>,\n): Mutator<ArgsInput, TSchema, C, TWrappedTransaction> {\n  const {validator} = definition;\n\n  // fn takes ReadonlyJSONValue args because it's called during rebase (from\n  // stored JSON) and on the server (from wire format). Validation happens here.\n  const fn: MutatorExecutionFunction<\n    ArgsInput,\n    C,\n    Transaction<TSchema, TWrappedTransaction>\n  > = async options => {\n    const validatedArgs = validator\n      ? validateInput(name, options.args, validator, 'mutator')\n      : (options.args as unknown as ArgsOutput);\n    await definition.fn({\n      args: validatedArgs,\n      ctx: options.ctx as C,\n      tx: options.tx,\n    });\n  };\n\n  const mutator = (\n    args: ArgsInput,\n  ): MutateRequest<ArgsInput, TSchema, C, TWrappedTransaction> => ({\n    args,\n    '~': 'MutateRequest' as MutateRequestTypes<\n      ArgsInput,\n      TSchema,\n      C,\n      TWrappedTransaction\n    >,\n    'mutator': mutator as unknown as Mutator<\n      ArgsInput,\n      TSchema,\n      C,\n      TWrappedTransaction\n    >,\n  });\n\n  mutator.mutatorName = name;\n  mutator.fn = fn;\n  mutator['~'] = 'Mutator' as unknown as MutatorTypes<\n    ArgsInput,\n    TSchema,\n    C,\n    TWrappedTransaction\n  >;\n\n  return mutator as unknown as Mutator<\n    ArgsInput,\n    TSchema,\n    C,\n    TWrappedTransaction\n  >;\n}\n\nexport function* iterateMutators(\n  registry: AnyMutatorRegistry,\n): Iterable<AnyMutator> {\n  yield* iterateLeaves(registry, isMutator);\n}\n\n/**\n * Gets a Mutator by its dot-separated name from a MutatorRegistry.\n * Returns undefined if not found.\n */\nexport function getMutator<\n  MD extends MutatorDefinitions,\n  TSchema extends Schema,\n>(\n  registry: MutatorRegistry<MD, TSchema>,\n  name: string,\n): FromMutatorTree<MD, TSchema> | undefined {\n  const m = getValueAtPath(registry, name, '.');\n  return m as FromMutatorTree<MD, TSchema> | undefined;\n}\n\n/**\n * Gets a Mutator by its dot-separated name from a MutatorRegistry.\n * Throws if not found.\n */\nexport function mustGetMutator<\n  MD extends MutatorDefinitions,\n  TSchema extends Schema,\n>(\n  registry: MutatorRegistry<MD, TSchema>,\n  name: string,\n): FromMutatorTree<MD, TSchema> {\n  const mutator = getMutator(registry, name);\n  if (mutator === undefined) {\n    throw new Error(`Mutator not found: ${name}`);\n  }\n  return mutator;\n}\n"],"mappings":";;;;;AAgGA,SAAgB,eACd,mBACA,gBACoB;CACpB,SAAS,mBACP,aACA,MACkC;EAClC,MAAM,SAA2C,GAC9C,MAAM,mBACR;AAED,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,YAAY,EAAE;AACtD,QAAK,KAAK,IAAI;GACd,MAAM,OAAO,KAAK,KAAK,IAAI;AAE3B,OAAI,oBAAoB,MAAM,CAC5B,QAAO,OAAO,cAAc,MAAM,MAAM;OAGxC,QAAO,OAAO,mBAAmB,OAAO,KAAK;AAE/C,QAAK,KAAK;;AAGZ,SAAO;;AAGT,KAAI,mBAAmB,KAAA,GAAW;EAEhC,IAAI;AACJ,MAAI,CAAC,kBAAkB,kBAAkB,CACvC,QAAO,mBAAmB,mBAAmB,EAAE,CAAC;MAEhD,QAAO;EAGT,MAAM,YAAY,mBAAmB,gBAAgB,EAAE,CAAC;EAExD,MAAM,SAAS,UAAU,MAAM,WAAW,cAAc;AACxD,SAAO,OAAO;AACd,SAAO;;AAGT,QAAO,mBACL,mBACA,EAAE,CACH;;AAGH,IAAM,iBAAiB,UACrB,CAAC,cAAc,MAAM,IAAI,UAAU,MAAM;;;;AAK3C,SAAgB,yBAEkB;AAChC,QAAO;;;;;AAwCT,SAAgB,kBAAkB,OAA6C;AAC7E,QACE,OAAO,UAAU,YACjB,UAAU,QACT,MAAkC,SAAS;;AA0EhD,SAAS,cAOP,MACA,YACqD;CACrD,MAAM,EAAC,cAAa;CAIpB,MAAM,KAIF,OAAM,YAAW;EACnB,MAAM,gBAAgB,YAClB,cAAc,MAAM,QAAQ,MAAM,WAAW,UAAU,GACtD,QAAQ;AACb,QAAM,WAAW,GAAG;GAClB,MAAM;GACN,KAAK,QAAQ;GACb,IAAI,QAAQ;GACb,CAAC;;CAGJ,MAAM,WACJ,UAC+D;EAC/D;EACA,KAAK;EAML,WAAW;EAMZ;AAED,SAAQ,cAAc;AACtB,SAAQ,KAAK;AACb,SAAQ,OAAO;AAOf,QAAO;;AAQT,UAAiB,gBACf,UACsB;AACtB,QAAO,cAAc,UAAU,UAAU;;;;;;AAO3C,SAAgB,WAId,UACA,MAC0C;AAE1C,QADU,eAAe,UAAU,MAAM,IAAI;;;;;;AAQ/C,SAAgB,eAId,UACA,MAC8B;CAC9B,MAAM,UAAU,WAAW,UAAU,KAAK;AAC1C,KAAI,YAAY,KAAA,EACd,OAAM,IAAI,MAAM,sBAAsB,OAAO;AAE/C,QAAO"}

package/out/zql/src/mutate/mutator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutator.js","names":[],"sources":["../../../../../zql/src/mutate/mutator.ts"],"sourcesContent":["import type {StandardSchemaV1} from '@standard-schema/spec';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {\n  DefaultContext,\n  DefaultSchema,\n  DefaultWrappedTransaction,\n  IsUnknown,\n} from '../../../zero-types/src/default-types.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {AnyTransaction, Transaction} from './custom.ts';\n\n// ----------------------------------------------------------------------------\n// defineMutator\n// ----------------------------------------------------------------------------\n\nexport type MutatorDefinitionTypes<\n  TInput extends ReadonlyJSONValue | undefined,\n  TOutput,\n  TContext,\n  TWrappedTransaction,\n> = 'MutatorDefinition' & {\n  readonly $input: TInput;\n  readonly $output: TOutput;\n  readonly $context: TContext;\n  readonly $wrappedTransaction: TWrappedTransaction;\n};\n\nexport type MutatorDefinition<\n  TInput extends ReadonlyJSONValue | undefined,\n  TOutput extends ReadonlyJSONValue | undefined,\n  TContext = DefaultContext,\n  TWrappedTransaction = DefaultWrappedTransaction,\n> = {\n  readonly 'fn': MutatorDefinitionFunction<TOutput, TContext, AnyTransaction>;\n  readonly 'validator': StandardSchemaV1<TInput, TOutput> | undefined;\n  readonly '~': MutatorDefinitionTypes<\n    TInput,\n    TOutput,\n    TContext,\n    TWrappedTransaction\n  >;\n};\n\n// oxlint-disable-next-line no-explicit-any\nexport type AnyMutatorDefinition = MutatorDefinition<any, any, any, any>;\n\nexport function isMutatorDefinition(f: unknown): f is AnyMutatorDefinition {\n  return (\n    typeof f === 'object' &&\n    f !== null &&\n    (f as {['~']?: unknown})['~'] === 'MutatorDefinition'\n  );\n}\n\n// Overload for no validator\nexport function defineMutator<\n  TInput extends ReadonlyJSONValue | undefined = ReadonlyJSONValue | undefined,\n  TSchema extends Schema = DefaultSchema,\n  TContext = DefaultContext,\n  TWrappedTransaction = DefaultWrappedTransaction,\n>(\n  mutator: MutatorDefinitionFunction<\n    TInput,\n    TContext,\n    Transaction<TSchema, TWrappedTransaction>\n  >,\n): MutatorDefinition<TInput, TInput, TContext, TWrappedTransaction>;\n\n// Overload for validator\nexport function defineMutator<\n  TInput extends ReadonlyJSONValue | undefined = undefined,\n  TOutput extends ReadonlyJSONValue | undefined = TInput,\n  TSchema extends Schema = DefaultSchema,\n  TContext = DefaultContext,\n  TWrappedTransaction = DefaultWrappedTransaction,\n>(\n  validator: StandardSchemaV1<TInput, TOutput>,\n  mutator: MutatorDefinitionFunction<\n    TOutput,\n    TContext,\n    Transaction<TSchema, TWrappedTransaction>\n  >,\n): MutatorDefinition<TInput, TOutput, TContext, TWrappedTransaction>;\n\n// Implementation\nexport function defineMutator<\n  TInput extends ReadonlyJSONValue | undefined = undefined,\n  TOutput extends ReadonlyJSONValue | undefined = TInput,\n  TSchema extends Schema = DefaultSchema,\n  TContext = DefaultContext,\n  TWrappedTransaction = DefaultWrappedTransaction,\n>(\n  validatorOrMutator:\n    | StandardSchemaV1<TInput, TOutput>\n    | MutatorDefinitionFunction<\n        TOutput,\n        TContext,\n        Transaction<TSchema, TWrappedTransaction>\n      >,\n  mutator?: MutatorDefinitionFunction<\n    TOutput,\n    TContext,\n    Transaction<TSchema, TWrappedTransaction>\n  >,\n): MutatorDefinition<TInput, TOutput, TContext, TWrappedTransaction> {\n  let validator: StandardSchemaV1<TInput, TOutput> | undefined;\n  let actualMutator: MutatorDefinitionFunction<\n    TOutput,\n    TContext,\n    Transaction<TSchema, TWrappedTransaction>\n  >;\n\n  if ('~standard' in validatorOrMutator) {\n    // defineMutator(validator, mutator)\n    validator = validatorOrMutator;\n    actualMutator = must(mutator);\n  } else {\n    // defineMutator(mutator) - no validator\n    validator = undefined;\n    actualMutator = validatorOrMutator;\n  }\n\n  const mutatorDefinition: MutatorDefinition<\n    TInput,\n    TOutput,\n    TContext,\n    TWrappedTransaction\n  > = {\n    'fn': actualMutator as MutatorDefinitionFunction<\n      TOutput,\n      TContext,\n      AnyTransaction\n    >,\n    'validator': validator,\n    '~': 'MutatorDefinition' as unknown as MutatorDefinitionTypes<\n      TInput,\n      TOutput,\n      TContext,\n      TWrappedTransaction\n    >,\n  };\n  return mutatorDefinition;\n}\n\n// intentionally not using DefaultSchema, DefaultContext, or DefaultWrappedTransaction\nexport function defineMutatorWithType<\n  TSchema extends Schema,\n  TContext = unknown,\n  TWrappedTransaction = unknown,\n>(): TypedDefineMutator<TSchema, TContext, TWrappedTransaction> {\n  return defineMutator;\n}\n\n/**\n * The return type of defineMutatorWithType. A function matching the\n * defineMutator overloads but with Schema, Context, and WrappedTransaction\n * pre-bound.\n *\n * This is used as a workaround to using DefaultTypes (e.g. when using\n * multiple Zero instances).\n */\ntype TypedDefineMutator<\n  TSchema extends Schema,\n  TContext,\n  TWrappedTransaction,\n> = {\n  // Without validator\n  <TArgs extends ReadonlyJSONValue | undefined>(\n    mutator: MutatorDefinitionFunction<\n      TArgs,\n      TContext,\n      Transaction<TSchema, TWrappedTransaction>\n    >,\n  ): MutatorDefinition<TArgs, TArgs, TContext, TWrappedTransaction>;\n\n  // With validator\n  <\n    TInput extends ReadonlyJSONValue | undefined,\n    TOutput extends ReadonlyJSONValue | undefined,\n  >(\n    validator: StandardSchemaV1<TInput, TOutput>,\n    mutator: MutatorDefinitionFunction<\n      TOutput,\n      TContext,\n      Transaction<TSchema, TWrappedTransaction>\n    >,\n  ): MutatorDefinition<TInput, TOutput, TContext, TWrappedTransaction>;\n};\n\nexport type MutatorDefinitionFunction<\n  TOutput extends ReadonlyJSONValue | undefined,\n  TContext,\n  TTransaction,\n> = (options: {\n  args: TOutput;\n  ctx: TContext;\n  tx: TTransaction;\n}) => Promise<void>;\n\nexport type MutatorExecutionFunction<\n  TOutput extends ReadonlyJSONValue | undefined,\n  TContext,\n  TTransaction,\n> = (\n  options: IsUnknown<TContext> extends true\n    ? {args: TOutput; tx: TTransaction; ctx?: TContext}\n    : {args: TOutput; tx: TTransaction; ctx: TContext},\n) => Promise<void>;\n\n// ----------------------------------------------------------------------------\n// Mutator and MutateRequest types\n// ----------------------------------------------------------------------------\n\nexport type MutatorTypes<\n  TInput extends ReadonlyJSONValue | undefined,\n  TSchema extends Schema,\n  TContext,\n  TWrappedTransaction,\n> = 'Mutator' & {\n  readonly $input: TInput;\n  readonly $schema: TSchema;\n  readonly $context: TContext;\n  readonly $wrappedTransaction: TWrappedTransaction;\n};\n\n/**\n * A callable wrapper around a MutatorDefinition, created by `defineMutators()`.\n *\n * Accessed like `mutators.foo.bar`, and called to create a MutateRequest:\n * `mutators.foo.bar(42)` returns a `MutateRequest`.\n *\n * The `fn` property is used for execution and takes raw JSON args (for rebase\n * and server wire format cases) that are validated internally.\n */\nexport type Mutator<\n  TInput extends ReadonlyJSONValue | undefined,\n  TSchema extends Schema = DefaultSchema,\n  TContext = DefaultContext,\n  TWrappedTransaction = DefaultWrappedTransaction,\n> = {\n  readonly 'mutatorName': string;\n  /**\n   * Execute the mutation. Args are ReadonlyJSONValue because this is called\n   * during rebase (from stored JSON) and on the server (from wire format).\n   * Validation happens internally before the recipe function runs.\n   */\n  readonly 'fn': MutatorExecutionFunction<\n    TInput,\n    TContext,\n    Transaction<TSchema, TWrappedTransaction>\n  >;\n  readonly '~': MutatorTypes<TInput, TSchema, TContext, TWrappedTransaction>;\n} & MutatorCallable<TInput, TSchema, TContext, TWrappedTransaction>;\n\n// Helper type for the callable part of Mutator\n// When TInput is undefined, the function is callable with 0 args\n// When TInput includes undefined (optional), args is optional\n// Otherwise, args is required\ntype MutatorCallable<\n  TInput extends ReadonlyJSONValue | undefined,\n  TSchema extends Schema,\n  TContext,\n  TWrappedTransaction,\n> = [TInput] extends [undefined]\n  ? () => MutateRequest<TInput, TSchema, TContext, TWrappedTransaction>\n  : undefined extends TInput\n    ? {\n        (): MutateRequest<TInput, TSchema, TContext, TWrappedTransaction>;\n        (\n          args?: TInput,\n        ): MutateRequest<TInput, TSchema, TContext, TWrappedTransaction>;\n      }\n    : {\n        (\n          args: TInput,\n        ): MutateRequest<TInput, TSchema, TContext, TWrappedTransaction>;\n      };\n\n// oxlint-disable-next-line no-explicit-any\nexport type AnyMutator = Mutator<any, any, any, any>;\n\n/**\n * Checks if a value is a Mutator (the result of processing a MutatorDefinition\n * through defineMutators).\n */\nexport function isMutator<S extends Schema>(\n  value: unknown,\n  // oxlint-disable-next-line no-explicit-any\n): value is Mutator<any, S, any, any> {\n  return (\n    typeof value === 'function' &&\n    typeof (value as {mutatorName?: unknown}).mutatorName === 'string' &&\n    typeof (value as {fn?: unknown}).fn === 'function'\n  );\n}\n\nexport type MutateRequestTypes<\n  TInput extends ReadonlyJSONValue | undefined,\n  TSchema extends Schema,\n  TContext,\n  TWrappedTransaction,\n> = 'MutateRequest' & {\n  readonly $input: TInput;\n  readonly $schema: TSchema;\n  readonly $context: TContext;\n  readonly $wrappedTransaction: TWrappedTransaction;\n};\n\n/**\n * The result of calling a Mutator with arguments.\n *\n * Created by `mutators.foo.bar(42)`, executed by `zero.mutate(mr)` on the client\n * or `mr.mutator.fn({tx, ctx, args: mr.args})` on the server.\n */\nexport type MutateRequest<\n  TInput extends ReadonlyJSONValue | undefined,\n  TSchema extends Schema = DefaultSchema,\n  TContext = DefaultContext,\n  TWrappedTransaction = DefaultWrappedTransaction,\n> = {\n  readonly 'mutator': Mutator<TInput, TSchema, TContext, TWrappedTransaction>;\n  readonly 'args': TInput;\n  readonly '~': MutateRequestTypes<\n    TInput,\n    TSchema,\n    TContext,\n    TWrappedTransaction\n  >;\n};\n"],"mappings":";;AA+CA,SAAgB,oBAAoB,GAAuC;AACzE,QACE,OAAO,MAAM,YACb,MAAM,QACL,EAAwB,SAAS;;AAmCtC,SAAgB,cAOd,oBAOA,SAKmE;CACnE,IAAI;CACJ,IAAI;AAMJ,KAAI,eAAe,oBAAoB;AAErC,cAAY;AACZ,kBAAgB,KAAK,QAAQ;QACxB;AAEL,cAAY,KAAA;AACZ,kBAAgB;;AAsBlB,QAdI;EACF,MAAM;EAKN,aAAa;EACb,KAAK;EAMN;;AAKH,SAAgB,wBAIgD;AAC9D,QAAO;;;;;;AAuIT,SAAgB,UACd,OAEoC;AACpC,QACE,OAAO,UAAU,cACjB,OAAQ,MAAkC,gBAAgB,YAC1D,OAAQ,MAAyB,OAAO"}

package/out/zql/src/planner/planner-builder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner-builder.js","names":[],"sources":["../../../../../zql/src/planner/planner-builder.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {\n  AST,\n  Condition,\n  Conjunction,\n  CorrelatedSubqueryCondition,\n  Disjunction,\n} from '../../../zero-protocol/src/ast.ts';\nimport {planIdSymbol} from '../../../zero-protocol/src/ast.ts';\nimport type {ConnectionCostModel} from './planner-connection.ts';\nimport type {PlannerConstraint} from './planner-constraint.ts';\nimport type {PlanDebugger} from './planner-debug.ts';\nimport {PlannerFanIn} from './planner-fan-in.ts';\nimport {PlannerFanOut} from './planner-fan-out.ts';\nimport {PlannerGraph} from './planner-graph.ts';\nimport {PlannerJoin} from './planner-join.ts';\nimport type {PlannerNode} from './planner-node.ts';\nimport {PlannerTerminus} from './planner-terminus.ts';\n\nfunction wireOutput(from: PlannerNode, to: PlannerNode): void {\n  switch (from.kind) {\n    case 'connection':\n    case 'join':\n    case 'fan-in':\n      from.setOutput(to);\n      break;\n    case 'fan-out':\n      from.addOutput(to);\n      break;\n    case 'terminus':\n      assert(false, 'Terminus nodes cannot have outputs');\n  }\n}\n\nexport type Plans = {\n  plan: PlannerGraph;\n  subPlans: {[key: string]: Plans};\n};\n\nexport function buildPlanGraph(\n  ast: AST,\n  model: ConnectionCostModel,\n  isRoot: boolean,\n  baseConstraints?: PlannerConstraint,\n): Plans {\n  const graph = new PlannerGraph();\n  let nextPlanId = 0;\n\n  const source = graph.addSource(ast.table, model);\n  const connection = source.connect(\n    ast.orderBy ?? [],\n    ast.where,\n    isRoot,\n    baseConstraints,\n    ast.limit,\n  );\n  graph.connections.push(connection);\n\n  let end: PlannerNode = connection;\n  if (ast.where) {\n    end = processCondition(\n      ast.where,\n      end,\n      graph,\n      model,\n      ast.table,\n      () => nextPlanId++,\n    );\n  }\n\n  const terminus = new PlannerTerminus(end);\n  wireOutput(end, terminus);\n  graph.setTerminus(terminus);\n\n  const subPlans: {[key: string]: Plans} = {};\n  if (ast.related) {\n    for (const csq of ast.related) {\n      const alias = must(\n        csq.subquery.alias,\n        'Related subquery must have alias',\n      );\n      const childConstraints = extractConstraint(\n        csq.correlation.childField,\n        csq.subquery.table,\n      );\n      subPlans[alias] = buildPlanGraph(\n        csq.subquery,\n        model,\n        true,\n        childConstraints,\n      );\n    }\n  }\n\n  return {plan: graph, subPlans};\n}\n\nfunction processCondition(\n  condition: Condition,\n  input: Exclude<PlannerNode, PlannerTerminus>,\n  graph: PlannerGraph,\n  model: ConnectionCostModel,\n  parentTable: string,\n  getPlanId: () => number,\n): Exclude<PlannerNode, PlannerTerminus> {\n  switch (condition.type) {\n    case 'simple':\n      return input;\n    case 'and':\n      return processAnd(condition, input, graph, model, parentTable, getPlanId);\n    case 'or':\n      return processOr(condition, input, graph, model, parentTable, getPlanId);\n    case 'correlatedSubquery':\n      return processCorrelatedSubquery(\n        condition,\n        input,\n        graph,\n        model,\n        parentTable,\n        getPlanId,\n      );\n  }\n}\n\nfunction processAnd(\n  condition: Conjunction,\n  input: Exclude<PlannerNode, PlannerTerminus>,\n  graph: PlannerGraph,\n  model: ConnectionCostModel,\n  parentTable: string,\n  getPlanId: () => number,\n): Exclude<PlannerNode, PlannerTerminus> {\n  let end = input;\n  for (const subCondition of condition.conditions) {\n    end = processCondition(\n      subCondition,\n      end,\n      graph,\n      model,\n      parentTable,\n      getPlanId,\n    );\n  }\n  return end;\n}\n\nfunction processOr(\n  condition: Disjunction,\n  input: Exclude<PlannerNode, PlannerTerminus>,\n  graph: PlannerGraph,\n  model: ConnectionCostModel,\n  parentTable: string,\n  getPlanId: () => number,\n): Exclude<PlannerNode, PlannerTerminus> {\n  const subqueryConditions = condition.conditions.filter(\n    c => c.type === 'correlatedSubquery' || hasCorrelatedSubquery(c),\n  );\n\n  if (subqueryConditions.length === 0) {\n    return input;\n  }\n\n  const fanOut = new PlannerFanOut(input);\n  graph.fanOuts.push(fanOut);\n  wireOutput(input, fanOut);\n\n  const branches: Exclude<PlannerNode, PlannerTerminus>[] = [];\n  for (const subCondition of subqueryConditions) {\n    const branch = processCondition(\n      subCondition,\n      fanOut,\n      graph,\n      model,\n      parentTable,\n      getPlanId,\n    );\n    branches.push(branch);\n    fanOut.addOutput(branch);\n  }\n\n  const fanIn = new PlannerFanIn(branches);\n  graph.fanIns.push(fanIn);\n  for (const branch of branches) {\n    wireOutput(branch, fanIn);\n  }\n\n  return fanIn;\n}\n\nfunction processCorrelatedSubquery(\n  condition: CorrelatedSubqueryCondition,\n  input: Exclude<PlannerNode, PlannerTerminus>,\n  graph: PlannerGraph,\n  model: ConnectionCostModel,\n  parentTable: string,\n  getPlanId: () => number,\n): Exclude<PlannerNode, PlannerTerminus> {\n  const {related} = condition;\n  const childTable = related.subquery.table;\n\n  const childSource = graph.hasSource(childTable)\n    ? graph.getSource(childTable)\n    : graph.addSource(childTable, model);\n\n  const childConnection = childSource.connect(\n    related.subquery.orderBy ?? [],\n    related.subquery.where,\n    false,\n    undefined, // no base constraints for EXISTS/NOT EXISTS\n    condition.op === 'EXISTS' ? 1 : undefined,\n  );\n  graph.connections.push(childConnection);\n\n  let childEnd: PlannerNode = childConnection;\n  if (related.subquery.where) {\n    childEnd = processCondition(\n      related.subquery.where,\n      childEnd,\n      graph,\n      model,\n      childTable,\n      getPlanId,\n    );\n  }\n\n  const parentConstraint = extractConstraint(\n    related.correlation.parentField,\n    parentTable,\n  );\n  const childConstraint = extractConstraint(\n    related.correlation.childField,\n    childTable,\n  );\n\n  const planId = getPlanId();\n  condition[planIdSymbol] = planId;\n\n  // Determine flippability and initial type based on flip flag and operator\n  const isNotExists = condition.op === 'NOT EXISTS';\n  const manualFlip = condition.flip;\n\n  let flippable: boolean;\n  let initialType: 'semi' | 'flipped';\n\n  if (isNotExists) {\n    // NOT EXISTS joins can never be flipped\n    flippable = false;\n    initialType = 'semi';\n  } else if (manualFlip === true) {\n    // User explicitly requested flip=true: start flipped, don't allow planner to change\n    flippable = false;\n    initialType = 'flipped';\n  } else if (manualFlip === false) {\n    // User explicitly requested flip=false: start semi, don't allow planner to change\n    flippable = false;\n    initialType = 'semi';\n  } else {\n    // flip is undefined: planner can decide\n    flippable = true;\n    initialType = 'semi';\n  }\n\n  const join = new PlannerJoin(\n    input,\n    childEnd,\n    parentConstraint,\n    childConstraint,\n    flippable,\n    planId,\n    initialType,\n  );\n  graph.joins.push(join);\n\n  wireOutput(input, join);\n  wireOutput(childEnd, join);\n\n  return join;\n}\n\nfunction hasCorrelatedSubquery(condition: Condition): boolean {\n  if (condition.type === 'correlatedSubquery') {\n    return true;\n  }\n  if (condition.type === 'and' || condition.type === 'or') {\n    return condition.conditions.some(hasCorrelatedSubquery);\n  }\n  // simple conditions don't contain correlated subqueries\n  return false;\n}\n\nfunction extractConstraint(\n  fields: readonly string[],\n  _tableName: string,\n): PlannerConstraint {\n  return Object.fromEntries(fields.map(field => [field, undefined]));\n}\n\nfunction planRecursively(\n  plans: Plans,\n  planDebugger?: PlanDebugger,\n  lc?: LogContext,\n): void {\n  for (const subPlan of Object.values(plans.subPlans)) {\n    planRecursively(subPlan, planDebugger, lc);\n  }\n  plans.plan.plan(planDebugger, lc);\n}\n\nexport function planQuery(\n  ast: AST,\n  model: ConnectionCostModel,\n  planDebugger?: PlanDebugger,\n  lc?: LogContext,\n): AST {\n  const plans = buildPlanGraph(ast, model, true);\n  planRecursively(plans, planDebugger, lc);\n  return applyPlansToAST(ast, plans);\n}\n\nfunction applyToCondition(\n  condition: Condition,\n  flippedIds: Set<number>,\n): Condition {\n  if (condition.type === 'simple') {\n    return condition;\n  }\n\n  if (condition.type === 'correlatedSubquery') {\n    const planId = (condition as unknown as Record<symbol, number>)[\n      planIdSymbol\n    ];\n    const shouldFlip = planId !== undefined && flippedIds.has(planId);\n\n    return {\n      ...condition,\n      flip: shouldFlip,\n      related: {\n        ...condition.related,\n        subquery: {\n          ...condition.related.subquery,\n          where: condition.related.subquery.where\n            ? applyToCondition(condition.related.subquery.where, flippedIds)\n            : undefined,\n        },\n      },\n    };\n  }\n\n  return {\n    ...condition,\n    conditions: condition.conditions.map(c => applyToCondition(c, flippedIds)),\n  };\n}\n\nexport function applyPlansToAST(ast: AST, plans: Plans): AST {\n  const flippedIds = new Set<number>();\n  for (const join of plans.plan.joins) {\n    if (join.type === 'flipped' && join.planId !== undefined) {\n      flippedIds.add(join.planId);\n    }\n  }\n\n  return {\n    ...ast,\n    where: ast.where ? applyToCondition(ast.where, flippedIds) : undefined,\n    related: ast.related?.map(csq => {\n      const alias = must(\n        csq.subquery.alias,\n        'Related subquery must have alias',\n      );\n      const subPlan = plans.subPlans[alias];\n      return {\n        ...csq,\n        subquery: subPlan\n          ? applyPlansToAST(csq.subquery, subPlan)\n          : csq.subquery,\n      };\n    }),\n  };\n}\n"],"mappings":"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"}

package/out/zql/src/planner/planner-connection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner-connection.js","names":["#sort","#filters","#model","#baseConstraints","#baseLimit","#constraints","#isRoot","#output","#cachedConstraintCosts"],"sources":["../../../../../zql/src/planner/planner-connection.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Condition, Ordering} from '../../../zero-protocol/src/ast.ts';\nimport {\n  mergeConstraints,\n  type PlannerConstraint,\n} from './planner-constraint.ts';\nimport type {PlanDebugger} from './planner-debug.ts';\nimport {omitFanout} from './planner-node.ts';\nimport type {\n  CostEstimate,\n  JoinOrConnection,\n  PlannerNode,\n} from './planner-node.ts';\n\n/**\n * Represents a connection to a source (table scan).\n *\n * # Dual State Pattern\n * Like all planner nodes, PlannerConnection separates:\n * 1. immutable structure: Ordering, filters, cost model (set at construction)\n * 2. mutable state: Pinned status, constraints (mutated during planning)\n *\n * # Cost Estimation\n * The ordering and filters determine the initial cost. As planning progresses,\n * constraints from parent joins refine the cost estimate.\n *\n * # Constraint Flow\n * When a connection is pinned as the outer loop, it reveals constraints for\n * connected joins. These constraints propagate through the graph, allowing\n * other connections to update their cost estimates.\n *\n * Example:\n *\n * ```ts\n * builder.issue.whereExists('assignee', a => a.where('name', 'Alice'))\n * ```\n *\n * ```\n * [issue]  [assignee]\n *   |         |\n *   |         +-- where name = 'Alice'\n *    \\        /\n *     \\      /\n *      [join]\n *        |\n * ```\n *\n * - Initial state: Both connections have no constraints, costs are unconstrained\n * - If `issue` chosen first: Reveals constraint `assignee_id` for assignee connection\n * - If `assignee` chosen first: Reveals constraint `assignee_id` for issue connection\n * - Updated costs guide the next selection\n *\n * # Lifecycle\n * 1. Construct with immutable structure (ordering, filters, cost model)\n * 2. Wire to output node during graph construction\n * 3. Planning mutates pinned status and accumulates constraints\n * 4. reset() clears mutable state for replanning\n */\nexport class PlannerConnection {\n  readonly kind = 'connection' as const;\n\n  // ========================================================================\n  // IMMUTABLE STRUCTURE (set during construction, never changes)\n  // ========================================================================\n  readonly #sort: Ordering;\n  readonly #filters: Condition | undefined;\n  readonly #model: ConnectionCostModel;\n  readonly table: string;\n  readonly name: string; // Human-readable name for debugging (defaults to table name)\n  readonly #baseConstraints: PlannerConstraint | undefined; // Constraints from parent correlation\n  readonly #baseLimit: number | undefined; // Original limit from query structure (never modified)\n  readonly selectivity: number; // Fraction of rows passing filters (1.0 = no filtering)\n  #output?: PlannerNode | undefined; // Set once during graph construction\n\n  // ========================================================================\n  // MUTABLE PLANNING STATE (changes during plan search)\n  // ========================================================================\n  /**\n   * Current limit during planning. Can be cleared (set to undefined) when a\n   * parent join is flipped, indicating this connection is now in an outer loop\n   * and should not be limited by EXISTS semantics.\n   */\n  limit: number | undefined;\n\n  /**\n   * Constraints accumulated from parent joins during planning.\n   * Key is a path through the graph (e.g., \"0,1\" for branch pattern [0,1]).\n   *\n   * Undefined constraints are possible when a FO converts to UFO and only\n   * a single join in the UFO is flipped - other branches report undefined.\n   */\n  readonly #constraints: Map<string, PlannerConstraint | undefined>;\n\n  readonly #isRoot: boolean;\n\n  /**\n   * Cached per-constraint costs to avoid redundant cost model calls.\n   * Maps constraint key (branch pattern string) to computed cost.\n   * Invalidated when constraints change.\n   */\n  #cachedConstraintCosts: Map<string, CostEstimate> = new Map();\n\n  constructor(\n    table: string,\n    model: ConnectionCostModel,\n    sort: Ordering,\n    filters: Condition | undefined,\n    isRoot: boolean,\n    baseConstraints?: PlannerConstraint,\n    limit?: number,\n    name?: string,\n  ) {\n    this.table = table;\n    this.name = name ?? table;\n    this.#sort = sort;\n    this.#filters = filters;\n    this.#model = model;\n    this.#baseConstraints = baseConstraints;\n    this.#baseLimit = limit;\n    this.limit = limit;\n    this.#constraints = new Map();\n    this.#isRoot = isRoot;\n\n    // Compute selectivity for EXISTS child connections (baseLimit === 1)\n    // Selectivity = fraction of rows that pass filters\n    if (limit !== undefined && filters) {\n      const costWithFilters = model(table, sort, filters, undefined);\n      const costWithoutFilters = model(table, sort, undefined, undefined);\n      this.selectivity =\n        costWithoutFilters.rows > 0\n          ? costWithFilters.rows / costWithoutFilters.rows\n          : 1.0;\n    } else {\n      // Root connections or connections without filters\n      this.selectivity = 1.0;\n    }\n  }\n\n  setOutput(node: PlannerNode): void {\n    this.#output = node;\n  }\n\n  get output(): PlannerNode {\n    assert(this.#output !== undefined, 'Output not set');\n    return this.#output;\n  }\n\n  closestJoinOrSource(): JoinOrConnection {\n    return 'connection';\n  }\n\n  /**\n   * Constraints are uniquely identified by their path through the\n   * graph.\n   *\n   * FO represents all sub-joins as a single path.\n   * UFO represents each sub-join as a separate path.\n   * The first branch in a UFO will match the path of FO so no re-set needs to happen\n   * when swapping from FO to UFO.\n   *\n   * FO swaps to UFO when a join inside FO-FI gets flipped.\n   *\n   * The max of the last element of the paths is the number of\n   * root branches.\n   */\n  propagateConstraints(\n    path: number[],\n    c: PlannerConstraint | undefined,\n    from?: PlannerNode,\n    planDebugger?: PlanDebugger,\n  ): void {\n    const key = path.join(',');\n    this.#constraints.set(key, c);\n    // Constraints changed, invalidate cost caches\n    this.#cachedConstraintCosts.clear();\n\n    planDebugger?.log({\n      type: 'node-constraint',\n      nodeType: 'connection',\n      node: this.name,\n      branchPattern: path,\n      constraint: c,\n      from: from?.kind ?? 'unknown',\n    });\n  }\n\n  estimateCost(\n    downstreamChildSelectivity: number,\n    branchPattern: number[],\n    planDebugger?: PlanDebugger,\n  ): CostEstimate {\n    // Branch pattern specified - return cost for this specific branch\n    const key = branchPattern.join(',');\n\n    // Check per-constraint cache first\n    let cost = this.#cachedConstraintCosts.get(key);\n    if (cost !== undefined) {\n      return cost;\n    }\n\n    // Cache miss - compute and cache\n    const constraint = this.#constraints.get(key);\n    // Merge base constraints with propagated constraints\n    const mergedConstraint = mergeConstraints(\n      this.#baseConstraints,\n      constraint,\n    );\n    const {startupCost, fanout, rows} = this.#model(\n      this.table,\n      this.#sort,\n      this.#filters,\n      mergedConstraint,\n    );\n    cost = {\n      startupCost,\n      scanEst:\n        this.limit === undefined\n          ? rows\n          : Math.min(rows, this.limit / downstreamChildSelectivity),\n      cost: 0,\n      returnedRows: rows,\n      selectivity: this.selectivity,\n      limit: this.limit,\n      fanout,\n    };\n    this.#cachedConstraintCosts.set(key, cost);\n\n    if (planDebugger) {\n      planDebugger.log({\n        type: 'node-cost',\n        nodeType: 'connection',\n        node: this.name,\n        branchPattern,\n        downstreamChildSelectivity,\n        costEstimate: omitFanout(cost),\n        filters: this.#filters,\n        ordering: this.#sort,\n      });\n    }\n\n    return cost;\n  }\n\n  /**\n   * Remove the limit from this connection.\n   * Called when a parent join is flipped, making this connection part of an\n   * outer loop that should produce all rows rather than stopping at the limit.\n   */\n  unlimit(): void {\n    if (this.#isRoot) {\n      // We cannot unlimit root connections\n      return;\n    }\n    if (this.limit !== undefined) {\n      this.limit = undefined;\n      // Limit changes do not impact connection costs.\n      // Limit is taken into account at the join level.\n      // Given that, we do not need to invalidate cost caches here.\n    }\n  }\n\n  /**\n   * Propagate unlimiting when a parent join is flipped.\n   * For connections, we simply remove the limit.\n   */\n  propagateUnlimitFromFlippedJoin(): void {\n    this.unlimit();\n  }\n\n  reset() {\n    this.#constraints.clear();\n    this.limit = this.#baseLimit;\n    // Clear all cost caches\n    this.#cachedConstraintCosts.clear();\n  }\n\n  /**\n   * Capture constraint state for snapshotting.\n   * Used by PlannerGraph to save/restore planning state.\n   */\n  captureConstraints(): Map<string, PlannerConstraint | undefined> {\n    return new Map(this.#constraints);\n  }\n\n  /**\n   * Restore constraint state from a snapshot.\n   * Used by PlannerGraph to restore planning state.\n   */\n  restoreConstraints(\n    constraints: Map<string, PlannerConstraint | undefined>,\n  ): void {\n    this.#constraints.clear();\n    for (const [key, value] of constraints) {\n      this.#constraints.set(key, value);\n    }\n    // Constraints changed, invalidate cost caches\n    this.#cachedConstraintCosts.clear();\n  }\n\n  /** Get current constraints for debugging. */\n  getConstraintsForDebug(): Record<string, PlannerConstraint | undefined> {\n    const record: Record<string, PlannerConstraint | undefined> = {};\n    for (const [key, value] of this.#constraints) {\n      record[key] = value;\n    }\n    return record;\n  }\n\n  /** Get filters for debugging. */\n  getFiltersForDebug(): Condition | undefined {\n    return this.#filters;\n  }\n\n  /** Get sort/ordering for debugging. */\n  getSortForDebug(): Ordering {\n    return this.#sort;\n  }\n\n  /** Get estimated cost for each constraint branch. */\n  getConstraintCostsForDebug(): Record<string, CostEstimate> {\n    const record: Record<string, CostEstimate> = {};\n    for (const [key, value] of this.#cachedConstraintCosts) {\n      record[key] = value;\n    }\n    return record;\n  }\n}\n\ntype FanoutEst = {\n  fanout: number;\n  confidence: 'high' | 'med' | 'none';\n};\nexport type FanoutCostModel = (columns: string[]) => FanoutEst;\n\nexport type CostModelCost = {\n  startupCost: number;\n  rows: number;\n  fanout: FanoutCostModel;\n};\nexport type ConnectionCostModel = (\n  table: string,\n  sort: Ordering,\n  filters: Condition | undefined,\n  constraint: PlannerConstraint | undefined,\n) => CostModelCost;\n"],"mappings":"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"}

package/out/zql/src/planner/planner-constraint.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner-constraint.js","names":[],"sources":["../../../../../zql/src/planner/planner-constraint.ts"],"sourcesContent":["/**\n * We do not know the value a constraint will take until runtime.\n *\n * However, we do know the column.\n *\n * E.g., we know that `issue.assignee_id` will be constrained to typeof issue.assignee_id.\n */\nexport type PlannerConstraint = Record<string, undefined>;\n\n/**\n * Multiple flipped joins will contribute extra constraints to a parent join.\n * These need to be merged.\n */\nexport function mergeConstraints(\n  a: PlannerConstraint | undefined,\n  b: PlannerConstraint | undefined,\n): PlannerConstraint | undefined {\n  if (!a) return b;\n  if (!b) return a;\n  return {...a, ...b};\n}\n"],"mappings":";;;;;AAaA,SAAgB,iBACd,GACA,GAC+B;AAC/B,KAAI,CAAC,EAAG,QAAO;AACf,KAAI,CAAC,EAAG,QAAO;AACf,QAAO;EAAC,GAAG;EAAG,GAAG;EAAE"}

package/out/zql/src/planner/planner-debug.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner-debug.js","names":[],"sources":["../../../../../zql/src/planner/planner-debug.ts"],"sourcesContent":["import type * as v from '../../../shared/src/valita.ts';\nimport type {\n  attemptStartEventJSONSchema,\n  bestPlanSelectedEventJSONSchema,\n  connectionSelectedEventJSONSchema,\n  nodeConstraintEventJSONSchema,\n  PlanDebugEventJSON,\n  planFailedEventJSONSchema,\n} from '../../../zero-protocol/src/analyze-query-result.ts';\nimport type {\n  Condition,\n  Ordering,\n  ValuePosition,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {PlannerConstraint} from './planner-constraint.ts';\nimport type {PlanState} from './planner-graph.ts';\nimport type {CostEstimate, JoinType} from './planner-node.ts';\n\n/**\n * Structured debug events emitted during query planning.\n * These events can be accumulated, printed, or analyzed to understand\n * the planner's decision-making process.\n */\n\n/**\n * Starting a new planning attempt with a different root connection.\n */\nexport type AttemptStartEvent = v.Infer<typeof attemptStartEventJSONSchema>;\n\n/**\n * Snapshot of connection costs before selecting the next connection.\n */\nexport type ConnectionCostsEvent = {\n  type: 'connection-costs';\n  attemptNumber: number;\n  costs: Array<{\n    connection: string;\n    cost: number;\n    costEstimate: Omit<CostEstimate, 'fanout'>;\n    pinned: boolean;\n    constraints: Record<string, PlannerConstraint | undefined>;\n    constraintCosts: Record<string, Omit<CostEstimate, 'fanout'>>;\n  }>;\n};\n\n/**\n * A connection was chosen and pinned.\n */\nexport type ConnectionSelectedEvent = v.Infer<\n  typeof connectionSelectedEventJSONSchema\n>;\n\n/**\n * Constraints have been propagated through the graph.\n */\nexport type ConstraintsPropagatedEvent = {\n  type: 'constraints-propagated';\n  attemptNumber: number;\n  connectionConstraints: Array<{\n    connection: string;\n    constraints: Record<string, PlannerConstraint | undefined>;\n    constraintCosts: Record<string, Omit<CostEstimate, 'fanout'>>;\n  }>;\n};\n\n/**\n * A complete plan was found for this attempt.\n */\nexport type PlanCompleteEvent = {\n  type: 'plan-complete';\n  attemptNumber: number;\n  totalCost: number;\n  flipPattern: number; // Bitmask indicating which joins are flipped\n  joinStates: Array<{\n    join: string;\n    type: JoinType;\n  }>;\n  // Planning snapshot that can be restored and applied to AST\n  planSnapshot: PlanState;\n};\n\n/**\n * Planning attempt failed (e.g., unflippable join).\n */\nexport type PlanFailedEvent = v.Infer<typeof planFailedEventJSONSchema>;\n\n/**\n * The best plan across all attempts was selected.\n */\nexport type BestPlanSelectedEvent = v.Infer<\n  typeof bestPlanSelectedEventJSONSchema\n>;\n\n/**\n * A node computed its cost estimate during planning.\n * Emitted by nodes during estimateCost() traversal.\n * attemptNumber is added by the debugger.\n */\nexport type NodeCostEvent = {\n  type: 'node-cost';\n  attemptNumber?: number;\n  nodeType: 'connection' | 'join' | 'fan-out' | 'fan-in' | 'terminus';\n  node: string;\n  branchPattern: number[];\n  downstreamChildSelectivity: number;\n  costEstimate: Omit<CostEstimate, 'fanout'>;\n  filters?: Condition | undefined; // Only for connections\n  ordering?: Ordering | undefined; // Only for connections\n  joinType?: JoinType | undefined; // Only for joins\n};\n\n/**\n * A node received constraints during constraint propagation.\n * Emitted by nodes during propagateConstraints() traversal.\n * attemptNumber is added by the debugger.\n */\nexport type NodeConstraintEvent = v.Infer<typeof nodeConstraintEventJSONSchema>;\n\n/**\n * Union of all debug event types.\n */\nexport type PlanDebugEvent =\n  | AttemptStartEvent\n  | ConnectionCostsEvent\n  | ConnectionSelectedEvent\n  | ConstraintsPropagatedEvent\n  | PlanCompleteEvent\n  | PlanFailedEvent\n  | BestPlanSelectedEvent\n  | NodeCostEvent\n  | NodeConstraintEvent;\n\n/**\n * Interface for objects that receive debug events during planning.\n */\nexport interface PlanDebugger {\n  log(event: PlanDebugEvent): void;\n}\n\n/**\n * Simple accumulator debugger that stores all events.\n * Useful for tests and debugging.\n */\nexport class AccumulatorDebugger implements PlanDebugger {\n  readonly events: PlanDebugEvent[] = [];\n  private currentAttempt = 0;\n\n  log(event: PlanDebugEvent): void {\n    // Track current attempt number\n    if (event.type === 'attempt-start') {\n      this.currentAttempt = event.attemptNumber;\n    }\n\n    // Add attempt number to node events\n    if (event.type === 'node-cost' || event.type === 'node-constraint') {\n      (event as NodeCostEvent | NodeConstraintEvent).attemptNumber =\n        this.currentAttempt;\n    }\n\n    this.events.push(event);\n  }\n\n  /**\n   * Get all events of a specific type.\n   */\n  getEvents<T extends PlanDebugEvent['type']>(\n    type: T,\n  ): Extract<PlanDebugEvent, {type: T}>[] {\n    return this.events.filter(e => e.type === type) as Extract<\n      PlanDebugEvent,\n      {type: T}\n    >[];\n  }\n\n  /**\n   * Format events as a human-readable string.\n   */\n  format(): string {\n    return formatPlannerEvents(this.events);\n  }\n}\n\n/**\n * Format a constraint object as a human-readable string.\n */\nfunction formatConstraint(\n  constraint: PlannerConstraint | Record<string, unknown> | null | undefined,\n): string {\n  if (!constraint) return '{}';\n  const keys = Object.keys(constraint);\n  if (keys.length === 0) return '{}';\n  return '{' + keys.join(', ') + '}';\n}\n\n/**\n * Format a ValuePosition (column, literal, or static parameter) as a human-readable string.\n */\nfunction formatValuePosition(value: ValuePosition): string {\n  switch (value.type) {\n    case 'column':\n      return value.name;\n    case 'literal':\n      // Format literal values with SQL-style quoting for strings\n      if (typeof value.value === 'string') {\n        return `'${value.value}'`;\n      }\n      return JSON.stringify(value.value);\n    case 'static':\n      return `@${value.anchor}.${Array.isArray(value.field) ? value.field.join('.') : value.field}`;\n  }\n}\n\n/**\n * Format a Condition (filter) as a human-readable string.\n */\nfunction formatFilter(filter: Condition | undefined): string {\n  if (!filter) return 'none';\n\n  switch (filter.type) {\n    case 'simple':\n      return `${formatValuePosition(filter.left)} ${filter.op} ${formatValuePosition(filter.right)}`;\n    case 'and':\n      return `(${filter.conditions.map(formatFilter).join(' AND ')})`;\n    case 'or':\n      return `(${filter.conditions.map(formatFilter).join(' OR ')})`;\n    case 'correlatedSubquery':\n      return `EXISTS(${filter.related.subquery.table})`;\n    default:\n      return JSON.stringify(filter);\n  }\n}\n\n/**\n * Format an Ordering as a human-readable string.\n */\nfunction formatOrdering(ordering: Ordering | undefined): string {\n  if (!ordering || ordering.length === 0) return 'none';\n  return ordering\n    .map(([field, direction]) => `${field} ${direction}`)\n    .join(', ');\n}\n\n/**\n * Format a compact summary for a single planning attempt.\n */\nfunction formatAttemptSummary(\n  attemptNum: number,\n  events: (PlanDebugEvent | PlanDebugEventJSON)[],\n): string[] {\n  const lines: string[] = [];\n\n  // Find the attempt-start event to get total attempts\n  const startEvent = events.find(e => e.type === 'attempt-start') as\n    | AttemptStartEvent\n    | undefined;\n  const totalAttempts = startEvent?.totalAttempts ?? '?';\n\n  // Calculate number of bits needed for pattern\n  const numBits =\n    typeof totalAttempts === 'number'\n      ? Math.ceil(Math.log2(totalAttempts)) || 1\n      : 1;\n  const bitPattern = attemptNum.toString(2).padStart(numBits, '0');\n\n  lines.push(\n    `[Attempt ${attemptNum + 1}/${totalAttempts}] Pattern ${attemptNum} (${bitPattern})`,\n  );\n\n  // Collect connection costs (use array to preserve all connections, including duplicates)\n  const connectionCostEvents: (\n    | NodeCostEvent\n    | Extract<PlanDebugEventJSON, {type: 'node-cost'}>\n  )[] = [];\n  const connectionConstraintEvents: NodeConstraintEvent[] = [];\n\n  for (const event of events) {\n    if (event.type === 'node-cost' && event.nodeType === 'connection') {\n      connectionCostEvents.push(event);\n    }\n    if (event.type === 'node-constraint' && event.nodeType === 'connection') {\n      connectionConstraintEvents.push(event);\n    }\n  }\n\n  // Show connection summary\n  if (connectionCostEvents.length > 0) {\n    lines.push('  Connections:');\n    for (const cost of connectionCostEvents) {\n      // Find matching constraint event (same node name and branch pattern)\n      const constraint = connectionConstraintEvents.find(\n        c =>\n          c.node === cost.node &&\n          c.branchPattern.join(',') === cost.branchPattern.join(','),\n      )?.constraint;\n\n      const constraintStr = formatConstraint(constraint);\n      const filterStr = formatFilter(cost.filters);\n      const orderingStr = formatOrdering(cost.ordering);\n      const limitStr =\n        cost.costEstimate.limit !== undefined\n          ? cost.costEstimate.limit.toString()\n          : 'none';\n\n      lines.push(`    ${cost.node}:`);\n      lines.push(\n        `      cost=${cost.costEstimate.cost.toFixed(2)}, startup=${cost.costEstimate.startupCost.toFixed(2)}, scan=${cost.costEstimate.scanEst.toFixed(2)}`,\n      );\n      lines.push(\n        `      rows=${cost.costEstimate.returnedRows.toFixed(2)}, selectivity=${cost.costEstimate.selectivity.toFixed(8)}, limit=${limitStr}`,\n      );\n      lines.push(\n        `      downstreamChildSelectivity=${cost.downstreamChildSelectivity.toFixed(8)}`,\n      );\n      lines.push(`      constraints=${constraintStr}`);\n      lines.push(`      filters=${filterStr}`);\n      lines.push(`      ordering=${orderingStr}`);\n    }\n  }\n\n  // Collect join costs from node-cost events\n  const joinCosts: (\n    | NodeCostEvent\n    | Extract<PlanDebugEventJSON, {type: 'node-cost'}>\n  )[] = [];\n  for (const event of events) {\n    if (event.type === 'node-cost' && event.nodeType === 'join') {\n      joinCosts.push(event);\n    }\n  }\n\n  if (joinCosts.length > 0) {\n    lines.push('  Joins:');\n    for (const cost of joinCosts) {\n      const typeStr = cost.joinType ? ` (${cost.joinType})` : '';\n      const limitStr =\n        cost.costEstimate.limit !== undefined\n          ? cost.costEstimate.limit.toString()\n          : 'none';\n\n      lines.push(`    ${cost.node}${typeStr}:`);\n      lines.push(\n        `      cost=${cost.costEstimate.cost.toFixed(2)}, startup=${cost.costEstimate.startupCost.toFixed(2)}, scan=${cost.costEstimate.scanEst.toFixed(2)}`,\n      );\n      lines.push(\n        `      rows=${cost.costEstimate.returnedRows.toFixed(2)}, selectivity=${cost.costEstimate.selectivity.toFixed(8)}, limit=${limitStr}`,\n      );\n      lines.push(\n        `      downstreamChildSelectivity=${cost.downstreamChildSelectivity.toFixed(8)}`,\n      );\n    }\n  }\n\n  // Find completion/failure events\n  const completeEvent = events.find(e => e.type === 'plan-complete') as\n    | PlanCompleteEvent\n    | undefined;\n  const failedEvent = events.find(e => e.type === 'plan-failed') as\n    | PlanFailedEvent\n    | undefined;\n\n  // Show final status\n\n  if (completeEvent) {\n    lines.push(\n      `  ✓ Plan complete: total cost = ${completeEvent.totalCost.toFixed(2)}`,\n    );\n  } else if (failedEvent) {\n    lines.push(`  ✗ Plan failed: ${failedEvent.reason}`);\n  }\n\n  return lines;\n}\n\n/**\n * Convert undefined values to null in a constraint object for JSON serialization.\n * PlannerConstraint uses Record<string, undefined> which loses keys during JSON.stringify.\n */\nfunction convertConstraintUndefinedToNull(\n  constraint: PlannerConstraint | Record<string, unknown> | undefined | null,\n): Record<string, unknown> | undefined | null {\n  if (constraint === undefined) {\n    return undefined;\n  }\n  if (constraint === null) {\n    return null;\n  }\n  const result: Record<string, unknown> = {};\n  for (const [key, val] of Object.entries(constraint)) {\n    result[key] = val === undefined ? null : val;\n  }\n  return result;\n}\n\n/**\n * Serialize a single debug event to JSON-compatible format.\n * The fanout function is already omitted when events are created.\n * The planSnapshot is excluded as it's internal state not needed for debugging.\n * Undefined values in constraints are converted to null for JSON serialization.\n */\nfunction serializeEvent(event: PlanDebugEvent): PlanDebugEventJSON {\n  // Remove planSnapshot from plan-complete events\n  if (event.type === 'plan-complete') {\n    const {planSnapshot: _, ...rest} = event;\n    return rest as PlanDebugEventJSON;\n  }\n\n  // Convert constraint undefined values to null for specific event types\n  if (event.type === 'node-constraint') {\n    return {\n      ...event,\n      constraint: convertConstraintUndefinedToNull(event.constraint),\n    } as PlanDebugEventJSON;\n  }\n\n  if (event.type === 'connection-costs') {\n    return {\n      ...event,\n      costs: event.costs.map(cost => ({\n        ...cost,\n        constraints: Object.fromEntries(\n          Object.entries(cost.constraints).map(([key, val]) => [\n            key,\n            convertConstraintUndefinedToNull(val),\n          ]),\n        ),\n      })),\n    } as PlanDebugEventJSON;\n  }\n\n  if (event.type === 'constraints-propagated') {\n    return {\n      ...event,\n      connectionConstraints: event.connectionConstraints.map(cc => ({\n        ...cc,\n        constraints: Object.fromEntries(\n          Object.entries(cc.constraints).map(([key, val]) => [\n            key,\n            convertConstraintUndefinedToNull(val),\n          ]),\n        ),\n      })),\n    } as PlanDebugEventJSON;\n  }\n\n  return event as PlanDebugEventJSON;\n}\n\n/**\n * Serialize an array of debug events to JSON-compatible format.\n * The fanout function is already omitted when events are created.\n * The planSnapshot is excluded as it's internal state not needed for debugging.\n */\nexport function serializePlanDebugEvents(\n  events: PlanDebugEvent[],\n): PlanDebugEventJSON[] {\n  return events.map(serializeEvent);\n}\n\n/**\n * Format planner debug events as a human-readable string.\n * Works with JSON-serialized events (from inspector API) or native events (from AccumulatorDebugger).\n *\n * @param events - Array of planner debug events (either JSON or native format)\n * @returns Formatted string showing planning attempts, costs, and final plan selection\n *\n * @example\n * ```typescript\n * const result = await inspector.analyzeQuery(query, { joinPlans: true });\n * if (result.joinPlans) {\n *   console.log(formatPlannerEvents(result.joinPlans));\n * }\n * ```\n */\nexport function formatPlannerEvents(\n  events: PlanDebugEventJSON[] | PlanDebugEvent[],\n): string {\n  const lines: string[] = [];\n\n  // Group events by attempt\n  const eventsByAttempt = new Map<\n    number,\n    (PlanDebugEventJSON | PlanDebugEvent)[]\n  >();\n  let bestPlanEvent:\n    | {\n        type: 'best-plan-selected';\n        bestAttemptNumber: number;\n        totalCost: number;\n        flipPattern: number;\n        joinStates: Array<{join: string; type: string}>;\n      }\n    | undefined;\n\n  for (const event of events) {\n    if ('attemptNumber' in event) {\n      const attempt = event.attemptNumber;\n      if (attempt !== undefined) {\n        let attemptEvents = eventsByAttempt.get(attempt);\n        if (!attemptEvents) {\n          attemptEvents = [];\n          eventsByAttempt.set(attempt, attemptEvents);\n        }\n        attemptEvents.push(event);\n      }\n    } else if (event.type === 'best-plan-selected') {\n      // Save for displaying at the end\n      bestPlanEvent = event;\n    }\n  }\n\n  // Format each attempt as a compact summary\n  for (const [attemptNum, events] of eventsByAttempt.entries()) {\n    lines.push(...formatAttemptSummary(attemptNum, events));\n    lines.push(''); // Blank line between attempts\n  }\n\n  // Show the final plan selection\n  if (bestPlanEvent) {\n    lines.push('─'.repeat(60));\n    lines.push(\n      `✓ Best plan: Attempt ${bestPlanEvent.bestAttemptNumber + 1} (cost=${bestPlanEvent.totalCost.toFixed(2)})`,\n    );\n    if (bestPlanEvent.joinStates.length > 0) {\n      lines.push('  Join types:');\n      for (const j of bestPlanEvent.joinStates) {\n        lines.push(`    ${j.join}: ${j.type}`);\n      }\n    }\n    lines.push('─'.repeat(60));\n  }\n\n  return lines.join('\\n');\n}\n"],"mappings":"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"}

package/out/zql/src/planner/planner-fan-in.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner-fan-in.js","names":["#inputs","#type","#output"],"sources":["../../../../../zql/src/planner/planner-fan-in.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {PlannerConstraint} from './planner-constraint.ts';\nimport type {PlanDebugger} from './planner-debug.ts';\nimport {omitFanout} from './planner-node.ts';\nimport type {\n  CostEstimate,\n  JoinOrConnection,\n  PlannerNode,\n} from './planner-node.ts';\nimport type {PlannerTerminus} from './planner-terminus.ts';\n\n/**\n * A PlannerFanIn node can either be a normal FanIn or UnionFanIn.\n *\n * These have different performance characteristics so we need to distinguish them.\n *\n * A normal FanIn only does a single fetch to FanOut, regardless of how many internal\n * branches / inputs it has.\n *\n * A UnionFanIn does a fetch per internal branch / input. This causes an exponential\n * increase in cost if many UnionFanIns are chained after on another. E.g., `(A or B) AND (C or D)`.\n *\n * To capture this cost blow-up, union fan in assigns different branch patterns to their inputs.\n *\n * Since UFI will generate a unique branch pattern per input, planner-connection will yield a higher cost\n * each time a UFI is present. planner-connection will return the sum of the costs of each unique branch pattern.\n */\nexport class PlannerFanIn {\n  readonly kind = 'fan-in' as const;\n  #type: 'FI' | 'UFI';\n  #output?: PlannerNode | undefined;\n  readonly #inputs: Exclude<PlannerNode, PlannerTerminus>[];\n\n  constructor(inputs: Exclude<PlannerNode, PlannerTerminus>[]) {\n    this.#type = 'FI';\n    this.#inputs = inputs;\n  }\n\n  get type() {\n    return this.#type;\n  }\n\n  closestJoinOrSource(): JoinOrConnection {\n    return 'join';\n  }\n\n  setOutput(node: PlannerNode): void {\n    this.#output = node;\n  }\n\n  get output(): PlannerNode {\n    assert(this.#output !== undefined, 'Output not set');\n    return this.#output;\n  }\n\n  reset() {\n    this.#type = 'FI';\n  }\n\n  convertToUFI(): void {\n    this.#type = 'UFI';\n  }\n\n  /**\n   * Propagate unlimiting when a parent join is flipped.\n   * Fan-in propagates to all of its inputs.\n   */\n  propagateUnlimitFromFlippedJoin(): void {\n    for (const input of this.#inputs) {\n      if (\n        'propagateUnlimitFromFlippedJoin' in input &&\n        typeof input.propagateUnlimitFromFlippedJoin === 'function'\n      ) {\n        (\n          input as {propagateUnlimitFromFlippedJoin(): void}\n        ).propagateUnlimitFromFlippedJoin();\n      }\n    }\n  }\n\n  estimateCost(\n    downstreamChildSelectivity: number,\n    branchPattern: number[],\n    planDebugger?: PlanDebugger,\n  ): CostEstimate {\n    // FanIn always sums costs of its inputs\n    // But it needs to pass the correct branch pattern to each input\n    let totalCost: CostEstimate = {\n      returnedRows: 0,\n      cost: 0,\n      scanEst: 0,\n      startupCost: 0,\n      selectivity: 0,\n      limit: undefined,\n      fanout: () => {\n        throw new Error('Failed to set fanout model');\n      },\n    };\n\n    if (this.#type === 'FI') {\n      // Normal FanIn: all inputs get the same branch pattern with 0 prepended\n      const updatedPattern = [0, ...branchPattern];\n      let maxrows = 0;\n      let maxRunningCost = 0;\n      let maxStartupCost = 0;\n      let maxScanEst = 0;\n\n      let noMatchProb = 1.0;\n      for (const input of this.#inputs) {\n        const cost = input.estimateCost(\n          downstreamChildSelectivity,\n          updatedPattern,\n          planDebugger,\n        );\n        totalCost.fanout = cost.fanout;\n        if (cost.returnedRows > maxrows) {\n          maxrows = cost.returnedRows;\n        }\n        if (cost.cost > maxRunningCost) {\n          maxRunningCost = cost.cost;\n        }\n        if (cost.startupCost > maxStartupCost) {\n          maxStartupCost = cost.startupCost;\n        }\n        if (cost.scanEst > maxScanEst) {\n          maxScanEst = cost.scanEst;\n        }\n\n        // OR branches: combine selectivities assuming independent events\n        // P(A OR B) = 1 - (1-A)(1-B)\n        // Track probability of NO match in any branch\n        noMatchProb *= 1 - cost.selectivity;\n\n        // all inputs should have the same limit.\n        assert(\n          totalCost.limit === undefined || cost.limit === totalCost.limit,\n          'All FanIn inputs should have the same limit',\n        );\n        totalCost.limit = cost.limit;\n      }\n\n      totalCost.returnedRows = maxrows;\n      totalCost.cost = maxRunningCost;\n      totalCost.selectivity = 1 - noMatchProb;\n      totalCost.startupCost = maxStartupCost;\n      totalCost.scanEst = maxScanEst;\n    } else {\n      // Union FanIn (UFI): each input gets unique branch pattern\n      let i = 0;\n\n      let noMatchProb = 1.0;\n      for (const input of this.#inputs) {\n        const updatedPattern = [i, ...branchPattern];\n        const cost = input.estimateCost(\n          downstreamChildSelectivity,\n          updatedPattern,\n          planDebugger,\n        );\n        totalCost.fanout = cost.fanout;\n        totalCost.returnedRows += cost.returnedRows;\n        totalCost.cost += cost.cost;\n        totalCost.scanEst += cost.scanEst;\n        totalCost.startupCost = totalCost.startupCost + cost.startupCost;\n\n        // OR branches: combine selectivities assuming independent events\n        // P(A OR B) = 1 - (1-A)(1-B)\n        // Track probability of NO match in any branch\n        noMatchProb *= 1 - cost.selectivity;\n\n        // all inputs should have the same limit.\n        assert(\n          totalCost.limit === undefined || cost.limit === totalCost.limit,\n          'All FanIn inputs should have the same limit',\n        );\n        totalCost.limit = cost.limit;\n        i++;\n      }\n      totalCost.selectivity = 1 - noMatchProb;\n    }\n\n    if (planDebugger) {\n      planDebugger.log({\n        type: 'node-cost',\n        nodeType: 'fan-in',\n        node: this.#type,\n        branchPattern,\n        downstreamChildSelectivity,\n        costEstimate: omitFanout(totalCost),\n      });\n    }\n\n    return totalCost;\n  }\n\n  propagateConstraints(\n    branchPattern: number[],\n    constraint: PlannerConstraint | undefined,\n    from?: PlannerNode,\n    planDebugger?: PlanDebugger,\n  ): void {\n    planDebugger?.log({\n      type: 'node-constraint',\n      nodeType: 'fan-in',\n      node: this.#type,\n      branchPattern,\n      constraint,\n      from: from?.kind ?? 'unknown',\n    });\n\n    if (this.#type === 'FI') {\n      const updatedPattern = [0, ...branchPattern];\n      /**\n       * All inputs get the same branch pattern.\n       * 1. They cannot contribute differing constraints to their parent inputs because they are not flipped.\n       *    If they were flipped this would be of type UFI.\n       * 2. All inputs need to be called because they could be pinned. If they are pinned they could have constraints\n       *    to send to their children.\n       */\n      for (const input of this.#inputs) {\n        input.propagateConstraints(\n          updatedPattern,\n          constraint,\n          this,\n          planDebugger,\n        );\n      }\n      return;\n    }\n\n    let i = 0;\n    for (const input of this.#inputs) {\n      input.propagateConstraints(\n        [i, ...branchPattern],\n        constraint,\n        this,\n        planDebugger,\n      );\n      i++;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA2BA,IAAa,eAAb,MAA0B;CACxB,OAAgB;CAChB;CACA;CACA;CAEA,YAAY,QAAiD;AAC3D,QAAA,OAAa;AACb,QAAA,SAAe;;CAGjB,IAAI,OAAO;AACT,SAAO,MAAA;;CAGT,sBAAwC;AACtC,SAAO;;CAGT,UAAU,MAAyB;AACjC,QAAA,SAAe;;CAGjB,IAAI,SAAsB;AACxB,SAAO,MAAA,WAAiB,KAAA,GAAW,iBAAiB;AACpD,SAAO,MAAA;;CAGT,QAAQ;AACN,QAAA,OAAa;;CAGf,eAAqB;AACnB,QAAA,OAAa;;;;;;CAOf,kCAAwC;AACtC,OAAK,MAAM,SAAS,MAAA,OAClB,KACE,qCAAqC,SACrC,OAAO,MAAM,oCAAoC,WAG/C,OACA,iCAAiC;;CAKzC,aACE,4BACA,eACA,cACc;EAGd,IAAI,YAA0B;GAC5B,cAAc;GACd,MAAM;GACN,SAAS;GACT,aAAa;GACb,aAAa;GACb,OAAO,KAAA;GACP,cAAc;AACZ,UAAM,IAAI,MAAM,6BAA6B;;GAEhD;AAED,MAAI,MAAA,SAAe,MAAM;GAEvB,MAAM,iBAAiB,CAAC,GAAG,GAAG,cAAc;GAC5C,IAAI,UAAU;GACd,IAAI,iBAAiB;GACrB,IAAI,iBAAiB;GACrB,IAAI,aAAa;GAEjB,IAAI,cAAc;AAClB,QAAK,MAAM,SAAS,MAAA,QAAc;IAChC,MAAM,OAAO,MAAM,aACjB,4BACA,gBACA,aACD;AACD,cAAU,SAAS,KAAK;AACxB,QAAI,KAAK,eAAe,QACtB,WAAU,KAAK;AAEjB,QAAI,KAAK,OAAO,eACd,kBAAiB,KAAK;AAExB,QAAI,KAAK,cAAc,eACrB,kBAAiB,KAAK;AAExB,QAAI,KAAK,UAAU,WACjB,cAAa,KAAK;AAMpB,mBAAe,IAAI,KAAK;AAGxB,WACE,UAAU,UAAU,KAAA,KAAa,KAAK,UAAU,UAAU,OAC1D,8CACD;AACD,cAAU,QAAQ,KAAK;;AAGzB,aAAU,eAAe;AACzB,aAAU,OAAO;AACjB,aAAU,cAAc,IAAI;AAC5B,aAAU,cAAc;AACxB,aAAU,UAAU;SACf;GAEL,IAAI,IAAI;GAER,IAAI,cAAc;AAClB,QAAK,MAAM,SAAS,MAAA,QAAc;IAChC,MAAM,iBAAiB,CAAC,GAAG,GAAG,cAAc;IAC5C,MAAM,OAAO,MAAM,aACjB,4BACA,gBACA,aACD;AACD,cAAU,SAAS,KAAK;AACxB,cAAU,gBAAgB,KAAK;AAC/B,cAAU,QAAQ,KAAK;AACvB,cAAU,WAAW,KAAK;AAC1B,cAAU,cAAc,UAAU,cAAc,KAAK;AAKrD,mBAAe,IAAI,KAAK;AAGxB,WACE,UAAU,UAAU,KAAA,KAAa,KAAK,UAAU,UAAU,OAC1D,8CACD;AACD,cAAU,QAAQ,KAAK;AACvB;;AAEF,aAAU,cAAc,IAAI;;AAG9B,MAAI,aACF,cAAa,IAAI;GACf,MAAM;GACN,UAAU;GACV,MAAM,MAAA;GACN;GACA;GACA,cAAc,WAAW,UAAU;GACpC,CAAC;AAGJ,SAAO;;CAGT,qBACE,eACA,YACA,MACA,cACM;AACN,gBAAc,IAAI;GAChB,MAAM;GACN,UAAU;GACV,MAAM,MAAA;GACN;GACA;GACA,MAAM,MAAM,QAAQ;GACrB,CAAC;AAEF,MAAI,MAAA,SAAe,MAAM;GACvB,MAAM,iBAAiB,CAAC,GAAG,GAAG,cAAc;;;;;;;;AAQ5C,QAAK,MAAM,SAAS,MAAA,OAClB,OAAM,qBACJ,gBACA,YACA,MACA,aACD;AAEH;;EAGF,IAAI,IAAI;AACR,OAAK,MAAM,SAAS,MAAA,QAAc;AAChC,SAAM,qBACJ,CAAC,GAAG,GAAG,cAAc,EACrB,YACA,MACA,aACD;AACD"}

package/out/zql/src/planner/planner-fan-out.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner-fan-out.js","names":["#outputs","#input","#type"],"sources":["../../../../../zql/src/planner/planner-fan-out.ts"],"sourcesContent":["import type {PlannerConstraint} from './planner-constraint.ts';\nimport type {PlanDebugger} from './planner-debug.ts';\nimport {omitFanout} from './planner-node.ts';\nimport type {\n  CostEstimate,\n  JoinOrConnection,\n  PlannerNode,\n} from './planner-node.ts';\nimport type {PlannerTerminus} from './planner-terminus.ts';\n\nexport class PlannerFanOut {\n  readonly kind = 'fan-out' as const;\n  #type: 'FO' | 'UFO';\n  readonly #outputs: PlannerNode[] = [];\n  readonly #input: Exclude<PlannerNode, PlannerTerminus>;\n\n  constructor(input: Exclude<PlannerNode, PlannerTerminus>) {\n    this.#type = 'FO';\n    this.#input = input;\n  }\n\n  get type() {\n    return this.#type;\n  }\n\n  addOutput(node: PlannerNode): void {\n    this.#outputs.push(node);\n  }\n\n  get outputs(): PlannerNode[] {\n    return this.#outputs;\n  }\n\n  closestJoinOrSource(): JoinOrConnection {\n    return this.#input.closestJoinOrSource();\n  }\n\n  propagateConstraints(\n    branchPattern: number[],\n    constraint: PlannerConstraint | undefined,\n    from?: PlannerNode,\n    planDebugger?: PlanDebugger,\n  ): void {\n    planDebugger?.log({\n      type: 'node-constraint',\n      nodeType: 'fan-out',\n      node: 'FO',\n      branchPattern,\n      constraint,\n      from: from?.kind ?? 'unknown',\n    });\n\n    this.#input.propagateConstraints(\n      branchPattern,\n      constraint,\n      this,\n      planDebugger,\n    );\n  }\n\n  estimateCost(\n    downstreamChildSelectivity: number,\n    branchPattern: number[],\n    planDebugger?: PlanDebugger,\n  ): CostEstimate {\n    const ret = this.#input.estimateCost(\n      downstreamChildSelectivity,\n      branchPattern,\n      planDebugger,\n    );\n\n    if (planDebugger) {\n      planDebugger.log({\n        type: 'node-cost',\n        nodeType: 'fan-out',\n        node: 'FO',\n        branchPattern,\n        downstreamChildSelectivity,\n        costEstimate: omitFanout(ret),\n      });\n    }\n\n    return ret;\n  }\n\n  convertToUFO(): void {\n    this.#type = 'UFO';\n  }\n\n  reset(): void {\n    this.#type = 'FO';\n  }\n\n  /**\n   * Propagate unlimiting when a parent join is flipped.\n   * Fan-out propagates to its input.\n   */\n  propagateUnlimitFromFlippedJoin(): void {\n    if (\n      'propagateUnlimitFromFlippedJoin' in this.#input &&\n      typeof this.#input.propagateUnlimitFromFlippedJoin === 'function'\n    ) {\n      (\n        this.#input as {propagateUnlimitFromFlippedJoin(): void}\n      ).propagateUnlimitFromFlippedJoin();\n    }\n  }\n}\n"],"mappings":";;AAUA,IAAa,gBAAb,MAA2B;CACzB,OAAgB;CAChB;CACA,WAAmC,EAAE;CACrC;CAEA,YAAY,OAA8C;AACxD,QAAA,OAAa;AACb,QAAA,QAAc;;CAGhB,IAAI,OAAO;AACT,SAAO,MAAA;;CAGT,UAAU,MAAyB;AACjC,QAAA,QAAc,KAAK,KAAK;;CAG1B,IAAI,UAAyB;AAC3B,SAAO,MAAA;;CAGT,sBAAwC;AACtC,SAAO,MAAA,MAAY,qBAAqB;;CAG1C,qBACE,eACA,YACA,MACA,cACM;AACN,gBAAc,IAAI;GAChB,MAAM;GACN,UAAU;GACV,MAAM;GACN;GACA;GACA,MAAM,MAAM,QAAQ;GACrB,CAAC;AAEF,QAAA,MAAY,qBACV,eACA,YACA,MACA,aACD;;CAGH,aACE,4BACA,eACA,cACc;EACd,MAAM,MAAM,MAAA,MAAY,aACtB,4BACA,eACA,aACD;AAED,MAAI,aACF,cAAa,IAAI;GACf,MAAM;GACN,UAAU;GACV,MAAM;GACN;GACA;GACA,cAAc,WAAW,IAAI;GAC9B,CAAC;AAGJ,SAAO;;CAGT,eAAqB;AACnB,QAAA,OAAa;;CAGf,QAAc;AACZ,QAAA,OAAa;;;;;;CAOf,kCAAwC;AACtC,MACE,qCAAqC,MAAA,SACrC,OAAO,MAAA,MAAY,oCAAoC,WAGrD,OAAA,MACA,iCAAiC"}