@rocicorp/zero 1.6.0-canary.11 → 1.6.0-canary.13

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

@@ -1 +1 @@
-{"version":3,"file":"planner-graph.js","names":["#sources","#terminus","#validateSnapshotShape","#restoreConnections","#restoreJoins","#restoreFanNodes"],"sources":["../../../../../zql/src/planner/planner-graph.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {PlannerConnection} from './planner-connection.ts';\nimport type {PlannerConstraint} from './planner-constraint.ts';\nimport type {PlanDebugger} from './planner-debug.ts';\nimport type {PlannerFanIn} from './planner-fan-in.ts';\nimport type {PlannerFanOut} from './planner-fan-out.ts';\nimport type {PlannerJoin} from './planner-join.ts';\nimport {omitFanout} from './planner-node.ts';\nimport type {PlannerNode} from './planner-node.ts';\nimport {PlannerSource, type ConnectionCostModel} from './planner-source.ts';\nimport type {PlannerTerminus} from './planner-terminus.ts';\n\n/**\n * Captured state of a plan for comparison and restoration.\n */\nexport type PlanState = {\n  connections: Array<{limit: number | undefined}>;\n  joins: Array<{type: 'semi' | 'flipped'}>;\n  fanOuts: Array<{type: 'FO' | 'UFO'}>;\n  fanIns: Array<{type: 'FI' | 'UFI'}>;\n  connectionConstraints: Array<Map<string, PlannerConstraint | undefined>>;\n};\n\n/**\n * Maximum number of flippable joins to attempt exhaustive enumeration.\n * With n flippable joins, we explore 2^n plans.\n * 10 joins = 1024 plans (~100-200ms), 12 joins = 4096 plans (~400ms - 1 second)\n */\nconst MAX_FLIPPABLE_JOINS = 9;\n\n/**\n * Cached information about FanOut→FanIn relationships.\n * Computed once during planning to avoid redundant BFS traversals.\n */\ntype FOFIInfo = {\n  fi: PlannerFanIn | undefined;\n  joinsBetween: PlannerJoin[];\n};\n\nexport class PlannerGraph {\n  // Sources indexed by table name\n  readonly #sources = new Map<string, PlannerSource>();\n\n  // The final output node where constraint propagation starts\n  #terminus: PlannerTerminus | undefined = undefined;\n\n  // Collections of nodes with mutable planning state\n  joins: PlannerJoin[] = [];\n  fanOuts: PlannerFanOut[] = [];\n  fanIns: PlannerFanIn[] = [];\n  connections: PlannerConnection[] = [];\n\n  /**\n   * Reset all planning state back to initial values for another planning pass.\n   * Resets only mutable planning state - graph structure is unchanged.\n   *\n   * This allows replanning the same query graph with different strategies.\n   */\n  resetPlanningState() {\n    for (const j of this.joins) j.reset();\n    for (const fo of this.fanOuts) fo.reset();\n    for (const fi of this.fanIns) fi.reset();\n    for (const c of this.connections) c.reset();\n  }\n\n  /**\n   * Create and register a source (table) in the graph.\n   */\n  addSource(name: string, model: ConnectionCostModel): PlannerSource {\n    assert(\n      !this.#sources.has(name),\n      `Source ${name} already exists in the graph`,\n    );\n    const source = new PlannerSource(name, model);\n    this.#sources.set(name, source);\n    return source;\n  }\n\n  /**\n   * Get a source by table name.\n   */\n  getSource(name: string): PlannerSource {\n    const source = this.#sources.get(name);\n    assert(source !== undefined, `Source ${name} not found in the graph`);\n    return source;\n  }\n\n  /**\n   * Check if a source exists by table name.\n   */\n  hasSource(name: string): boolean {\n    return this.#sources.has(name);\n  }\n\n  /**\n   * Set the terminus (final output) node of the graph.\n   * Constraint propagation starts from this node.\n   */\n  setTerminus(terminus: PlannerTerminus): void {\n    this.#terminus = terminus;\n  }\n\n  /**\n   * Initiate constraint propagation from the terminus node.\n   * This sends constraints up through the graph to update\n   * connection cost estimates.\n   */\n  propagateConstraints(planDebugger?: PlanDebugger): void {\n    assert(\n      this.#terminus !== undefined,\n      'Cannot propagate constraints without a terminus node',\n    );\n    this.#terminus.propagateConstraints(planDebugger);\n  }\n\n  /**\n   * Calculate total cost of the current plan.\n   * Total cost includes both startup cost (one-time, e.g., sorting) and running cost.\n   */\n  getTotalCost(planDebugger?: PlanDebugger): number {\n    const estimate = must(this.#terminus).estimateCost(planDebugger);\n    return estimate.cost + estimate.startupCost;\n  }\n\n  /**\n   * Capture a lightweight snapshot of the current planning state.\n   * Used for backtracking during multi-start greedy search.\n   *\n   * Captures mutable state including pinned flags, join types, and\n   * constraint maps to avoid needing repropagation on restore.\n   *\n   * @returns A snapshot that can be restored via restorePlanningSnapshot()\n   */\n  capturePlanningSnapshot(): PlanState {\n    return {\n      connections: this.connections.map(c => ({\n        limit: c.limit,\n      })),\n      joins: this.joins.map(j => ({type: j.type})),\n      fanOuts: this.fanOuts.map(fo => ({type: fo.type})),\n      fanIns: this.fanIns.map(fi => ({type: fi.type})),\n      connectionConstraints: this.connections.map(c => c.captureConstraints()),\n    };\n  }\n\n  /**\n   * Restore planning state from a previously captured snapshot.\n   * Used for backtracking when a planning attempt fails.\n   *\n   * Restores pinned flags, join types, and constraint maps, eliminating\n   * the need for repropagation.\n   *\n   * @param state - Snapshot created by capturePlanningSnapshot()\n   */\n  restorePlanningSnapshot(state: PlanState): void {\n    this.#validateSnapshotShape(state);\n    this.#restoreConnections(state);\n    this.#restoreJoins(state);\n    this.#restoreFanNodes(state);\n  }\n\n  /**\n   * Validate that snapshot shape matches current graph structure.\n   */\n  #validateSnapshotShape(state: PlanState): void {\n    assert(\n      this.connections.length === state.connections.length,\n      'Plan state mismatch: connections',\n    );\n    assert(\n      this.joins.length === state.joins.length,\n      'Plan state mismatch: joins',\n    );\n    assert(\n      this.fanOuts.length === state.fanOuts.length,\n      'Plan state mismatch: fanOuts',\n    );\n    assert(\n      this.fanIns.length === state.fanIns.length,\n      'Plan state mismatch: fanIns',\n    );\n    assert(\n      this.connections.length === state.connectionConstraints.length,\n      'Plan state mismatch: connectionConstraints',\n    );\n  }\n\n  /**\n   * Restore connection pinned flags, limits, and constraint maps.\n   */\n  #restoreConnections(state: PlanState): void {\n    for (let i = 0; i < this.connections.length; i++) {\n      this.connections[i].limit = state.connections[i].limit;\n      this.connections[i].restoreConstraints(state.connectionConstraints[i]);\n    }\n  }\n\n  /**\n   * Restore join types and pinned flags.\n   */\n  #restoreJoins(state: PlanState): void {\n    for (let i = 0; i < this.joins.length; i++) {\n      const join = this.joins[i];\n      const targetState = state.joins[i];\n\n      // Reset to initial state first\n      join.reset();\n\n      // Apply target state\n      if (targetState.type === 'flipped' && join.type !== 'flipped') {\n        join.flip();\n      }\n      assert(\n        targetState.type === join.type,\n        'join is not in the correct state after reset',\n      );\n    }\n  }\n\n  /**\n   * Restore FanOut and FanIn types.\n   */\n  #restoreFanNodes(state: PlanState): void {\n    for (let i = 0; i < this.fanOuts.length; i++) {\n      const fo = this.fanOuts[i];\n      const targetType = state.fanOuts[i].type;\n      if (targetType === 'UFO' && fo.type === 'FO') {\n        fo.convertToUFO();\n      }\n    }\n\n    for (let i = 0; i < this.fanIns.length; i++) {\n      const fi = this.fanIns[i];\n      const targetType = state.fanIns[i].type;\n      if (targetType === 'UFI' && fi.type === 'FI') {\n        fi.convertToUFI();\n      }\n    }\n  }\n\n  /**\n   * Main planning algorithm using exhaustive join flip enumeration.\n   *\n   * Enumerates all possible flip patterns for flippable joins (2^n for n flippable joins).\n   * Each pattern represents a different query execution plan. We evaluate the cost of each\n   * plan and select the one with the lowest cost.\n   *\n   * Connections are used only for cost estimation - the flip patterns determine the plan.\n   * FanOut/FanIn states (FO/UFO and FI/UFI) are automatically derived from join flip states.\n   *\n   * @param planDebugger - Optional debugger to receive structured events during planning\n   * @param lc - Optional logger for warnings\n   */\n  plan(planDebugger?: PlanDebugger, lc?: LogContext): void {\n    // Get all flippable joins\n    const flippableJoins = this.joins.filter(j => j.isFlippable());\n\n    // Too many flippable joins - skip optimization and run as-is\n    if (flippableJoins.length > MAX_FLIPPABLE_JOINS) {\n      lc?.warn?.(\n        `Query has ${flippableJoins.length} EXISTS checks which would require ` +\n          `${2 ** flippableJoins.length} plan evaluations. Skipping optimization.`,\n      );\n      return;\n    }\n\n    // Build FO→FI cache once to avoid redundant BFS traversals in each iteration\n    const fofiCache = buildFOFICache(this);\n\n    const numPatterns =\n      flippableJoins.length === 0 ? 0 : 2 ** flippableJoins.length;\n    let bestCost = Infinity;\n    let bestPlan: PlanState | undefined = undefined;\n    let bestAttemptNumber = -1;\n\n    // Enumerate all flip patterns\n    for (let pattern = 0; pattern < numPatterns; pattern++) {\n      // Reset to initial state\n      this.resetPlanningState();\n\n      if (planDebugger) {\n        planDebugger.log({\n          type: 'attempt-start',\n          attemptNumber: pattern,\n          totalAttempts: numPatterns,\n        });\n      }\n\n      // Apply flip pattern (treat pattern as bitmask)\n      // Bit i set to 1 means flip join i\n      for (let i = 0; i < flippableJoins.length; i++) {\n        if (pattern & (1 << i)) {\n          flippableJoins[i].flip();\n        }\n      }\n\n      // Derive FO/UFO and FI/UFI states from join flip states\n      checkAndConvertFOFI(fofiCache);\n\n      // Propagate unlimiting for flipped joins\n      propagateUnlimitForFlippedJoins(this);\n\n      // Propagate constraints through the graph\n      this.propagateConstraints(planDebugger);\n\n      if (planDebugger) {\n        planDebugger.log({\n          type: 'constraints-propagated',\n          attemptNumber: pattern,\n          connectionConstraints: this.connections.map(c => {\n            const constraintCosts = c.getConstraintCostsForDebug();\n            const constraintCostsWithoutFanout: Record<\n              string,\n              Omit<(typeof constraintCosts)[string], 'fanout'>\n            > = {};\n            for (const [key, cost] of Object.entries(constraintCosts)) {\n              constraintCostsWithoutFanout[key] = omitFanout(cost);\n            }\n            return {\n              connection: c.name,\n              constraints: c.getConstraintsForDebug(),\n              constraintCosts: constraintCostsWithoutFanout,\n            };\n          }),\n        });\n      }\n\n      // Evaluate this plan\n      const totalCost = this.getTotalCost(planDebugger);\n\n      if (planDebugger) {\n        planDebugger.log({\n          type: 'plan-complete',\n          attemptNumber: pattern,\n          totalCost,\n          flipPattern: pattern, // Bitmask of which joins are flipped\n          planSnapshot: this.capturePlanningSnapshot(),\n          joinStates: this.joins.map(j => {\n            const info = j.getDebugInfo();\n            return {\n              join: info.name,\n              type: info.type,\n            };\n          }),\n        });\n      }\n\n      // Track best plan\n      if (totalCost < bestCost) {\n        bestCost = totalCost;\n        bestPlan = this.capturePlanningSnapshot();\n        bestAttemptNumber = pattern;\n      }\n    }\n\n    // Restore best plan\n    if (bestPlan) {\n      this.restorePlanningSnapshot(bestPlan);\n      // Propagate constraints to ensure all derived state is consistent\n      this.propagateConstraints(planDebugger);\n\n      if (planDebugger) {\n        planDebugger.log({\n          type: 'best-plan-selected',\n          bestAttemptNumber,\n          totalCost: bestCost,\n          flipPattern: bestAttemptNumber, // The best attempt number is also the flip pattern\n          joinStates: this.joins.map(j => ({\n            join: j.getName(),\n            type: j.type,\n          })),\n        });\n      }\n    } else {\n      assert(\n        numPatterns === 0,\n        'no plan was found but flippable joins did exist!',\n      );\n    }\n  }\n}\n\n/**\n * Build cache of FO→FI relationships and joins between them.\n * Called once at the start of planning to avoid redundant BFS traversals.\n */\nfunction buildFOFICache(graph: PlannerGraph): Map<PlannerFanOut, FOFIInfo> {\n  const cache = new Map<PlannerFanOut, FOFIInfo>();\n\n  for (const fo of graph.fanOuts) {\n    const info = findFIAndJoins(fo);\n    cache.set(fo, info);\n  }\n\n  return cache;\n}\n\n/**\n * Check if any joins downstream of a FanOut (before reaching FanIn) are flipped.\n * If so, convert the FO to UFO and the FI to UFI.\n *\n * This must be called after join flipping and before propagateConstraints.\n */\nfunction checkAndConvertFOFI(fofiCache: Map<PlannerFanOut, FOFIInfo>): void {\n  for (const [fo, info] of fofiCache) {\n    const hasFlippedJoin = info.joinsBetween.some(j => j.type === 'flipped');\n    if (info.fi && hasFlippedJoin) {\n      fo.convertToUFO();\n      info.fi.convertToUFI();\n    }\n  }\n}\n\n/**\n * Traverse from a FanOut through its outputs to find the corresponding FanIn\n * and collect all joins along the way.\n */\nfunction findFIAndJoins(fo: PlannerFanOut): FOFIInfo {\n  const joinsBetween: PlannerJoin[] = [];\n  let fi: PlannerFanIn | undefined = undefined;\n\n  // BFS through FO outputs to find FI and collect joins\n  const queue: PlannerNode[] = [...fo.outputs];\n  const visited = new Set<PlannerNode>();\n\n  while (queue.length > 0) {\n    const node = must(queue.shift());\n    if (visited.has(node)) continue;\n    visited.add(node);\n\n    switch (node.kind) {\n      case 'join':\n        joinsBetween.push(node);\n        queue.push(node.output);\n        break;\n      case 'fan-out':\n        // Nested FO - traverse its outputs\n        queue.push(...node.outputs);\n        break;\n      case 'fan-in':\n        // Found the FI - this is the boundary, don't traverse further\n        fi = node;\n        break;\n      case 'connection':\n        // Shouldn't happen in a well-formed graph\n        break;\n      case 'terminus':\n        // Reached the end without finding FI\n        break;\n    }\n  }\n\n  return {fi, joinsBetween};\n}\n\n/**\n * Propagate unlimiting to all flipped joins in the graph.\n * When a join is flipped, its child becomes the outer loop and should no longer\n * be limited by EXISTS semantics.\n *\n * This must be called after join flipping and before propagateConstraints.\n */\nfunction propagateUnlimitForFlippedJoins(graph: PlannerGraph): void {\n  for (const join of graph.joins) {\n    if (join.type === 'flipped') {\n      join.propagateUnlimit();\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"planner-graph.js","names":["#sources","#terminus","#validateSnapshotShape","#restoreConnections","#restoreJoins","#restoreFanNodes"],"sources":["../../../../../zql/src/planner/planner-graph.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {PlannerConnection} from './planner-connection.ts';\nimport type {PlannerConstraint} from './planner-constraint.ts';\nimport type {PlanDebugger} from './planner-debug.ts';\nimport type {PlannerFanIn} from './planner-fan-in.ts';\nimport type {PlannerFanOut} from './planner-fan-out.ts';\nimport type {PlannerJoin} from './planner-join.ts';\nimport {omitFanout} from './planner-node.ts';\nimport type {PlannerNode} from './planner-node.ts';\nimport {PlannerSource, type ConnectionCostModel} from './planner-source.ts';\nimport type {PlannerTerminus} from './planner-terminus.ts';\n\n/**\n * Captured state of a plan for comparison and restoration.\n */\nexport type PlanState = {\n  connections: Array<{limit: number | undefined}>;\n  joins: Array<{type: 'semi' | 'flipped'}>;\n  fanOuts: Array<{type: 'FO' | 'UFO'}>;\n  fanIns: Array<{type: 'FI' | 'UFI'}>;\n  connectionConstraints: Array<Map<string, PlannerConstraint | undefined>>;\n};\n\n/**\n * Maximum number of flippable joins to attempt exhaustive enumeration.\n * With n flippable joins, we explore 2^n plans.\n * 10 joins = 1024 plans (~100-200ms), 12 joins = 4096 plans (~400ms - 1 second)\n */\nconst MAX_FLIPPABLE_JOINS = 9;\n\n/**\n * Cached information about FanOut→FanIn relationships.\n * Computed once during planning to avoid redundant BFS traversals.\n */\ntype FOFIInfo = {\n  fi: PlannerFanIn | undefined;\n  joinsBetween: PlannerJoin[];\n};\n\nexport class PlannerGraph {\n  // Sources indexed by table name\n  readonly #sources = new Map<string, PlannerSource>();\n\n  // The final output node where constraint propagation starts\n  #terminus: PlannerTerminus | undefined = undefined;\n\n  // Collections of nodes with mutable planning state\n  joins: PlannerJoin[] = [];\n  fanOuts: PlannerFanOut[] = [];\n  fanIns: PlannerFanIn[] = [];\n  connections: PlannerConnection[] = [];\n\n  /**\n   * Reset all planning state back to initial values for another planning pass.\n   * Resets only mutable planning state - graph structure is unchanged.\n   *\n   * This allows replanning the same query graph with different strategies.\n   */\n  resetPlanningState() {\n    for (const j of this.joins) j.reset();\n    for (const fo of this.fanOuts) fo.reset();\n    for (const fi of this.fanIns) fi.reset();\n    for (const c of this.connections) c.reset();\n  }\n\n  /**\n   * Create and register a source (table) in the graph.\n   */\n  addSource(name: string, model: ConnectionCostModel): PlannerSource {\n    assert(\n      !this.#sources.has(name),\n      `Source ${name} already exists in the graph`,\n    );\n    const source = new PlannerSource(name, model);\n    this.#sources.set(name, source);\n    return source;\n  }\n\n  /**\n   * Get a source by table name.\n   */\n  getSource(name: string): PlannerSource {\n    const source = this.#sources.get(name);\n    assert(source !== undefined, `Source ${name} not found in the graph`);\n    return source;\n  }\n\n  /**\n   * Check if a source exists by table name.\n   */\n  hasSource(name: string): boolean {\n    return this.#sources.has(name);\n  }\n\n  /**\n   * Set the terminus (final output) node of the graph.\n   * Constraint propagation starts from this node.\n   */\n  setTerminus(terminus: PlannerTerminus): void {\n    this.#terminus = terminus;\n  }\n\n  /**\n   * Initiate constraint propagation from the terminus node.\n   * This sends constraints up through the graph to update\n   * connection cost estimates.\n   */\n  propagateConstraints(planDebugger?: PlanDebugger): void {\n    assert(\n      this.#terminus !== undefined,\n      'Cannot propagate constraints without a terminus node',\n    );\n    this.#terminus.propagateConstraints(planDebugger);\n  }\n\n  /**\n   * Calculate total cost of the current plan.\n   * Total cost includes both startup cost (one-time, e.g., sorting) and running cost.\n   */\n  getTotalCost(planDebugger?: PlanDebugger): number {\n    const estimate = must(this.#terminus).estimateCost(planDebugger);\n    return estimate.cost + estimate.startupCost;\n  }\n\n  /**\n   * Capture a lightweight snapshot of the current planning state.\n   * Used for backtracking during multi-start greedy search.\n   *\n   * Captures mutable state including pinned flags, join types, and\n   * constraint maps to avoid needing repropagation on restore.\n   *\n   * @returns A snapshot that can be restored via restorePlanningSnapshot()\n   */\n  capturePlanningSnapshot(): PlanState {\n    return {\n      connections: this.connections.map(c => ({\n        limit: c.limit,\n      })),\n      joins: this.joins.map(j => ({type: j.type})),\n      fanOuts: this.fanOuts.map(fo => ({type: fo.type})),\n      fanIns: this.fanIns.map(fi => ({type: fi.type})),\n      connectionConstraints: this.connections.map(c => c.captureConstraints()),\n    };\n  }\n\n  /**\n   * Restore planning state from a previously captured snapshot.\n   * Used for backtracking when a planning attempt fails.\n   *\n   * Restores pinned flags, join types, and constraint maps, eliminating\n   * the need for repropagation.\n   *\n   * @param state - Snapshot created by capturePlanningSnapshot()\n   */\n  restorePlanningSnapshot(state: PlanState): void {\n    this.#validateSnapshotShape(state);\n    this.#restoreConnections(state);\n    this.#restoreJoins(state);\n    this.#restoreFanNodes(state);\n  }\n\n  /**\n   * Validate that snapshot shape matches current graph structure.\n   */\n  #validateSnapshotShape(state: PlanState): void {\n    assert(\n      this.connections.length === state.connections.length,\n      'Plan state mismatch: connections',\n    );\n    assert(\n      this.joins.length === state.joins.length,\n      'Plan state mismatch: joins',\n    );\n    assert(\n      this.fanOuts.length === state.fanOuts.length,\n      'Plan state mismatch: fanOuts',\n    );\n    assert(\n      this.fanIns.length === state.fanIns.length,\n      'Plan state mismatch: fanIns',\n    );\n    assert(\n      this.connections.length === state.connectionConstraints.length,\n      'Plan state mismatch: connectionConstraints',\n    );\n  }\n\n  /**\n   * Restore connection pinned flags, limits, and constraint maps.\n   */\n  #restoreConnections(state: PlanState): void {\n    for (let i = 0; i < this.connections.length; i++) {\n      this.connections[i].limit = state.connections[i].limit;\n      this.connections[i].restoreConstraints(state.connectionConstraints[i]);\n    }\n  }\n\n  /**\n   * Restore join types and pinned flags.\n   */\n  #restoreJoins(state: PlanState): void {\n    for (let i = 0; i < this.joins.length; i++) {\n      const join = this.joins[i];\n      const targetState = state.joins[i];\n\n      // Reset to initial state first\n      join.reset();\n\n      // Apply target state\n      if (targetState.type === 'flipped' && join.type !== 'flipped') {\n        join.flip();\n      }\n      assert(\n        targetState.type === join.type,\n        'join is not in the correct state after reset',\n      );\n    }\n  }\n\n  /**\n   * Restore FanOut and FanIn types.\n   */\n  #restoreFanNodes(state: PlanState): void {\n    for (let i = 0; i < this.fanOuts.length; i++) {\n      const fo = this.fanOuts[i];\n      const targetType = state.fanOuts[i].type;\n      if (targetType === 'UFO' && fo.type === 'FO') {\n        fo.convertToUFO();\n      }\n    }\n\n    for (let i = 0; i < this.fanIns.length; i++) {\n      const fi = this.fanIns[i];\n      const targetType = state.fanIns[i].type;\n      if (targetType === 'UFI' && fi.type === 'FI') {\n        fi.convertToUFI();\n      }\n    }\n  }\n\n  /**\n   * Main planning algorithm using exhaustive join flip enumeration.\n   *\n   * Enumerates all possible flip patterns for flippable joins (2^n for n flippable joins).\n   * Each pattern represents a different query execution plan. We evaluate the cost of each\n   * plan and select the one with the lowest cost.\n   *\n   * Connections are used only for cost estimation - the flip patterns determine the plan.\n   * FanOut/FanIn states (FO/UFO and FI/UFI) are automatically derived from join flip states.\n   *\n   * @param planDebugger - Optional debugger to receive structured events during planning\n   * @param lc - Optional logger for warnings\n   */\n  plan(planDebugger?: PlanDebugger, lc?: LogContext): void {\n    // Get all flippable joins\n    const flippableJoins = this.joins.filter(j => j.isFlippable());\n\n    // Too many flippable joins - skip optimization and run as-is\n    if (flippableJoins.length > MAX_FLIPPABLE_JOINS) {\n      lc?.warn?.(\n        `Query has ${flippableJoins.length} EXISTS checks which would require ` +\n          `${2 ** flippableJoins.length} plan evaluations. Skipping optimization.`,\n      );\n      return;\n    }\n\n    // Build FO→FI cache once to avoid redundant BFS traversals in each iteration\n    const fofiCache = buildFOFICache(this);\n\n    const numPatterns =\n      flippableJoins.length === 0 ? 0 : 2 ** flippableJoins.length;\n    let bestCost = Infinity;\n    let bestPlan: PlanState | undefined = undefined;\n    let bestAttemptNumber = -1;\n\n    // Enumerate all flip patterns\n    for (let pattern = 0; pattern < numPatterns; pattern++) {\n      // Reset to initial state\n      this.resetPlanningState();\n\n      if (planDebugger) {\n        planDebugger.log({\n          type: 'attempt-start',\n          attemptNumber: pattern,\n          totalAttempts: numPatterns,\n        });\n      }\n\n      // Apply flip pattern (treat pattern as bitmask)\n      // Bit i set to 1 means flip join i\n      for (let i = 0; i < flippableJoins.length; i++) {\n        if (pattern & (1 << i)) {\n          flippableJoins[i].flip();\n        }\n      }\n\n      // Derive FO/UFO and FI/UFI states from join flip states\n      checkAndConvertFOFI(fofiCache);\n\n      // Propagate unlimiting for flipped joins\n      propagateUnlimitForFlippedJoins(this);\n\n      // Propagate constraints through the graph\n      this.propagateConstraints(planDebugger);\n\n      if (planDebugger) {\n        planDebugger.log({\n          type: 'constraints-propagated',\n          attemptNumber: pattern,\n          connectionConstraints: this.connections.map(c => {\n            const constraintCosts = c.getConstraintCostsForDebug();\n            const constraintCostsWithoutFanout: Record<\n              string,\n              Omit<(typeof constraintCosts)[string], 'fanout'>\n            > = {};\n            for (const [key, cost] of Object.entries(constraintCosts)) {\n              constraintCostsWithoutFanout[key] = omitFanout(cost);\n            }\n            return {\n              connection: c.name,\n              constraints: c.getConstraintsForDebug(),\n              constraintCosts: constraintCostsWithoutFanout,\n            };\n          }),\n        });\n      }\n\n      // Evaluate this plan\n      const totalCost = this.getTotalCost(planDebugger);\n\n      if (planDebugger) {\n        planDebugger.log({\n          type: 'plan-complete',\n          attemptNumber: pattern,\n          totalCost,\n          flipPattern: pattern, // Bitmask of which joins are flipped\n          planSnapshot: this.capturePlanningSnapshot(),\n          joinStates: this.joins.map(j => {\n            const info = j.getDebugInfo();\n            return {\n              join: info.name,\n              type: info.type,\n            };\n          }),\n        });\n      }\n\n      // Track best plan\n      if (totalCost < bestCost) {\n        bestCost = totalCost;\n        bestPlan = this.capturePlanningSnapshot();\n        bestAttemptNumber = pattern;\n      }\n    }\n\n    // Restore best plan\n    if (bestPlan) {\n      this.restorePlanningSnapshot(bestPlan);\n      // Propagate constraints to ensure all derived state is consistent\n      this.propagateConstraints(planDebugger);\n\n      if (planDebugger) {\n        planDebugger.log({\n          type: 'best-plan-selected',\n          bestAttemptNumber,\n          totalCost: bestCost,\n          flipPattern: bestAttemptNumber, // The best attempt number is also the flip pattern\n          joinStates: this.joins.map(j => ({\n            join: j.getName(),\n            type: j.type,\n          })),\n        });\n      }\n    } else {\n      assert(\n        numPatterns === 0,\n        'no plan was found but flippable joins did exist!',\n      );\n    }\n  }\n}\n\n/**\n * Build cache of FO→FI relationships and joins between them.\n * Called once at the start of planning to avoid redundant BFS traversals.\n */\nfunction buildFOFICache(graph: PlannerGraph): Map<PlannerFanOut, FOFIInfo> {\n  const cache = new Map<PlannerFanOut, FOFIInfo>();\n\n  for (const fo of graph.fanOuts) {\n    const info = findFIAndJoins(fo);\n    cache.set(fo, info);\n  }\n\n  return cache;\n}\n\n/**\n * Check if any joins downstream of a FanOut (before reaching FanIn) are flipped.\n * If so, convert the FO to UFO and the FI to UFI.\n *\n * This must be called after join flipping and before propagateConstraints.\n */\nfunction checkAndConvertFOFI(fofiCache: Map<PlannerFanOut, FOFIInfo>): void {\n  for (const [fo, info] of fofiCache) {\n    const hasFlippedJoin = info.joinsBetween.some(j => j.type === 'flipped');\n    if (info.fi && hasFlippedJoin) {\n      fo.convertToUFO();\n      info.fi.convertToUFI();\n    }\n  }\n}\n\n/**\n * Traverse from a FanOut through its outputs to find the corresponding FanIn\n * and collect all joins along the way.\n */\nfunction findFIAndJoins(fo: PlannerFanOut): FOFIInfo {\n  const joinsBetween: PlannerJoin[] = [];\n  let fi: PlannerFanIn | undefined = undefined;\n\n  // BFS through FO outputs to find FI and collect joins\n  const queue: PlannerNode[] = [...fo.outputs];\n  const visited = new Set<PlannerNode>();\n\n  while (queue.length > 0) {\n    const node = must(queue.shift());\n    if (visited.has(node)) continue;\n    visited.add(node);\n\n    switch (node.kind) {\n      case 'join':\n        joinsBetween.push(node);\n        queue.push(node.output);\n        break;\n      case 'fan-out':\n        // Nested FO - traverse its outputs\n        queue.push(...node.outputs);\n        break;\n      case 'fan-in':\n        // Found the FI - this is the boundary, don't traverse further\n        fi = node;\n        break;\n      case 'connection':\n        // Shouldn't happen in a well-formed graph\n        break;\n      case 'terminus':\n        // Reached the end without finding FI\n        break;\n    }\n  }\n\n  return {fi, joinsBetween};\n}\n\n/**\n * Propagate unlimiting to all flipped joins in the graph.\n * When a join is flipped, its child becomes the outer loop and should no longer\n * be limited by EXISTS semantics.\n *\n * This must be called after join flipping and before propagateConstraints.\n */\nfunction propagateUnlimitForFlippedJoins(graph: PlannerGraph): void {\n  for (const join of graph.joins) {\n    if (join.type === 'flipped') {\n      join.propagateUnlimit();\n    }\n  }\n}\n"],"mappings":"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"}

package/out/zql/src/planner/planner-join.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"planner-join.d.ts","sourceRoot":"","sources":["../../../../../zql/src/planner/planner-join.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAoC3D;;;;;;;;;;;;;;;GAeG;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,WAAW;;IACtB,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAU;IAOhC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAQtB,MAAM,EAAE,OAAO,CAAC,WAAW,EAAE,eAAe,CAAC,EAC7C,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE,eAAe,CAAC,EAC5C,gBAAgB,EAAE,iBAAiB,EACnC,eAAe,EAAE,iBAAiB,EAClC,SAAS,EAAE,OAAO,EAClB,MAAM,EAAE,MAAM,EACd,WAAW,GAAE,MAAM,GAAG,SAAkB;IAY1C,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAIlC,IAAI,MAAM,IAAI,WAAW,CAGxB;IAED,mBAAmB,IAAI,gBAAgB;IAIvC,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAWtC,IAAI,IAAI,IAAI;IAUZ,IAAI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;IACD,WAAW,IAAI,OAAO;IAItB;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,IAAI,IAAI;IAMxB;;;;;OAKG;IACH,+BAA+B,IAAI,IAAI;IAIvC,oBAAoB,CAClB,aAAa,EAAE,MAAM,EAAE,EACvB,UAAU,EAAE,iBAAiB,GAAG,SAAS,EACzC,IAAI,CAAC,EAAE,WAAW,EAClB,YAAY,CAAC,EAAE,YAAY,GAC1B,IAAI;IAuDP,KAAK,IAAI,IAAI;IAIb,YAAY;IACV;;;;;;;;OAQG;IACH,0BAA0B,EAAE,MAAM;IAClC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,aAAa,EAAE,MAAM,EAAE,EACvB,YAAY,CAAC,EAAE,YAAY,GAC1B,YAAY;IAuHf;;;OAGG;IACH,OAAO,IAAI,MAAM;IAMjB;;OAEG;IACH,YAAY,IAAI;QACd,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;QACzB,MAAM,EAAE,MAAM,CAAC;KAChB;CAOF;AAED,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B"}
+{"version":3,"file":"planner-join.d.ts","sourceRoot":"","sources":["../../../../../zql/src/planner/planner-join.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAoC3D;;;;;;;;;;;;;;;GAeG;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,WAAW;;IACtB,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAU;IAOhC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAQtB,MAAM,EAAE,OAAO,CAAC,WAAW,EAAE,eAAe,CAAC,EAC7C,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE,eAAe,CAAC,EAC5C,gBAAgB,EAAE,iBAAiB,EACnC,eAAe,EAAE,iBAAiB,EAClC,SAAS,EAAE,OAAO,EAClB,MAAM,EAAE,MAAM,EACd,WAAW,GAAE,MAAM,GAAG,SAAkB;IAY1C,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAIlC,IAAI,MAAM,IAAI,WAAW,CAGxB;IAED,mBAAmB,IAAI,gBAAgB;IAIvC,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAWtC,IAAI,IAAI,IAAI;IAUZ,IAAI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;IACD,WAAW,IAAI,OAAO;IAItB;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,IAAI,IAAI;IAMxB;;;;;OAKG;IACH,+BAA+B,IAAI,IAAI;IAIvC,oBAAoB,CAClB,aAAa,EAAE,MAAM,EAAE,EACvB,UAAU,EAAE,iBAAiB,GAAG,SAAS,EACzC,IAAI,CAAC,EAAE,WAAW,EAClB,YAAY,CAAC,EAAE,YAAY,GAC1B,IAAI;IAuDP,KAAK,IAAI,IAAI;IAIb,YAAY;IACV;;;;;;;;OAQG;IACH,0BAA0B,EAAE,MAAM;IAClC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,aAAa,EAAE,MAAM,EAAE,EACvB,YAAY,CAAC,EAAE,YAAY,GAC1B,YAAY;IA8Gf;;;OAGG;IACH,OAAO,IAAI,MAAM;IAMjB;;OAEG;IACH,YAAY,IAAI;QACd,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;QACzB,MAAM,EAAE,MAAM,CAAC;KAChB;CAOF;AAED,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B"}

package/out/zql/src/planner/planner-join.js

@@ -1,5 +1,4 @@
 import { assert } from "../../../shared/src/asserts.js";
-import { getMultiConstraintChunkSize } from "../ivm/flipped-join.js";
 import { omitFanout } from "./planner-node.js";
 import { mergeConstraints } from "./planner-constraint.js";
 //#region ../zql/src/planner/planner-join.ts
@@ -202,7 +201,7 @@ var PlannerJoin = class {
 		else costEstimate = {
 			startupCost: child.startupCost,
 			scanEst: parent.limit === void 0 ? parent.returnedRows * child.returnedRows : Math.min(parent.returnedRows * child.returnedRows, downstreamChildSelectivity === 0 ? 0 : parent.limit / downstreamChildSelectivity),
-			cost: child.cost + Math.ceil(child.scanEst / getMultiConstraintChunkSize()) * parent.startupCost + child.scanEst * (parent.cost + parent.scanEst),
+			cost: child.cost + child.scanEst * (parent.startupCost + parent.cost + parent.scanEst),
 			returnedRows: parent.returnedRows * child.returnedRows,
 			selectivity: parent.selectivity * child.selectivity,
 			limit: parent.limit,

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

@@ -1 +1 @@
-{"version":3,"file":"planner-join.js","names":["#parent","#child","#parentConstraint","#childConstraint","#flippable","#initialType","#type","#output"],"sources":["../../../../../zql/src/planner/planner-join.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {getMultiConstraintChunkSize} from '../ivm/flipped-join.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';\nimport type {PlannerTerminus} from './planner-terminus.ts';\n\n/**\n * Translate constraints for a flipped join from parent space to child space.\n * Matches the runtime behavior of FlippedJoin.fetch() which translates\n * parent constraints to child constraints using index-based key mapping.\n *\n * Example:\n *   parentConstraint = {issueID: undefined, projectID: undefined}\n *   childConstraint = {id: undefined, projectID: undefined}\n *   incomingConstraint = {issueID: 5}\n *   result = {id: 5}  // issueID at index 0 maps to id at index 0\n */\nfunction translateConstraintsForFlippedJoin(\n  incomingConstraint: PlannerConstraint | undefined,\n  parentConstraint: PlannerConstraint,\n  childConstraint: PlannerConstraint,\n): PlannerConstraint | undefined {\n  if (!incomingConstraint) return undefined;\n\n  const parentKeys = Object.keys(parentConstraint);\n  const childKeys = Object.keys(childConstraint);\n  const translated: PlannerConstraint = {};\n\n  for (const [key, value] of Object.entries(incomingConstraint)) {\n    const index = parentKeys.indexOf(key);\n    if (index !== -1) {\n      // Found this key in parent at position `index`\n      // Map to child key at same position\n      translated[childKeys[index]] = value;\n    }\n  }\n\n  return Object.keys(translated).length > 0 ? translated : undefined;\n}\n\n/**\n * Semi-join overhead multiplier.\n *\n * Semi-joins represent correlated subqueries (EXISTS checks) which have\n * execution overhead compared to flipped joins, even when logical row counts\n * are identical. This overhead comes from:\n * - Need to execute a separate correlation check for each parent row\n * - Cannot leverage combined constraint checking as effectively as flipped joins\n *\n * A multiplier of 1.5 means semi-joins are estimated to be ~50% more expensive\n * than equivalent flipped joins, which empirically matches observed performance\n * differences in production workloads (e.g., 1.7x in zbugs benchmarks).\n *\n * Flipped joins have a different overhead in that they become unlimited. This\n * is accounted for when propagating unlimits rather than here.\n */\n// const SEMI_JOIN_OVERHEAD_MULTIPLIER = 1.5;\n\n/**\n * Represents a join between two data streams (parent and child).\n *\n * # Dual-State Pattern\n * Like all planner nodes, PlannerJoin separates:\n * 1. IMMUTABLE STRUCTURE: Parent/child nodes, constraints, flippability\n * 2. MUTABLE STATE: Join type (semi/flipped), pinned status\n *\n * # Join Flipping\n * A join can be in two states:\n * - 'semi': Parent is outer loop, child is inner (semi-join for EXISTS)\n * - 'flipped': Child is outer loop, parent is inner\n *\n * Flipping is the key optimization: choosing which table scans first.\n * NOT EXISTS joins cannot be flipped (#flippable = false).\n *\n * # Constraint Propagation\n * - Semi-join: Sends childConstraint to child, forwards received constraints to parent\n * - Flipped join: Sends undefined to child, merges parentConstraint with received to parent\n * - Unpinned join: Only forwards constraints to parent (doesn't constrain child yet)\n *\n * # Lifecycle\n * 1. Construct with immutable structure (parent, child, constraints, flippability)\n * 2. Wire to output node during graph construction\n * 3. Planning calls flipIfNeeded() based on connection selection order\n * 4. pin() locks the join type once chosen\n * 5. reset() clears mutable state (type → 'semi', pinned → false)\n */\nexport class PlannerJoin {\n  readonly kind = 'join' as const;\n\n  readonly #parent: Exclude<PlannerNode, PlannerTerminus>;\n  readonly #child: Exclude<PlannerNode, PlannerTerminus>;\n  readonly #parentConstraint: PlannerConstraint;\n  readonly #childConstraint: PlannerConstraint;\n  readonly #flippable: boolean;\n  readonly planId: number;\n  #output?: PlannerNode | undefined; // Set once during graph construction\n\n  // Reset between planning attempts\n  #type: 'semi' | 'flipped';\n  readonly #initialType: 'semi' | 'flipped';\n\n  constructor(\n    parent: Exclude<PlannerNode, PlannerTerminus>,\n    child: Exclude<PlannerNode, PlannerTerminus>,\n    parentConstraint: PlannerConstraint,\n    childConstraint: PlannerConstraint,\n    flippable: boolean,\n    planId: number,\n    initialType: 'semi' | 'flipped' = 'semi',\n  ) {\n    this.#type = initialType;\n    this.#initialType = initialType;\n    this.#parent = parent;\n    this.#child = child;\n    this.#childConstraint = childConstraint;\n    this.#parentConstraint = parentConstraint;\n    this.#flippable = flippable;\n    this.planId = planId;\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 'join';\n  }\n\n  flipIfNeeded(input: PlannerNode): void {\n    if (input === this.#child) {\n      this.flip();\n    } else {\n      assert(\n        input === this.#parent,\n        'Can only flip a join from one of its inputs',\n      );\n    }\n  }\n\n  flip(): void {\n    assert(this.#type === 'semi', 'Can only flip a semi-join');\n    if (!this.#flippable) {\n      throw new UnflippableJoinError(\n        'Cannot flip a non-flippable join (e.g., NOT EXISTS)',\n      );\n    }\n    this.#type = 'flipped';\n  }\n\n  get type(): 'semi' | 'flipped' {\n    return this.#type;\n  }\n  isFlippable(): boolean {\n    return this.#flippable;\n  }\n\n  /**\n   * Propagate unlimiting when this join is flipped.\n   * When a join is flipped:\n   * 1. Child becomes outer loop → produces all rows (unlimited)\n   * 2. Parent is fetched once per child row → effectively unlimited\n   *\n   * Example: If child produces 896 rows, parent is fetched 896 times.\n   * Even if each fetch returns 1 row, parent produces 896 total rows.\n   *\n   * Propagation rules:\n   * - Connection: call unlimit()\n   * - Semi-join: continue to parent (outer loop)\n   * - Flipped join: stop (already unlimited when it was flipped)\n   * - Fan-out/Fan-in: propagate to all inputs\n   */\n  propagateUnlimit(): void {\n    assert(this.#type === 'flipped', 'Can only unlimit a flipped join');\n    // Parent stays limited; child becomes unlimited\n    this.#child.propagateUnlimitFromFlippedJoin(); // Up the child chain\n  }\n\n  /**\n   * Called when a parent join is flipped and this join is part of its child subgraph.\n   * Continue propagation to parent (the outer loop).\n   * If we are hitting a semi-join, the parent drives.\n   * If we are hitting a flip-join, well now we have to unlimit its parent too!\n   */\n  propagateUnlimitFromFlippedJoin(): void {\n    this.#parent.propagateUnlimitFromFlippedJoin();\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: 'join',\n      node: this.getName(),\n      branchPattern,\n      constraint,\n      from: from ? getNodeName(from) : 'unknown',\n    });\n\n    if (this.#type === 'semi') {\n      // A semi-join always has constraints for its child.\n      // They are defined by the correlation between parent and child.\n      this.#child.propagateConstraints(\n        branchPattern,\n        this.#childConstraint,\n        this,\n        planDebugger,\n      );\n      // A semi-join forwards constraints to its parent.\n      this.#parent.propagateConstraints(\n        branchPattern,\n        constraint,\n        this,\n        planDebugger,\n      );\n    } else if (this.#type === 'flipped') {\n      // A flipped join translates constraints from parent space to child space.\n      // This matches FlippedJoin.fetch() runtime behavior where parent constraints\n      // on join keys are translated to child constraints.\n      // Example: If parent has {issueID: 5} and join maps issueID→id,\n      // child gets {id: 5} allowing index usage.\n      const translatedConstraint = translateConstraintsForFlippedJoin(\n        constraint,\n        this.#parentConstraint,\n        this.#childConstraint,\n      );\n      this.#child.propagateConstraints(\n        branchPattern,\n        translatedConstraint,\n        this,\n        planDebugger,\n      );\n      // A flipped join will have constraints to send to its parent.\n      // - The constraints its output sent\n      // - The constraints its child creates\n      this.#parent.propagateConstraints(\n        branchPattern,\n        mergeConstraints(constraint, this.#parentConstraint),\n        this,\n        planDebugger,\n      );\n    }\n  }\n\n  reset(): void {\n    this.#type = this.#initialType;\n  }\n\n  estimateCost(\n    /**\n     * This argument is to deal with consecutive `andExists` statements.\n     * Each one will constrain how often a parent row passes all constraints.\n     * This means that we have to scan more and more parent rows the more\n     * constraints we add.\n     *\n     * DownstreamChildSelectivity factors in fanout factor\n     * from parent -> child\n     */\n    downstreamChildSelectivity: number,\n    /**\n     * branchPattern uniquely identifies OR branches in the graph.\n     * Each path through an OR will have unique constraints to apply to the source\n     * connection.\n     * branchPattern allows us to correlate a path through the graph\n     * to the constraints that should be applied for that path.\n     *\n     * Example graph:\n     *  UFO\n     * /  \\\n     * J1   J2\n     * \\  /\n     *  UFI\n     *\n     * J1 and J2 are joins inside an OR (FO).\n     * branchPattern [0] = path through J1\n     * branchPattern [1] = path through J2\n     *\n     * If many ORs are nested, branchPattern will have multiple elements\n     * representing each level of OR.\n     *\n     * If no joins are flipped within the `OR`, then only a single\n     * branchPattern element will be needed, as FO represents all sub-joins\n     * as a single path.\n     */\n    branchPattern: number[],\n    planDebugger?: PlanDebugger,\n  ): CostEstimate {\n    /**\n     * downstreamChildSelectivity accumulates up a parent chain, not\n     * up child chains. Child chains represent independent sub-graphs.\n     * So we pass 1 for `downstreamChildSelectivity` when estimating child cost.\n     * Put another way, downstreamChildSelectivity impacts how many parent\n     * rows are returned.\n     */\n    const child = this.#child.estimateCost(1, branchPattern, planDebugger);\n\n    const fanoutFactor = child.fanout(Object.keys(this.#childConstraint));\n    // Factor in how many child rows match a parent row.\n    // E.g., if an issue has 10 comments on average then we're more\n    // likely to hit a comment compared to if an issue has 1 comment on average.\n    // If an index is all nulls (no parents match any children)\n    // this will collapse to 0.\n    const scaledChildSelectivity =\n      1 - Math.pow(1 - child.selectivity, fanoutFactor.fanout);\n\n    // Why do we not need fanout in the other direction?\n    // E.g., for an `inventory -> film` flipped-join, if each film has 100 inventories (100 copies)\n    // then we're more likely to hit an inventory row compared to if each film has 1 inventory.\n    // Flipped-join already accounts for this because the child selectivity is implicitly accounted\n    // for. The returned row estimate of the child is already representative of how many\n    // rows the child will have post-filtering.\n\n    /**\n     * How selective is the graph from this point forward?\n     * If we are _very_ selective then we must scan more parent rows\n     * before finding a match.\n     * E.g., if childSelectivity = 0.1 and downstreamChildSelectivity = 0.5\n     * then we only pass 5% of parent rows (0.1 * 0.5 = 0.05).\n     *\n     * This is used to estimate how many rows will be pulled from the parent\n     * when trying to satisfy downstream constraints and a limit.\n     *\n     * NOTE: We do not know if the probabilities are correlated so we assume independence.\n     * This is a fundamental limitation of the planner.\n     */\n    const parent = this.#parent.estimateCost(\n      // Selectivity flows up the graph from child to parent\n      // so we can determine the total selectivity of all ANDed exists checks.\n      this.#type === 'flipped'\n        ? 1 * downstreamChildSelectivity\n        : scaledChildSelectivity * downstreamChildSelectivity,\n      branchPattern,\n      planDebugger,\n    );\n\n    let costEstimate: CostEstimate;\n\n    if (this.type === 'semi') {\n      costEstimate = {\n        startupCost: parent.startupCost,\n        scanEst:\n          parent.limit === undefined\n            ? parent.returnedRows\n            : Math.min(\n                parent.returnedRows,\n                downstreamChildSelectivity === 0\n                  ? 0\n                  : parent.limit / downstreamChildSelectivity,\n              ),\n        cost:\n          parent.cost +\n          parent.scanEst * (child.startupCost + child.cost + child.scanEst),\n        returnedRows: parent.returnedRows * child.selectivity,\n        selectivity: child.selectivity * parent.selectivity,\n        limit: parent.limit,\n        fanout: parent.fanout,\n      };\n    } else {\n      costEstimate = {\n        startupCost: child.startupCost,\n        scanEst:\n          parent.limit === undefined\n            ? parent.returnedRows * child.returnedRows\n            : Math.min(\n                parent.returnedRows * child.returnedRows,\n                downstreamChildSelectivity === 0\n                  ? 0\n                  : parent.limit / downstreamChildSelectivity,\n              ),\n        // FlippedJoin batches child→parent lookups into chunks of\n        // getMultiConstraintChunkSize(), issuing one IN-list query per\n        // chunk. So `parent.startupCost` (statement prepare + plan\n        // setup) is paid once per chunk, not once per child row. The\n        // per-seek work (`parent.cost` index walk + `parent.scanEst`\n        // rows) still scales with child row count: each IN value still\n        // does its own index seek.\n        cost:\n          child.cost +\n          Math.ceil(child.scanEst / getMultiConstraintChunkSize()) *\n            parent.startupCost +\n          child.scanEst * (parent.cost + parent.scanEst),\n        // the child selectivity is not relevant here because it has already been taken into account via the flipping.\n        // I.e., `child.returnedRows` is the estimated number of rows produced by the child _after_ taking filtering into account.\n        returnedRows: parent.returnedRows * child.returnedRows,\n        selectivity: parent.selectivity * child.selectivity,\n        limit: parent.limit,\n        fanout: parent.fanout,\n      };\n    }\n\n    if (planDebugger) {\n      planDebugger.log({\n        type: 'node-cost',\n        nodeType: 'join',\n        node: this.getName(),\n        branchPattern,\n        downstreamChildSelectivity,\n        costEstimate: omitFanout(costEstimate),\n        joinType: this.#type,\n      });\n    }\n\n    return costEstimate;\n  }\n\n  /**\n   * Get a human-readable name for this join for debugging.\n   * Format: \"parentName ⋈ childName\"\n   */\n  getName(): string {\n    const parentName = getNodeName(this.#parent);\n    const childName = getNodeName(this.#child);\n    return `${parentName} ⋈ ${childName}`;\n  }\n\n  /**\n   * Get debug information about this join's state.\n   */\n  getDebugInfo(): {\n    name: string;\n    type: 'semi' | 'flipped';\n    planId: number;\n  } {\n    return {\n      name: this.getName(),\n      type: this.#type,\n      planId: this.planId,\n    };\n  }\n}\n\nexport class UnflippableJoinError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'UnflippableJoinError';\n  }\n}\n\n/**\n * Get a human-readable name for any planner node.\n * Used for debugging and tracing.\n */\nfunction getNodeName(node: PlannerNode): string {\n  switch (node.kind) {\n    case 'connection':\n      return node.name;\n    case 'join':\n      return node.getName();\n    case 'fan-out':\n      return 'FO';\n    case 'fan-in':\n      return 'FI';\n    case 'terminus':\n      return 'terminus';\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"planner-join.js","names":["#parent","#child","#parentConstraint","#childConstraint","#flippable","#initialType","#type","#output"],"sources":["../../../../../zql/src/planner/planner-join.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.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';\nimport type {PlannerTerminus} from './planner-terminus.ts';\n\n/**\n * Translate constraints for a flipped join from parent space to child space.\n * Matches the runtime behavior of FlippedJoin.fetch() which translates\n * parent constraints to child constraints using index-based key mapping.\n *\n * Example:\n *   parentConstraint = {issueID: undefined, projectID: undefined}\n *   childConstraint = {id: undefined, projectID: undefined}\n *   incomingConstraint = {issueID: 5}\n *   result = {id: 5}  // issueID at index 0 maps to id at index 0\n */\nfunction translateConstraintsForFlippedJoin(\n  incomingConstraint: PlannerConstraint | undefined,\n  parentConstraint: PlannerConstraint,\n  childConstraint: PlannerConstraint,\n): PlannerConstraint | undefined {\n  if (!incomingConstraint) return undefined;\n\n  const parentKeys = Object.keys(parentConstraint);\n  const childKeys = Object.keys(childConstraint);\n  const translated: PlannerConstraint = {};\n\n  for (const [key, value] of Object.entries(incomingConstraint)) {\n    const index = parentKeys.indexOf(key);\n    if (index !== -1) {\n      // Found this key in parent at position `index`\n      // Map to child key at same position\n      translated[childKeys[index]] = value;\n    }\n  }\n\n  return Object.keys(translated).length > 0 ? translated : undefined;\n}\n\n/**\n * Semi-join overhead multiplier.\n *\n * Semi-joins represent correlated subqueries (EXISTS checks) which have\n * execution overhead compared to flipped joins, even when logical row counts\n * are identical. This overhead comes from:\n * - Need to execute a separate correlation check for each parent row\n * - Cannot leverage combined constraint checking as effectively as flipped joins\n *\n * A multiplier of 1.5 means semi-joins are estimated to be ~50% more expensive\n * than equivalent flipped joins, which empirically matches observed performance\n * differences in production workloads (e.g., 1.7x in zbugs benchmarks).\n *\n * Flipped joins have a different overhead in that they become unlimited. This\n * is accounted for when propagating unlimits rather than here.\n */\n// const SEMI_JOIN_OVERHEAD_MULTIPLIER = 1.5;\n\n/**\n * Represents a join between two data streams (parent and child).\n *\n * # Dual-State Pattern\n * Like all planner nodes, PlannerJoin separates:\n * 1. IMMUTABLE STRUCTURE: Parent/child nodes, constraints, flippability\n * 2. MUTABLE STATE: Join type (semi/flipped), pinned status\n *\n * # Join Flipping\n * A join can be in two states:\n * - 'semi': Parent is outer loop, child is inner (semi-join for EXISTS)\n * - 'flipped': Child is outer loop, parent is inner\n *\n * Flipping is the key optimization: choosing which table scans first.\n * NOT EXISTS joins cannot be flipped (#flippable = false).\n *\n * # Constraint Propagation\n * - Semi-join: Sends childConstraint to child, forwards received constraints to parent\n * - Flipped join: Sends undefined to child, merges parentConstraint with received to parent\n * - Unpinned join: Only forwards constraints to parent (doesn't constrain child yet)\n *\n * # Lifecycle\n * 1. Construct with immutable structure (parent, child, constraints, flippability)\n * 2. Wire to output node during graph construction\n * 3. Planning calls flipIfNeeded() based on connection selection order\n * 4. pin() locks the join type once chosen\n * 5. reset() clears mutable state (type → 'semi', pinned → false)\n */\nexport class PlannerJoin {\n  readonly kind = 'join' as const;\n\n  readonly #parent: Exclude<PlannerNode, PlannerTerminus>;\n  readonly #child: Exclude<PlannerNode, PlannerTerminus>;\n  readonly #parentConstraint: PlannerConstraint;\n  readonly #childConstraint: PlannerConstraint;\n  readonly #flippable: boolean;\n  readonly planId: number;\n  #output?: PlannerNode | undefined; // Set once during graph construction\n\n  // Reset between planning attempts\n  #type: 'semi' | 'flipped';\n  readonly #initialType: 'semi' | 'flipped';\n\n  constructor(\n    parent: Exclude<PlannerNode, PlannerTerminus>,\n    child: Exclude<PlannerNode, PlannerTerminus>,\n    parentConstraint: PlannerConstraint,\n    childConstraint: PlannerConstraint,\n    flippable: boolean,\n    planId: number,\n    initialType: 'semi' | 'flipped' = 'semi',\n  ) {\n    this.#type = initialType;\n    this.#initialType = initialType;\n    this.#parent = parent;\n    this.#child = child;\n    this.#childConstraint = childConstraint;\n    this.#parentConstraint = parentConstraint;\n    this.#flippable = flippable;\n    this.planId = planId;\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 'join';\n  }\n\n  flipIfNeeded(input: PlannerNode): void {\n    if (input === this.#child) {\n      this.flip();\n    } else {\n      assert(\n        input === this.#parent,\n        'Can only flip a join from one of its inputs',\n      );\n    }\n  }\n\n  flip(): void {\n    assert(this.#type === 'semi', 'Can only flip a semi-join');\n    if (!this.#flippable) {\n      throw new UnflippableJoinError(\n        'Cannot flip a non-flippable join (e.g., NOT EXISTS)',\n      );\n    }\n    this.#type = 'flipped';\n  }\n\n  get type(): 'semi' | 'flipped' {\n    return this.#type;\n  }\n  isFlippable(): boolean {\n    return this.#flippable;\n  }\n\n  /**\n   * Propagate unlimiting when this join is flipped.\n   * When a join is flipped:\n   * 1. Child becomes outer loop → produces all rows (unlimited)\n   * 2. Parent is fetched once per child row → effectively unlimited\n   *\n   * Example: If child produces 896 rows, parent is fetched 896 times.\n   * Even if each fetch returns 1 row, parent produces 896 total rows.\n   *\n   * Propagation rules:\n   * - Connection: call unlimit()\n   * - Semi-join: continue to parent (outer loop)\n   * - Flipped join: stop (already unlimited when it was flipped)\n   * - Fan-out/Fan-in: propagate to all inputs\n   */\n  propagateUnlimit(): void {\n    assert(this.#type === 'flipped', 'Can only unlimit a flipped join');\n    // Parent stays limited; child becomes unlimited\n    this.#child.propagateUnlimitFromFlippedJoin(); // Up the child chain\n  }\n\n  /**\n   * Called when a parent join is flipped and this join is part of its child subgraph.\n   * Continue propagation to parent (the outer loop).\n   * If we are hitting a semi-join, the parent drives.\n   * If we are hitting a flip-join, well now we have to unlimit its parent too!\n   */\n  propagateUnlimitFromFlippedJoin(): void {\n    this.#parent.propagateUnlimitFromFlippedJoin();\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: 'join',\n      node: this.getName(),\n      branchPattern,\n      constraint,\n      from: from ? getNodeName(from) : 'unknown',\n    });\n\n    if (this.#type === 'semi') {\n      // A semi-join always has constraints for its child.\n      // They are defined by the correlation between parent and child.\n      this.#child.propagateConstraints(\n        branchPattern,\n        this.#childConstraint,\n        this,\n        planDebugger,\n      );\n      // A semi-join forwards constraints to its parent.\n      this.#parent.propagateConstraints(\n        branchPattern,\n        constraint,\n        this,\n        planDebugger,\n      );\n    } else if (this.#type === 'flipped') {\n      // A flipped join translates constraints from parent space to child space.\n      // This matches FlippedJoin.fetch() runtime behavior where parent constraints\n      // on join keys are translated to child constraints.\n      // Example: If parent has {issueID: 5} and join maps issueID→id,\n      // child gets {id: 5} allowing index usage.\n      const translatedConstraint = translateConstraintsForFlippedJoin(\n        constraint,\n        this.#parentConstraint,\n        this.#childConstraint,\n      );\n      this.#child.propagateConstraints(\n        branchPattern,\n        translatedConstraint,\n        this,\n        planDebugger,\n      );\n      // A flipped join will have constraints to send to its parent.\n      // - The constraints its output sent\n      // - The constraints its child creates\n      this.#parent.propagateConstraints(\n        branchPattern,\n        mergeConstraints(constraint, this.#parentConstraint),\n        this,\n        planDebugger,\n      );\n    }\n  }\n\n  reset(): void {\n    this.#type = this.#initialType;\n  }\n\n  estimateCost(\n    /**\n     * This argument is to deal with consecutive `andExists` statements.\n     * Each one will constrain how often a parent row passes all constraints.\n     * This means that we have to scan more and more parent rows the more\n     * constraints we add.\n     *\n     * DownstreamChildSelectivity factors in fanout factor\n     * from parent -> child\n     */\n    downstreamChildSelectivity: number,\n    /**\n     * branchPattern uniquely identifies OR branches in the graph.\n     * Each path through an OR will have unique constraints to apply to the source\n     * connection.\n     * branchPattern allows us to correlate a path through the graph\n     * to the constraints that should be applied for that path.\n     *\n     * Example graph:\n     *  UFO\n     * /  \\\n     * J1   J2\n     * \\  /\n     *  UFI\n     *\n     * J1 and J2 are joins inside an OR (FO).\n     * branchPattern [0] = path through J1\n     * branchPattern [1] = path through J2\n     *\n     * If many ORs are nested, branchPattern will have multiple elements\n     * representing each level of OR.\n     *\n     * If no joins are flipped within the `OR`, then only a single\n     * branchPattern element will be needed, as FO represents all sub-joins\n     * as a single path.\n     */\n    branchPattern: number[],\n    planDebugger?: PlanDebugger,\n  ): CostEstimate {\n    /**\n     * downstreamChildSelectivity accumulates up a parent chain, not\n     * up child chains. Child chains represent independent sub-graphs.\n     * So we pass 1 for `downstreamChildSelectivity` when estimating child cost.\n     * Put another way, downstreamChildSelectivity impacts how many parent\n     * rows are returned.\n     */\n    const child = this.#child.estimateCost(1, branchPattern, planDebugger);\n\n    const fanoutFactor = child.fanout(Object.keys(this.#childConstraint));\n    // Factor in how many child rows match a parent row.\n    // E.g., if an issue has 10 comments on average then we're more\n    // likely to hit a comment compared to if an issue has 1 comment on average.\n    // If an index is all nulls (no parents match any children)\n    // this will collapse to 0.\n    const scaledChildSelectivity =\n      1 - Math.pow(1 - child.selectivity, fanoutFactor.fanout);\n\n    // Why do we not need fanout in the other direction?\n    // E.g., for an `inventory -> film` flipped-join, if each film has 100 inventories (100 copies)\n    // then we're more likely to hit an inventory row compared to if each film has 1 inventory.\n    // Flipped-join already accounts for this because the child selectivity is implicitly accounted\n    // for. The returned row estimate of the child is already representative of how many\n    // rows the child will have post-filtering.\n\n    /**\n     * How selective is the graph from this point forward?\n     * If we are _very_ selective then we must scan more parent rows\n     * before finding a match.\n     * E.g., if childSelectivity = 0.1 and downstreamChildSelectivity = 0.5\n     * then we only pass 5% of parent rows (0.1 * 0.5 = 0.05).\n     *\n     * This is used to estimate how many rows will be pulled from the parent\n     * when trying to satisfy downstream constraints and a limit.\n     *\n     * NOTE: We do not know if the probabilities are correlated so we assume independence.\n     * This is a fundamental limitation of the planner.\n     */\n    const parent = this.#parent.estimateCost(\n      // Selectivity flows up the graph from child to parent\n      // so we can determine the total selectivity of all ANDed exists checks.\n      this.#type === 'flipped'\n        ? 1 * downstreamChildSelectivity\n        : scaledChildSelectivity * downstreamChildSelectivity,\n      branchPattern,\n      planDebugger,\n    );\n\n    let costEstimate: CostEstimate;\n\n    if (this.type === 'semi') {\n      costEstimate = {\n        startupCost: parent.startupCost,\n        scanEst:\n          parent.limit === undefined\n            ? parent.returnedRows\n            : Math.min(\n                parent.returnedRows,\n                downstreamChildSelectivity === 0\n                  ? 0\n                  : parent.limit / downstreamChildSelectivity,\n              ),\n        cost:\n          parent.cost +\n          parent.scanEst * (child.startupCost + child.cost + child.scanEst),\n        returnedRows: parent.returnedRows * child.selectivity,\n        selectivity: child.selectivity * parent.selectivity,\n        limit: parent.limit,\n        fanout: parent.fanout,\n      };\n    } else {\n      costEstimate = {\n        startupCost: child.startupCost,\n        scanEst:\n          parent.limit === undefined\n            ? parent.returnedRows * child.returnedRows\n            : Math.min(\n                parent.returnedRows * child.returnedRows,\n                downstreamChildSelectivity === 0\n                  ? 0\n                  : parent.limit / downstreamChildSelectivity,\n              ),\n        cost:\n          child.cost +\n          child.scanEst * (parent.startupCost + parent.cost + parent.scanEst),\n        // the child selectivity is not relevant here because it has already been taken into account via the flipping.\n        // I.e., `child.returnedRows` is the estimated number of rows produced by the child _after_ taking filtering into account.\n        returnedRows: parent.returnedRows * child.returnedRows,\n        selectivity: parent.selectivity * child.selectivity,\n        limit: parent.limit,\n        fanout: parent.fanout,\n      };\n    }\n\n    if (planDebugger) {\n      planDebugger.log({\n        type: 'node-cost',\n        nodeType: 'join',\n        node: this.getName(),\n        branchPattern,\n        downstreamChildSelectivity,\n        costEstimate: omitFanout(costEstimate),\n        joinType: this.#type,\n      });\n    }\n\n    return costEstimate;\n  }\n\n  /**\n   * Get a human-readable name for this join for debugging.\n   * Format: \"parentName ⋈ childName\"\n   */\n  getName(): string {\n    const parentName = getNodeName(this.#parent);\n    const childName = getNodeName(this.#child);\n    return `${parentName} ⋈ ${childName}`;\n  }\n\n  /**\n   * Get debug information about this join's state.\n   */\n  getDebugInfo(): {\n    name: string;\n    type: 'semi' | 'flipped';\n    planId: number;\n  } {\n    return {\n      name: this.getName(),\n      type: this.#type,\n      planId: this.planId,\n    };\n  }\n}\n\nexport class UnflippableJoinError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'UnflippableJoinError';\n  }\n}\n\n/**\n * Get a human-readable name for any planner node.\n * Used for debugging and tracing.\n */\nfunction getNodeName(node: PlannerNode): string {\n  switch (node.kind) {\n    case 'connection':\n      return node.name;\n    case 'join':\n      return node.getName();\n    case 'fan-out':\n      return 'FO';\n    case 'fan-in':\n      return 'FI';\n    case 'terminus':\n      return 'terminus';\n  }\n}\n"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"planner-node.js","names":[],"sources":["../../../../../zql/src/planner/planner-node.ts"],"sourcesContent":["import type {FanoutCostModel, PlannerConnection} from './planner-connection.ts';\nimport type {PlannerFanIn} from './planner-fan-in.ts';\nimport type {PlannerFanOut} from './planner-fan-out.ts';\nimport type {PlannerJoin} from './planner-join.ts';\nimport type {PlannerTerminus} from './planner-terminus.ts';\n\n/**\n * Union of all node types that can appear in the planner graph.\n * All nodes follow the dual-state pattern described above.\n */\nexport type PlannerNode =\n  | PlannerJoin\n  | PlannerConnection\n  | PlannerFanOut\n  | PlannerFanIn\n  | PlannerTerminus;\n\nexport type CostEstimate = {\n  startupCost: number;\n  scanEst: number;\n\n  /**\n   * The cumulative cost to run the pipeline so far.\n   *\n   * In a semi-join, each row output by the parent is multiplied by the cost to evaluate the child.\n   * In a flipped join, each row output by the child is multiplied by the cost to evaluate the parent.\n   *\n   * \"each row output by the parent\" is determined by the downstreamChildSelectivity parameter in combination\n   * with the limit or the rows output by the parent node.\n   *\n   * We pull on the parent and stop when hitting a limit or exhausting rows.\n   */\n  cost: number;\n\n  /**\n   * The number of rows output from a node.\n   * - For a connection, this is the estimated number of rows returned by the source query.\n   * - For a semi-join, this is the estimated number of rows that pass the semi-join filter.\n   * - For a flipped join, this is the estimated number of rows that match all child rows.\n   * - For fan-in, this is the sum of the rows from each input.\n   * - For fan-out, this is the rows from its input.\n   */\n  returnedRows: number;\n\n  /**\n   * The selectivity of the node.\n   * For a connection, this is the fraction of rows passing filters (1.0 = no filtering).\n   * For joins, this is the fraction of parent rows that match child rows.\n   * For fan-in, this is the probability of a match in any branch, assuming independent events.\n   * For fan-out, this is the selectivity of its input.\n   */\n  selectivity: number;\n  limit: number | undefined;\n\n  fanout: FanoutCostModel;\n};\n\n/**\n * Omit the fanout function from a cost estimate for serialization.\n */\nexport function omitFanout(cost: CostEstimate): Omit<CostEstimate, 'fanout'> {\n  const {fanout: _, ...rest} = cost;\n  return rest;\n}\n\nexport type NodeType = PlannerNode['kind'];\n\nexport type JoinOrConnection = 'join' | 'connection';\n\nexport type JoinType = PlannerJoin['type'];\n"],"mappings":";;;;AA4DA,SAAgB,WAAW,MAAkD;CAC3E,MAAM,EAAC,QAAQ,GAAG,GAAG,SAAQ;CAC7B,OAAO;AACT"}
+{"version":3,"file":"planner-node.js","names":[],"sources":["../../../../../zql/src/planner/planner-node.ts"],"sourcesContent":["import type {FanoutCostModel, PlannerConnection} from './planner-connection.ts';\nimport type {PlannerFanIn} from './planner-fan-in.ts';\nimport type {PlannerFanOut} from './planner-fan-out.ts';\nimport type {PlannerJoin} from './planner-join.ts';\nimport type {PlannerTerminus} from './planner-terminus.ts';\n\n/**\n * Union of all node types that can appear in the planner graph.\n * All nodes follow the dual-state pattern described above.\n */\nexport type PlannerNode =\n  | PlannerJoin\n  | PlannerConnection\n  | PlannerFanOut\n  | PlannerFanIn\n  | PlannerTerminus;\n\nexport type CostEstimate = {\n  startupCost: number;\n  scanEst: number;\n\n  /**\n   * The cumulative cost to run the pipeline so far.\n   *\n   * In a semi-join, each row output by the parent is multiplied by the cost to evaluate the child.\n   * In a flipped join, each row output by the child is multiplied by the cost to evaluate the parent.\n   *\n   * \"each row output by the parent\" is determined by the downstreamChildSelectivity parameter in combination\n   * with the limit or the rows output by the parent node.\n   *\n   * We pull on the parent and stop when hitting a limit or exhausting rows.\n   */\n  cost: number;\n\n  /**\n   * The number of rows output from a node.\n   * - For a connection, this is the estimated number of rows returned by the source query.\n   * - For a semi-join, this is the estimated number of rows that pass the semi-join filter.\n   * - For a flipped join, this is the estimated number of rows that match all child rows.\n   * - For fan-in, this is the sum of the rows from each input.\n   * - For fan-out, this is the rows from its input.\n   */\n  returnedRows: number;\n\n  /**\n   * The selectivity of the node.\n   * For a connection, this is the fraction of rows passing filters (1.0 = no filtering).\n   * For joins, this is the fraction of parent rows that match child rows.\n   * For fan-in, this is the probability of a match in any branch, assuming independent events.\n   * For fan-out, this is the selectivity of its input.\n   */\n  selectivity: number;\n  limit: number | undefined;\n\n  fanout: FanoutCostModel;\n};\n\n/**\n * Omit the fanout function from a cost estimate for serialization.\n */\nexport function omitFanout(cost: CostEstimate): Omit<CostEstimate, 'fanout'> {\n  const {fanout: _, ...rest} = cost;\n  return rest;\n}\n\nexport type NodeType = PlannerNode['kind'];\n\nexport type JoinOrConnection = 'join' | 'connection';\n\nexport type JoinType = PlannerJoin['type'];\n"],"mappings":";;;;AA4DA,SAAgB,WAAW,MAAkD;CAC3E,MAAM,EAAC,QAAQ,GAAG,GAAG,SAAQ;AAC7B,QAAO"}

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

@@ -1 +1 @@
-{"version":3,"file":"planner-source.js","names":["#model"],"sources":["../../../../../zql/src/planner/planner-source.ts"],"sourcesContent":["import type {Condition, Ordering} from '../../../zero-protocol/src/ast.ts';\nimport {\n  PlannerConnection,\n  type ConnectionCostModel,\n} from './planner-connection.ts';\nimport type {PlannerConstraint} from './planner-constraint.ts';\n\nexport type {ConnectionCostModel};\n\nexport class PlannerSource {\n  readonly name: string;\n  readonly #model: ConnectionCostModel;\n\n  constructor(name: string, model: ConnectionCostModel) {\n    this.name = name;\n    this.#model = model;\n  }\n\n  connect(\n    sort: Ordering,\n    filters: Condition | undefined,\n    isRoot: boolean,\n    baseConstraints?: PlannerConstraint,\n    limit?: number,\n  ): PlannerConnection {\n    return new PlannerConnection(\n      this.name,\n      this.#model,\n      sort,\n      filters,\n      isRoot,\n      baseConstraints,\n      limit,\n    );\n  }\n}\n"],"mappings":";;AASA,IAAa,gBAAb,MAA2B;CACzB;CACA;CAEA,YAAY,MAAc,OAA4B;EACpD,KAAK,OAAO;EACZ,KAAKA,SAAS;CAChB;CAEA,QACE,MACA,SACA,QACA,iBACA,OACmB;EACnB,OAAO,IAAI,kBACT,KAAK,MACL,KAAKA,QACL,MACA,SACA,QACA,iBACA,KACF;CACF;AACF"}
+{"version":3,"file":"planner-source.js","names":["#model"],"sources":["../../../../../zql/src/planner/planner-source.ts"],"sourcesContent":["import type {Condition, Ordering} from '../../../zero-protocol/src/ast.ts';\nimport {\n  PlannerConnection,\n  type ConnectionCostModel,\n} from './planner-connection.ts';\nimport type {PlannerConstraint} from './planner-constraint.ts';\n\nexport type {ConnectionCostModel};\n\nexport class PlannerSource {\n  readonly name: string;\n  readonly #model: ConnectionCostModel;\n\n  constructor(name: string, model: ConnectionCostModel) {\n    this.name = name;\n    this.#model = model;\n  }\n\n  connect(\n    sort: Ordering,\n    filters: Condition | undefined,\n    isRoot: boolean,\n    baseConstraints?: PlannerConstraint,\n    limit?: number,\n  ): PlannerConnection {\n    return new PlannerConnection(\n      this.name,\n      this.#model,\n      sort,\n      filters,\n      isRoot,\n      baseConstraints,\n      limit,\n    );\n  }\n}\n"],"mappings":";;AASA,IAAa,gBAAb,MAA2B;CACzB;CACA;CAEA,YAAY,MAAc,OAA4B;AACpD,OAAK,OAAO;AACZ,QAAA,QAAc;;CAGhB,QACE,MACA,SACA,QACA,iBACA,OACmB;AACnB,SAAO,IAAI,kBACT,KAAK,MACL,MAAA,OACA,MACA,SACA,QACA,iBACA,MACD"}

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

@@ -1 +1 @@
-{"version":3,"file":"planner-terminus.js","names":["#input"],"sources":["../../../../../zql/src/planner/planner-terminus.ts"],"sourcesContent":["import type {PlanDebugger} from './planner-debug.ts';\nimport type {\n  CostEstimate,\n  JoinOrConnection,\n  PlannerNode,\n} from './planner-node.ts';\n\nexport class PlannerTerminus {\n  readonly kind = 'terminus' as const;\n  readonly #input: Exclude<PlannerNode, PlannerTerminus>;\n\n  constructor(input: Exclude<PlannerNode, PlannerTerminus>) {\n    this.#input = input;\n  }\n\n  get pinned(): boolean {\n    return true;\n  }\n\n  closestJoinOrSource(): JoinOrConnection {\n    return this.#input.closestJoinOrSource();\n  }\n\n  propagateConstraints(planDebugger?: PlanDebugger): void {\n    this.#input.propagateConstraints([], undefined, this, planDebugger);\n  }\n\n  estimateCost(planDebugger?: PlanDebugger): CostEstimate {\n    // Terminus starts the cost estimation flow with empty branch pattern\n    return this.#input.estimateCost(1, [], planDebugger);\n  }\n\n  /**\n   * Propagate unlimiting when a parent join is flipped.\n   * Terminus doesn't participate in unlimiting.\n   */\n  propagateUnlimitFromFlippedJoin(): void {\n    // No-op: terminus doesn't need to unlimit anything\n  }\n}\n"],"mappings":";AAOA,IAAa,kBAAb,MAA6B;CAC3B,OAAgB;CAChB;CAEA,YAAY,OAA8C;EACxD,KAAKA,SAAS;CAChB;CAEA,IAAI,SAAkB;EACpB,OAAO;CACT;CAEA,sBAAwC;EACtC,OAAO,KAAKA,OAAO,oBAAoB;CACzC;CAEA,qBAAqB,cAAmC;EACtD,KAAKA,OAAO,qBAAqB,CAAC,GAAG,KAAA,GAAW,MAAM,YAAY;CACpE;CAEA,aAAa,cAA2C;EAEtD,OAAO,KAAKA,OAAO,aAAa,GAAG,CAAC,GAAG,YAAY;CACrD;;;;;CAMA,kCAAwC,CAExC;AACF"}
+{"version":3,"file":"planner-terminus.js","names":["#input"],"sources":["../../../../../zql/src/planner/planner-terminus.ts"],"sourcesContent":["import type {PlanDebugger} from './planner-debug.ts';\nimport type {\n  CostEstimate,\n  JoinOrConnection,\n  PlannerNode,\n} from './planner-node.ts';\n\nexport class PlannerTerminus {\n  readonly kind = 'terminus' as const;\n  readonly #input: Exclude<PlannerNode, PlannerTerminus>;\n\n  constructor(input: Exclude<PlannerNode, PlannerTerminus>) {\n    this.#input = input;\n  }\n\n  get pinned(): boolean {\n    return true;\n  }\n\n  closestJoinOrSource(): JoinOrConnection {\n    return this.#input.closestJoinOrSource();\n  }\n\n  propagateConstraints(planDebugger?: PlanDebugger): void {\n    this.#input.propagateConstraints([], undefined, this, planDebugger);\n  }\n\n  estimateCost(planDebugger?: PlanDebugger): CostEstimate {\n    // Terminus starts the cost estimation flow with empty branch pattern\n    return this.#input.estimateCost(1, [], planDebugger);\n  }\n\n  /**\n   * Propagate unlimiting when a parent join is flipped.\n   * Terminus doesn't participate in unlimiting.\n   */\n  propagateUnlimitFromFlippedJoin(): void {\n    // No-op: terminus doesn't need to unlimit anything\n  }\n}\n"],"mappings":";AAOA,IAAa,kBAAb,MAA6B;CAC3B,OAAgB;CAChB;CAEA,YAAY,OAA8C;AACxD,QAAA,QAAc;;CAGhB,IAAI,SAAkB;AACpB,SAAO;;CAGT,sBAAwC;AACtC,SAAO,MAAA,MAAY,qBAAqB;;CAG1C,qBAAqB,cAAmC;AACtD,QAAA,MAAY,qBAAqB,EAAE,EAAE,KAAA,GAAW,MAAM,aAAa;;CAGrE,aAAa,cAA2C;AAEtD,SAAO,MAAA,MAAY,aAAa,GAAG,EAAE,EAAE,aAAa;;;;;;CAOtD,kCAAwC"}

package/out/zql/src/query/complete-ordering.js.map

@@ -1 +1 @@
-{"version":3,"file":"complete-ordering.js","names":[],"sources":["../../../../../zql/src/query/complete-ordering.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {AST, Condition, Ordering} from '../../../zero-protocol/src/ast.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\n\nexport function completeOrdering(\n  ast: AST,\n  getPrimaryKey: (tableName: string) => PrimaryKey,\n): AST {\n  const primaryKey = must(getPrimaryKey(ast.table));\n  return {\n    ...ast,\n    ...(ast.related\n      ? {\n          related: ast.related?.map(r => ({\n            ...r,\n            subquery: completeOrdering(r.subquery, getPrimaryKey),\n          })),\n        }\n      : undefined),\n    ...(ast.where\n      ? {\n          where: completeOrderingInCondition(ast.where, getPrimaryKey),\n        }\n      : undefined),\n    orderBy: addPrimaryKeys(primaryKey, ast.orderBy),\n  };\n}\n\nexport function assertOrderingIncludesPK(\n  ordering: Ordering,\n  pk: PrimaryKey,\n): void {\n  // oxlint-disable-next-line unicorn/prefer-set-has -- Array is more appropriate here for small collections\n  const orderingFields = ordering.map(([field]) => field);\n  const missingFields = pk.filter(pkField => !orderingFields.includes(pkField));\n\n  assert(\n    missingFields.length === 0,\n    `Ordering must include all primary key fields. Missing: ${missingFields.join(\n      ', ',\n    )}.`,\n  );\n}\n\nfunction completeOrderingInCondition<C extends Condition | undefined>(\n  condition: C,\n  getPrimaryKey: (tableName: string) => PrimaryKey,\n): C {\n  if (!condition) {\n    return condition;\n  }\n  if (condition.type === 'simple') {\n    return condition;\n  }\n  if (condition.type === 'correlatedSubquery') {\n    return {\n      ...condition,\n      related: {\n        ...condition.related,\n        subquery: completeOrdering(condition.related.subquery, getPrimaryKey),\n      },\n    };\n  }\n  condition.type satisfies 'and' | 'or';\n  return {\n    ...condition,\n    conditions: condition.conditions.map(c =>\n      completeOrderingInCondition(c, getPrimaryKey),\n    ),\n  };\n}\n\nfunction addPrimaryKeys(\n  primaryKey: PrimaryKey,\n  orderBy: Ordering | undefined,\n): Ordering {\n  orderBy = orderBy ?? [];\n  const primaryKeysToAdd = new Set(primaryKey);\n\n  for (const [field] of orderBy) {\n    primaryKeysToAdd.delete(field);\n  }\n\n  if (primaryKeysToAdd.size === 0) {\n    return orderBy;\n  }\n\n  return [\n    ...orderBy,\n    ...Array.from(primaryKeysToAdd, key => [key, 'asc'] as [string, 'asc']),\n  ];\n}\n"],"mappings":";;;AAKA,SAAgB,iBACd,KACA,eACK;CACL,MAAM,aAAa,KAAK,cAAc,IAAI,KAAK,CAAC;CAChD,OAAO;EACL,GAAG;EACH,GAAI,IAAI,UACJ,EACE,SAAS,IAAI,SAAS,KAAI,OAAM;GAC9B,GAAG;GACH,UAAU,iBAAiB,EAAE,UAAU,aAAa;EACtD,EAAE,EACJ,IACA,KAAA;EACJ,GAAI,IAAI,QACJ,EACE,OAAO,4BAA4B,IAAI,OAAO,aAAa,EAC7D,IACA,KAAA;EACJ,SAAS,eAAe,YAAY,IAAI,OAAO;CACjD;AACF;AAEA,SAAgB,yBACd,UACA,IACM;CAEN,MAAM,iBAAiB,SAAS,KAAK,CAAC,WAAW,KAAK;CACtD,MAAM,gBAAgB,GAAG,QAAO,YAAW,CAAC,eAAe,SAAS,OAAO,CAAC;CAE5E,OACE,cAAc,WAAW,GACzB,0DAA0D,cAAc,KACtE,IACF,EAAE,EACJ;AACF;AAEA,SAAS,4BACP,WACA,eACG;CACH,IAAI,CAAC,WACH,OAAO;CAET,IAAI,UAAU,SAAS,UACrB,OAAO;CAET,IAAI,UAAU,SAAS,sBACrB,OAAO;EACL,GAAG;EACH,SAAS;GACP,GAAG,UAAU;GACb,UAAU,iBAAiB,UAAU,QAAQ,UAAU,aAAa;EACtE;CACF;CAEF,UAAU;CACV,OAAO;EACL,GAAG;EACH,YAAY,UAAU,WAAW,KAAI,MACnC,4BAA4B,GAAG,aAAa,CAC9C;CACF;AACF;AAEA,SAAS,eACP,YACA,SACU;CACV,UAAU,WAAW,CAAC;CACtB,MAAM,mBAAmB,IAAI,IAAI,UAAU;CAE3C,KAAK,MAAM,CAAC,UAAU,SACpB,iBAAiB,OAAO,KAAK;CAG/B,IAAI,iBAAiB,SAAS,GAC5B,OAAO;CAGT,OAAO,CACL,GAAG,SACH,GAAG,MAAM,KAAK,mBAAkB,QAAO,CAAC,KAAK,KAAK,CAAoB,CACxE;AACF"}
+{"version":3,"file":"complete-ordering.js","names":[],"sources":["../../../../../zql/src/query/complete-ordering.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {AST, Condition, Ordering} from '../../../zero-protocol/src/ast.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\n\nexport function completeOrdering(\n  ast: AST,\n  getPrimaryKey: (tableName: string) => PrimaryKey,\n): AST {\n  const primaryKey = must(getPrimaryKey(ast.table));\n  return {\n    ...ast,\n    ...(ast.related\n      ? {\n          related: ast.related?.map(r => ({\n            ...r,\n            subquery: completeOrdering(r.subquery, getPrimaryKey),\n          })),\n        }\n      : undefined),\n    ...(ast.where\n      ? {\n          where: completeOrderingInCondition(ast.where, getPrimaryKey),\n        }\n      : undefined),\n    orderBy: addPrimaryKeys(primaryKey, ast.orderBy),\n  };\n}\n\nexport function assertOrderingIncludesPK(\n  ordering: Ordering,\n  pk: PrimaryKey,\n): void {\n  // oxlint-disable-next-line unicorn/prefer-set-has -- Array is more appropriate here for small collections\n  const orderingFields = ordering.map(([field]) => field);\n  const missingFields = pk.filter(pkField => !orderingFields.includes(pkField));\n\n  assert(\n    missingFields.length === 0,\n    `Ordering must include all primary key fields. Missing: ${missingFields.join(\n      ', ',\n    )}.`,\n  );\n}\n\nfunction completeOrderingInCondition<C extends Condition | undefined>(\n  condition: C,\n  getPrimaryKey: (tableName: string) => PrimaryKey,\n): C {\n  if (!condition) {\n    return condition;\n  }\n  if (condition.type === 'simple') {\n    return condition;\n  }\n  if (condition.type === 'correlatedSubquery') {\n    return {\n      ...condition,\n      related: {\n        ...condition.related,\n        subquery: completeOrdering(condition.related.subquery, getPrimaryKey),\n      },\n    };\n  }\n  condition.type satisfies 'and' | 'or';\n  return {\n    ...condition,\n    conditions: condition.conditions.map(c =>\n      completeOrderingInCondition(c, getPrimaryKey),\n    ),\n  };\n}\n\nfunction addPrimaryKeys(\n  primaryKey: PrimaryKey,\n  orderBy: Ordering | undefined,\n): Ordering {\n  orderBy = orderBy ?? [];\n  const primaryKeysToAdd = new Set(primaryKey);\n\n  for (const [field] of orderBy) {\n    primaryKeysToAdd.delete(field);\n  }\n\n  if (primaryKeysToAdd.size === 0) {\n    return orderBy;\n  }\n\n  return [\n    ...orderBy,\n    ...Array.from(primaryKeysToAdd, key => [key, 'asc'] as [string, 'asc']),\n  ];\n}\n"],"mappings":";;;AAKA,SAAgB,iBACd,KACA,eACK;CACL,MAAM,aAAa,KAAK,cAAc,IAAI,MAAM,CAAC;AACjD,QAAO;EACL,GAAG;EACH,GAAI,IAAI,UACJ,EACE,SAAS,IAAI,SAAS,KAAI,OAAM;GAC9B,GAAG;GACH,UAAU,iBAAiB,EAAE,UAAU,cAAc;GACtD,EAAE,EACJ,GACD,KAAA;EACJ,GAAI,IAAI,QACJ,EACE,OAAO,4BAA4B,IAAI,OAAO,cAAc,EAC7D,GACD,KAAA;EACJ,SAAS,eAAe,YAAY,IAAI,QAAQ;EACjD;;AAGH,SAAgB,yBACd,UACA,IACM;CAEN,MAAM,iBAAiB,SAAS,KAAK,CAAC,WAAW,MAAM;CACvD,MAAM,gBAAgB,GAAG,QAAO,YAAW,CAAC,eAAe,SAAS,QAAQ,CAAC;AAE7E,QACE,cAAc,WAAW,GACzB,0DAA0D,cAAc,KACtE,KACD,CAAC,GACH;;AAGH,SAAS,4BACP,WACA,eACG;AACH,KAAI,CAAC,UACH,QAAO;AAET,KAAI,UAAU,SAAS,SACrB,QAAO;AAET,KAAI,UAAU,SAAS,qBACrB,QAAO;EACL,GAAG;EACH,SAAS;GACP,GAAG,UAAU;GACb,UAAU,iBAAiB,UAAU,QAAQ,UAAU,cAAc;GACtE;EACF;AAEH,WAAU;AACV,QAAO;EACL,GAAG;EACH,YAAY,UAAU,WAAW,KAAI,MACnC,4BAA4B,GAAG,cAAc,CAC9C;EACF;;AAGH,SAAS,eACP,YACA,SACU;AACV,WAAU,WAAW,EAAE;CACvB,MAAM,mBAAmB,IAAI,IAAI,WAAW;AAE5C,MAAK,MAAM,CAAC,UAAU,QACpB,kBAAiB,OAAO,MAAM;AAGhC,KAAI,iBAAiB,SAAS,EAC5B,QAAO;AAGT,QAAO,CACL,GAAG,SACH,GAAG,MAAM,KAAK,mBAAkB,QAAO,CAAC,KAAK,MAAM,CAAoB,CACxE"}

package/out/zql/src/query/create-builder.js.map

@@ -1 +1 @@
-{"version":3,"file":"create-builder.js","names":[],"sources":["../../../../../zql/src/query/create-builder.ts"],"sourcesContent":["import {recordProxy} from '../../../shared/src/record-proxy.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {QueryDelegate} from './query-delegate.ts';\nimport {newQuery} from './query-impl.ts';\nimport type {Query} from './query.ts';\nimport {newRunnableQuery} from './runnable-query-impl.ts';\nimport type {ConditionalSchemaQuery, SchemaQuery} from './schema-query.ts';\n\n/**\n * Returns a set of query builders for the given schema.\n */\nexport function createBuilder<S extends Schema>(schema: S): SchemaQuery<S> {\n  return createBuilderWithQueryFactory(schema, table =>\n    newQuery(schema, table),\n  );\n}\n\n/** @deprecated Use {@linkcode createBuilder} with `tx.run(zql.table.where(...))` instead. */\nexport function createRunnableBuilder<S extends Schema>(\n  delegate: QueryDelegate,\n  schema: S,\n): ConditionalSchemaQuery<S> {\n  if (!schema.enableLegacyQueries) {\n    return undefined as ConditionalSchemaQuery<S>;\n  }\n\n  return createBuilderWithQueryFactory(schema, table =>\n    newRunnableQuery(delegate, schema, table),\n  ) as ConditionalSchemaQuery<S>;\n}\n\nfunction createBuilderWithQueryFactory<S extends Schema>(\n  schema: S,\n  queryFactory: (table: keyof S['tables'] & string) => Query<string, S>,\n): SchemaQuery<S> {\n  // Create a target with no prototype so accessing unknown properties returns\n  // undefined instead of inherited Object.prototype methods (e.g., toString).\n  // This fixes React 19 dev mode compatibility where accessing $$typeof should\n  // return undefined rather than throwing.\n  const target = Object.assign(Object.create(null), schema.tables) as Record<\n    string,\n    unknown\n  >;\n\n  // No onMissing handler needed - unknown properties return undefined due to\n  // null prototype, which is the desired behavior for normal JS object semantics.\n  return recordProxy(target, (_tableSchema, prop) =>\n    queryFactory(prop),\n  ) as SchemaQuery<S>;\n}\n"],"mappings":";;;;;;;AAWA,SAAgB,cAAgC,QAA2B;CACzE,OAAO,8BAA8B,SAAQ,UAC3C,SAAS,QAAQ,KAAK,CACxB;AACF;;AAGA,SAAgB,sBACd,UACA,QAC2B;CAC3B,IAAI,CAAC,OAAO,qBACV;CAGF,OAAO,8BAA8B,SAAQ,UAC3C,iBAAiB,UAAU,QAAQ,KAAK,CAC1C;AACF;AAEA,SAAS,8BACP,QACA,cACgB;CAYhB,OAAO,YAPQ,OAAO,OAAO,OAAO,OAAO,IAAI,GAAG,OAAO,MAOtC,IAAS,cAAc,SACxC,aAAa,IAAI,CACnB;AACF"}
+{"version":3,"file":"create-builder.js","names":[],"sources":["../../../../../zql/src/query/create-builder.ts"],"sourcesContent":["import {recordProxy} from '../../../shared/src/record-proxy.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {QueryDelegate} from './query-delegate.ts';\nimport {newQuery} from './query-impl.ts';\nimport type {Query} from './query.ts';\nimport {newRunnableQuery} from './runnable-query-impl.ts';\nimport type {ConditionalSchemaQuery, SchemaQuery} from './schema-query.ts';\n\n/**\n * Returns a set of query builders for the given schema.\n */\nexport function createBuilder<S extends Schema>(schema: S): SchemaQuery<S> {\n  return createBuilderWithQueryFactory(schema, table =>\n    newQuery(schema, table),\n  );\n}\n\n/** @deprecated Use {@linkcode createBuilder} with `tx.run(zql.table.where(...))` instead. */\nexport function createRunnableBuilder<S extends Schema>(\n  delegate: QueryDelegate,\n  schema: S,\n): ConditionalSchemaQuery<S> {\n  if (!schema.enableLegacyQueries) {\n    return undefined as ConditionalSchemaQuery<S>;\n  }\n\n  return createBuilderWithQueryFactory(schema, table =>\n    newRunnableQuery(delegate, schema, table),\n  ) as ConditionalSchemaQuery<S>;\n}\n\nfunction createBuilderWithQueryFactory<S extends Schema>(\n  schema: S,\n  queryFactory: (table: keyof S['tables'] & string) => Query<string, S>,\n): SchemaQuery<S> {\n  // Create a target with no prototype so accessing unknown properties returns\n  // undefined instead of inherited Object.prototype methods (e.g., toString).\n  // This fixes React 19 dev mode compatibility where accessing $$typeof should\n  // return undefined rather than throwing.\n  const target = Object.assign(Object.create(null), schema.tables) as Record<\n    string,\n    unknown\n  >;\n\n  // No onMissing handler needed - unknown properties return undefined due to\n  // null prototype, which is the desired behavior for normal JS object semantics.\n  return recordProxy(target, (_tableSchema, prop) =>\n    queryFactory(prop),\n  ) as SchemaQuery<S>;\n}\n"],"mappings":";;;;;;;AAWA,SAAgB,cAAgC,QAA2B;AACzE,QAAO,8BAA8B,SAAQ,UAC3C,SAAS,QAAQ,MAAM,CACxB;;;AAIH,SAAgB,sBACd,UACA,QAC2B;AAC3B,KAAI,CAAC,OAAO,oBACV;AAGF,QAAO,8BAA8B,SAAQ,UAC3C,iBAAiB,UAAU,QAAQ,MAAM,CAC1C;;AAGH,SAAS,8BACP,QACA,cACgB;AAYhB,QAAO,YAPQ,OAAO,OAAO,OAAO,OAAO,KAAK,EAAE,OAAO,OAAO,GAOpC,cAAc,SACxC,aAAa,KAAK,CACnB"}

package/out/zql/src/query/error.js.map

@@ -1 +1 @@
-{"version":3,"file":"error.js","names":[],"sources":["../../../../../zql/src/query/error.ts"],"sourcesContent":["export class QueryParseError extends Error {\n  constructor(opts: ErrorOptions) {\n    super(\n      opts?.cause instanceof Error\n        ? `Failed to parse arguments for query: ${opts.cause.message}`\n        : `Failed to parse arguments for query`,\n      opts,\n    );\n    this.name = 'QueryParseError';\n  }\n}\n"],"mappings":";AAAA,IAAa,kBAAb,cAAqC,MAAM;CACzC,YAAY,MAAoB;EAC9B,MACE,MAAM,iBAAiB,QACnB,wCAAwC,KAAK,MAAM,YACnD,uCACJ,IACF;EACA,KAAK,OAAO;CACd;AACF"}
+{"version":3,"file":"error.js","names":[],"sources":["../../../../../zql/src/query/error.ts"],"sourcesContent":["export class QueryParseError extends Error {\n  constructor(opts: ErrorOptions) {\n    super(\n      opts?.cause instanceof Error\n        ? `Failed to parse arguments for query: ${opts.cause.message}`\n        : `Failed to parse arguments for query`,\n      opts,\n    );\n    this.name = 'QueryParseError';\n  }\n}\n"],"mappings":";AAAA,IAAa,kBAAb,cAAqC,MAAM;CACzC,YAAY,MAAoB;AAC9B,QACE,MAAM,iBAAiB,QACnB,wCAAwC,KAAK,MAAM,YACnD,uCACJ,KACD;AACD,OAAK,OAAO"}

package/out/zql/src/query/escape-like.js.map

@@ -1 +1 @@
-{"version":3,"file":"escape-like.js","names":[],"sources":["../../../../../zql/src/query/escape-like.ts"],"sourcesContent":["export function escapeLike(val: string) {\n  return val.replace(/[%_]/g, '\\\\$&');\n}\n"],"mappings":";AAAA,SAAgB,WAAW,KAAa;CACtC,OAAO,IAAI,QAAQ,SAAS,MAAM;AACpC"}
+{"version":3,"file":"escape-like.js","names":[],"sources":["../../../../../zql/src/query/escape-like.ts"],"sourcesContent":["export function escapeLike(val: string) {\n  return val.replace(/[%_]/g, '\\\\$&');\n}\n"],"mappings":";AAAA,SAAgB,WAAW,KAAa;AACtC,QAAO,IAAI,QAAQ,SAAS,OAAO"}

package/out/zql/src/query/expression.js.map

@@ -1 +1 @@
-{"version":3,"file":"expression.js","names":["#exists"],"sources":["../../../../../zql/src/query/expression.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport {must} from '../../../shared/src/must.ts';\nimport {\n  toStaticParam,\n  type Condition,\n  type LiteralValue,\n  type Parameter,\n  type SimpleOperator,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Schema as ZeroSchema} from '../../../zero-types/src/schema.ts';\nimport type {\n  AvailableRelationships,\n  DestTableName,\n  ExistsOptions,\n  GetFilterType,\n  NoCompoundTypeSelector,\n  PullTableSchema,\n  Query,\n} from './query.ts';\n\nexport type ParameterReference = {\n  [toStaticParam](): Parameter;\n};\n\n/**\n * A factory function that creates a condition. This is used to create\n * complex conditions that can be passed to the `where` method of a query.\n *\n * @example\n *\n * ```ts\n * const condition: ExpressionFactory<User> = ({and, cmp, or}) =>\n *   and(\n *     cmp('name', '=', 'Alice'),\n *     or(cmp('age', '>', 18), cmp('isStudent', '=', true)),\n *   );\n *\n * const query = z.query.user.where(condition);\n * ```\n */\nexport interface ExpressionFactory<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends ZeroSchema,\n> {\n  (eb: ExpressionBuilder<TTable, TSchema>): Condition;\n}\n\nexport class ExpressionBuilder<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends ZeroSchema,\n> {\n  readonly #exists: (\n    relationship: string,\n    cb?: (query: Query<TTable, TSchema>) => Query<TTable, TSchema, any>,\n    options?: ExistsOptions,\n  ) => Condition;\n\n  constructor(\n    exists: (\n      relationship: string,\n      cb?: (query: Query<TTable, TSchema>) => Query<TTable, TSchema, any>,\n      options?: ExistsOptions,\n    ) => Condition,\n  ) {\n    this.#exists = exists;\n    this.exists = this.exists.bind(this);\n  }\n\n  get eb() {\n    return this;\n  }\n\n  cmp<\n    TSelector extends NoCompoundTypeSelector<PullTableSchema<TTable, TSchema>>,\n    TOperator extends SimpleOperator,\n  >(\n    field: TSelector,\n    op: TOperator,\n    value:\n      | GetFilterType<PullTableSchema<TTable, TSchema>, TSelector, TOperator>\n      | ParameterReference\n      | undefined,\n  ): Condition;\n  cmp<\n    TSelector extends NoCompoundTypeSelector<PullTableSchema<TTable, TSchema>>,\n  >(\n    field: TSelector,\n    value:\n      | GetFilterType<PullTableSchema<TTable, TSchema>, TSelector, '='>\n      | ParameterReference\n      | undefined,\n  ): Condition;\n  cmp(\n    field: string,\n    opOrValue: SimpleOperator | ParameterReference | LiteralValue | undefined,\n    value?: ParameterReference | LiteralValue,\n  ): Condition {\n    if (arguments.length === 2) {\n      return cmp(field, opOrValue);\n    }\n    return cmp(field, opOrValue, value);\n  }\n\n  cmpLit(\n    left: ParameterReference | LiteralValue | undefined,\n    op: SimpleOperator,\n    right: ParameterReference | LiteralValue | undefined,\n  ): Condition {\n    return {\n      type: 'simple',\n      left: isParameterReference(left)\n        ? left[toStaticParam]()\n        : {type: 'literal', value: left ?? null},\n      right: isParameterReference(right)\n        ? right[toStaticParam]()\n        : {type: 'literal', value: right ?? null},\n      op,\n    };\n  }\n\n  and = and;\n  or = or;\n  not = not;\n\n  exists = <TRelationship extends AvailableRelationships<TTable, TSchema>>(\n    relationship: TRelationship,\n    cb?: (\n      query: Query<DestTableName<TTable, TSchema, TRelationship>, TSchema>,\n    ) => Query<any, TSchema>,\n    options?: ExistsOptions,\n  ): Condition => this.#exists(relationship, cb, options);\n}\n\nexport function and(...conditions: (Condition | undefined)[]): Condition {\n  const expressions = filterTrue(filterUndefined(conditions));\n\n  if (expressions.length === 1) {\n    return expressions[0];\n  }\n\n  if (expressions.some(isAlwaysFalse)) {\n    return FALSE;\n  }\n\n  return {type: 'and', conditions: expressions};\n}\n\nexport function or(...conditions: (Condition | undefined)[]): Condition {\n  const expressions = filterFalse(filterUndefined(conditions));\n\n  if (expressions.length === 1) {\n    return expressions[0];\n  }\n\n  if (expressions.some(isAlwaysTrue)) {\n    return TRUE;\n  }\n\n  return {type: 'or', conditions: expressions};\n}\n\nexport function not(expression: Condition): Condition {\n  switch (expression.type) {\n    case 'and':\n      return {\n        type: 'or',\n        conditions: expression.conditions.map(not),\n      };\n    case 'or':\n      return {\n        type: 'and',\n        conditions: expression.conditions.map(not),\n      };\n    case 'correlatedSubquery':\n      return {\n        type: 'correlatedSubquery',\n        related: expression.related,\n        op: negateOperator(expression.op),\n        ...(expression.flip !== undefined ? {flip: expression.flip} : {}),\n        ...(expression.scalar !== undefined ? {scalar: expression.scalar} : {}),\n      };\n    case 'simple':\n      return {\n        type: 'simple',\n        op: negateOperator(expression.op),\n        left: expression.left,\n        right: expression.right,\n      };\n  }\n}\n\nexport function cmp(\n  field: string,\n  opOrValue: SimpleOperator | ParameterReference | LiteralValue | undefined,\n  value?: ParameterReference | LiteralValue,\n): Condition {\n  let op: SimpleOperator;\n  let actualValue: ParameterReference | LiteralValue | undefined;\n\n  if (arguments.length === 2) {\n    // 2-arg form: cmp(field, value) - defaults to '=' operator\n    actualValue = opOrValue as ParameterReference | LiteralValue | undefined;\n    op = '=';\n  } else {\n    // 3-arg form: cmp(field, op, value)\n    op = opOrValue as SimpleOperator;\n    actualValue = value;\n  }\n\n  return {\n    type: 'simple',\n    left: {type: 'column', name: field},\n    right: isParameterReference(actualValue)\n      ? actualValue[toStaticParam]()\n      : {type: 'literal', value: actualValue ?? null},\n    op,\n  };\n}\n\nfunction isParameterReference(\n  value: ParameterReference | LiteralValue | null | undefined,\n): value is ParameterReference {\n  return (\n    value !== null &&\n    value !== undefined &&\n    typeof value === 'object' &&\n    (value as any)[toStaticParam]\n  );\n}\n\nexport const TRUE: Condition = {\n  type: 'and',\n  conditions: [],\n};\n\nconst FALSE: Condition = {\n  type: 'or',\n  conditions: [],\n};\n\nfunction isAlwaysTrue(condition: Condition): boolean {\n  return condition.type === 'and' && condition.conditions.length === 0;\n}\n\nfunction isAlwaysFalse(condition: Condition): boolean {\n  return condition.type === 'or' && condition.conditions.length === 0;\n}\n\nexport function simplifyCondition(c: Condition): Condition {\n  if (c.type === 'simple' || c.type === 'correlatedSubquery') {\n    return c;\n  }\n  if (c.conditions.length === 1) {\n    return simplifyCondition(c.conditions[0]);\n  }\n  const conditions = flatten(c.type, c.conditions.map(simplifyCondition));\n  if (c.type === 'and' && conditions.some(isAlwaysFalse)) {\n    return FALSE;\n  }\n  if (c.type === 'or' && conditions.some(isAlwaysTrue)) {\n    return TRUE;\n  }\n  return {\n    type: c.type,\n    conditions,\n  };\n}\n\nexport function flatten(\n  type: 'and' | 'or',\n  conditions: readonly Condition[],\n): Condition[] {\n  const flattened: Condition[] = [];\n  for (const c of conditions) {\n    if (c.type === type) {\n      flattened.push(...c.conditions);\n    } else {\n      flattened.push(c);\n    }\n  }\n\n  return flattened;\n}\n\nconst negateSimpleOperatorMap = {\n  ['=']: '!=',\n  ['!=']: '=',\n  ['<']: '>=',\n  ['>']: '<=',\n  ['>=']: '<',\n  ['<=']: '>',\n  ['IN']: 'NOT IN',\n  ['NOT IN']: 'IN',\n  ['LIKE']: 'NOT LIKE',\n  ['NOT LIKE']: 'LIKE',\n  ['ILIKE']: 'NOT ILIKE',\n  ['NOT ILIKE']: 'ILIKE',\n  ['IS']: 'IS NOT',\n  ['IS NOT']: 'IS',\n} as const;\n\nconst negateOperatorMap = {\n  ...negateSimpleOperatorMap,\n  ['EXISTS']: 'NOT EXISTS',\n  ['NOT EXISTS']: 'EXISTS',\n} as const;\n\nexport function negateOperator<OP extends keyof typeof negateOperatorMap>(\n  op: OP,\n): (typeof negateOperatorMap)[OP] {\n  return must(negateOperatorMap[op]);\n}\n\nfunction filterUndefined<T>(array: (T | undefined)[]): T[] {\n  return array.filter(e => e !== undefined);\n}\n\nfunction filterTrue(conditions: Condition[]): Condition[] {\n  return conditions.filter(c => !isAlwaysTrue(c));\n}\n\nfunction filterFalse(conditions: Condition[]): Condition[] {\n  return conditions.filter(c => !isAlwaysFalse(c));\n}\n"],"mappings":"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"}
+{"version":3,"file":"expression.js","names":["#exists"],"sources":["../../../../../zql/src/query/expression.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport {must} from '../../../shared/src/must.ts';\nimport {\n  toStaticParam,\n  type Condition,\n  type LiteralValue,\n  type Parameter,\n  type SimpleOperator,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Schema as ZeroSchema} from '../../../zero-types/src/schema.ts';\nimport type {\n  AvailableRelationships,\n  DestTableName,\n  ExistsOptions,\n  GetFilterType,\n  NoCompoundTypeSelector,\n  PullTableSchema,\n  Query,\n} from './query.ts';\n\nexport type ParameterReference = {\n  [toStaticParam](): Parameter;\n};\n\n/**\n * A factory function that creates a condition. This is used to create\n * complex conditions that can be passed to the `where` method of a query.\n *\n * @example\n *\n * ```ts\n * const condition: ExpressionFactory<User> = ({and, cmp, or}) =>\n *   and(\n *     cmp('name', '=', 'Alice'),\n *     or(cmp('age', '>', 18), cmp('isStudent', '=', true)),\n *   );\n *\n * const query = z.query.user.where(condition);\n * ```\n */\nexport interface ExpressionFactory<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends ZeroSchema,\n> {\n  (eb: ExpressionBuilder<TTable, TSchema>): Condition;\n}\n\nexport class ExpressionBuilder<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends ZeroSchema,\n> {\n  readonly #exists: (\n    relationship: string,\n    cb?: (query: Query<TTable, TSchema>) => Query<TTable, TSchema, any>,\n    options?: ExistsOptions,\n  ) => Condition;\n\n  constructor(\n    exists: (\n      relationship: string,\n      cb?: (query: Query<TTable, TSchema>) => Query<TTable, TSchema, any>,\n      options?: ExistsOptions,\n    ) => Condition,\n  ) {\n    this.#exists = exists;\n    this.exists = this.exists.bind(this);\n  }\n\n  get eb() {\n    return this;\n  }\n\n  cmp<\n    TSelector extends NoCompoundTypeSelector<PullTableSchema<TTable, TSchema>>,\n    TOperator extends SimpleOperator,\n  >(\n    field: TSelector,\n    op: TOperator,\n    value:\n      | GetFilterType<PullTableSchema<TTable, TSchema>, TSelector, TOperator>\n      | ParameterReference\n      | undefined,\n  ): Condition;\n  cmp<\n    TSelector extends NoCompoundTypeSelector<PullTableSchema<TTable, TSchema>>,\n  >(\n    field: TSelector,\n    value:\n      | GetFilterType<PullTableSchema<TTable, TSchema>, TSelector, '='>\n      | ParameterReference\n      | undefined,\n  ): Condition;\n  cmp(\n    field: string,\n    opOrValue: SimpleOperator | ParameterReference | LiteralValue | undefined,\n    value?: ParameterReference | LiteralValue,\n  ): Condition {\n    if (arguments.length === 2) {\n      return cmp(field, opOrValue);\n    }\n    return cmp(field, opOrValue, value);\n  }\n\n  cmpLit(\n    left: ParameterReference | LiteralValue | undefined,\n    op: SimpleOperator,\n    right: ParameterReference | LiteralValue | undefined,\n  ): Condition {\n    return {\n      type: 'simple',\n      left: isParameterReference(left)\n        ? left[toStaticParam]()\n        : {type: 'literal', value: left ?? null},\n      right: isParameterReference(right)\n        ? right[toStaticParam]()\n        : {type: 'literal', value: right ?? null},\n      op,\n    };\n  }\n\n  and = and;\n  or = or;\n  not = not;\n\n  exists = <TRelationship extends AvailableRelationships<TTable, TSchema>>(\n    relationship: TRelationship,\n    cb?: (\n      query: Query<DestTableName<TTable, TSchema, TRelationship>, TSchema>,\n    ) => Query<any, TSchema>,\n    options?: ExistsOptions,\n  ): Condition => this.#exists(relationship, cb, options);\n}\n\nexport function and(...conditions: (Condition | undefined)[]): Condition {\n  const expressions = filterTrue(filterUndefined(conditions));\n\n  if (expressions.length === 1) {\n    return expressions[0];\n  }\n\n  if (expressions.some(isAlwaysFalse)) {\n    return FALSE;\n  }\n\n  return {type: 'and', conditions: expressions};\n}\n\nexport function or(...conditions: (Condition | undefined)[]): Condition {\n  const expressions = filterFalse(filterUndefined(conditions));\n\n  if (expressions.length === 1) {\n    return expressions[0];\n  }\n\n  if (expressions.some(isAlwaysTrue)) {\n    return TRUE;\n  }\n\n  return {type: 'or', conditions: expressions};\n}\n\nexport function not(expression: Condition): Condition {\n  switch (expression.type) {\n    case 'and':\n      return {\n        type: 'or',\n        conditions: expression.conditions.map(not),\n      };\n    case 'or':\n      return {\n        type: 'and',\n        conditions: expression.conditions.map(not),\n      };\n    case 'correlatedSubquery':\n      return {\n        type: 'correlatedSubquery',\n        related: expression.related,\n        op: negateOperator(expression.op),\n        ...(expression.flip !== undefined ? {flip: expression.flip} : {}),\n        ...(expression.scalar !== undefined ? {scalar: expression.scalar} : {}),\n      };\n    case 'simple':\n      return {\n        type: 'simple',\n        op: negateOperator(expression.op),\n        left: expression.left,\n        right: expression.right,\n      };\n  }\n}\n\nexport function cmp(\n  field: string,\n  opOrValue: SimpleOperator | ParameterReference | LiteralValue | undefined,\n  value?: ParameterReference | LiteralValue,\n): Condition {\n  let op: SimpleOperator;\n  let actualValue: ParameterReference | LiteralValue | undefined;\n\n  if (arguments.length === 2) {\n    // 2-arg form: cmp(field, value) - defaults to '=' operator\n    actualValue = opOrValue as ParameterReference | LiteralValue | undefined;\n    op = '=';\n  } else {\n    // 3-arg form: cmp(field, op, value)\n    op = opOrValue as SimpleOperator;\n    actualValue = value;\n  }\n\n  return {\n    type: 'simple',\n    left: {type: 'column', name: field},\n    right: isParameterReference(actualValue)\n      ? actualValue[toStaticParam]()\n      : {type: 'literal', value: actualValue ?? null},\n    op,\n  };\n}\n\nfunction isParameterReference(\n  value: ParameterReference | LiteralValue | null | undefined,\n): value is ParameterReference {\n  return (\n    value !== null &&\n    value !== undefined &&\n    typeof value === 'object' &&\n    (value as any)[toStaticParam]\n  );\n}\n\nexport const TRUE: Condition = {\n  type: 'and',\n  conditions: [],\n};\n\nconst FALSE: Condition = {\n  type: 'or',\n  conditions: [],\n};\n\nfunction isAlwaysTrue(condition: Condition): boolean {\n  return condition.type === 'and' && condition.conditions.length === 0;\n}\n\nfunction isAlwaysFalse(condition: Condition): boolean {\n  return condition.type === 'or' && condition.conditions.length === 0;\n}\n\nexport function simplifyCondition(c: Condition): Condition {\n  if (c.type === 'simple' || c.type === 'correlatedSubquery') {\n    return c;\n  }\n  if (c.conditions.length === 1) {\n    return simplifyCondition(c.conditions[0]);\n  }\n  const conditions = flatten(c.type, c.conditions.map(simplifyCondition));\n  if (c.type === 'and' && conditions.some(isAlwaysFalse)) {\n    return FALSE;\n  }\n  if (c.type === 'or' && conditions.some(isAlwaysTrue)) {\n    return TRUE;\n  }\n  return {\n    type: c.type,\n    conditions,\n  };\n}\n\nexport function flatten(\n  type: 'and' | 'or',\n  conditions: readonly Condition[],\n): Condition[] {\n  const flattened: Condition[] = [];\n  for (const c of conditions) {\n    if (c.type === type) {\n      flattened.push(...c.conditions);\n    } else {\n      flattened.push(c);\n    }\n  }\n\n  return flattened;\n}\n\nconst negateSimpleOperatorMap = {\n  ['=']: '!=',\n  ['!=']: '=',\n  ['<']: '>=',\n  ['>']: '<=',\n  ['>=']: '<',\n  ['<=']: '>',\n  ['IN']: 'NOT IN',\n  ['NOT IN']: 'IN',\n  ['LIKE']: 'NOT LIKE',\n  ['NOT LIKE']: 'LIKE',\n  ['ILIKE']: 'NOT ILIKE',\n  ['NOT ILIKE']: 'ILIKE',\n  ['IS']: 'IS NOT',\n  ['IS NOT']: 'IS',\n} as const;\n\nconst negateOperatorMap = {\n  ...negateSimpleOperatorMap,\n  ['EXISTS']: 'NOT EXISTS',\n  ['NOT EXISTS']: 'EXISTS',\n} as const;\n\nexport function negateOperator<OP extends keyof typeof negateOperatorMap>(\n  op: OP,\n): (typeof negateOperatorMap)[OP] {\n  return must(negateOperatorMap[op]);\n}\n\nfunction filterUndefined<T>(array: (T | undefined)[]): T[] {\n  return array.filter(e => e !== undefined);\n}\n\nfunction filterTrue(conditions: Condition[]): Condition[] {\n  return conditions.filter(c => !isAlwaysTrue(c));\n}\n\nfunction filterFalse(conditions: Condition[]): Condition[] {\n  return conditions.filter(c => !isAlwaysFalse(c));\n}\n"],"mappings":"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"}

package/out/zql/src/query/measure-push-operator.js.map

@@ -1 +1 @@
-{"version":3,"file":"measure-push-operator.js","names":["#input","#queryID","#metricsDelegate","#metricName","#output"],"sources":["../../../../../zql/src/query/measure-push-operator.ts"],"sourcesContent":["import type {Change} from '../ivm/change.ts';\nimport type {Node} from '../ivm/data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Operator,\n  type Output,\n} from '../ivm/operator.ts';\nimport type {SourceSchema} from '../ivm/schema.ts';\nimport type {Stream} from '../ivm/stream.ts';\nimport type {MetricsDelegate} from './metrics-delegate.ts';\n\ntype MetricName = 'query-update-client' | 'query-update-server';\n\nexport class MeasurePushOperator implements Operator {\n  readonly #input: Input;\n  readonly #queryID: string;\n  readonly #metricsDelegate: MetricsDelegate;\n\n  #output: Output = throwOutput;\n  readonly #metricName: MetricName;\n\n  constructor(\n    input: Input,\n    queryID: string,\n    metricsDelegate: MetricsDelegate,\n    metricName: MetricName,\n  ) {\n    this.#input = input;\n    this.#queryID = queryID;\n    this.#metricsDelegate = metricsDelegate;\n    this.#metricName = metricName;\n    input.setOutput(this);\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    return this.#input.fetch(req);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    const startTime = performance.now();\n    yield* this.#output.push(change, this);\n    this.#metricsDelegate.addMetric(\n      this.#metricName,\n      performance.now() - startTime,\n      this.#queryID,\n    );\n  }\n}\n"],"mappings":";;AAeA,IAAa,sBAAb,MAAqD;CACnD;CACA;CACA;CAEA,UAAkB;CAClB;CAEA,YACE,OACA,SACA,iBACA,YACA;EACA,KAAKA,SAAS;EACd,KAAKC,WAAW;EAChB,KAAKC,mBAAmB;EACxB,KAAKC,cAAc;EACnB,MAAM,UAAU,IAAI;CACtB;CAEA,UAAU,QAAsB;EAC9B,KAAKC,UAAU;CACjB;CAEA,MAAM,KAA2C;EAC/C,OAAO,KAAKJ,OAAO,MAAM,GAAG;CAC9B;CAEA,YAA0B;EACxB,OAAO,KAAKA,OAAO,UAAU;CAC/B;CAEA,UAAgB;EACd,KAAKA,OAAO,QAAQ;CACtB;CAEA,CAAC,KAAK,QAAiC;EACrC,MAAM,YAAY,YAAY,IAAI;EAClC,OAAO,KAAKI,QAAQ,KAAK,QAAQ,IAAI;EACrC,KAAKF,iBAAiB,UACpB,KAAKC,aACL,YAAY,IAAI,IAAI,WACpB,KAAKF,QACP;CACF;AACF"}
+{"version":3,"file":"measure-push-operator.js","names":["#input","#queryID","#metricsDelegate","#metricName","#output"],"sources":["../../../../../zql/src/query/measure-push-operator.ts"],"sourcesContent":["import type {Change} from '../ivm/change.ts';\nimport type {Node} from '../ivm/data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Operator,\n  type Output,\n} from '../ivm/operator.ts';\nimport type {SourceSchema} from '../ivm/schema.ts';\nimport type {Stream} from '../ivm/stream.ts';\nimport type {MetricsDelegate} from './metrics-delegate.ts';\n\ntype MetricName = 'query-update-client' | 'query-update-server';\n\nexport class MeasurePushOperator implements Operator {\n  readonly #input: Input;\n  readonly #queryID: string;\n  readonly #metricsDelegate: MetricsDelegate;\n\n  #output: Output = throwOutput;\n  readonly #metricName: MetricName;\n\n  constructor(\n    input: Input,\n    queryID: string,\n    metricsDelegate: MetricsDelegate,\n    metricName: MetricName,\n  ) {\n    this.#input = input;\n    this.#queryID = queryID;\n    this.#metricsDelegate = metricsDelegate;\n    this.#metricName = metricName;\n    input.setOutput(this);\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    return this.#input.fetch(req);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    const startTime = performance.now();\n    yield* this.#output.push(change, this);\n    this.#metricsDelegate.addMetric(\n      this.#metricName,\n      performance.now() - startTime,\n      this.#queryID,\n    );\n  }\n}\n"],"mappings":";;AAeA,IAAa,sBAAb,MAAqD;CACnD;CACA;CACA;CAEA,UAAkB;CAClB;CAEA,YACE,OACA,SACA,iBACA,YACA;AACA,QAAA,QAAc;AACd,QAAA,UAAgB;AAChB,QAAA,kBAAwB;AACxB,QAAA,aAAmB;AACnB,QAAM,UAAU,KAAK;;CAGvB,UAAU,QAAsB;AAC9B,QAAA,SAAe;;CAGjB,MAAM,KAA2C;AAC/C,SAAO,MAAA,MAAY,MAAM,IAAI;;CAG/B,YAA0B;AACxB,SAAO,MAAA,MAAY,WAAW;;CAGhC,UAAgB;AACd,QAAA,MAAY,SAAS;;CAGvB,CAAC,KAAK,QAAiC;EACrC,MAAM,YAAY,YAAY,KAAK;AACnC,SAAO,MAAA,OAAa,KAAK,QAAQ,KAAK;AACtC,QAAA,gBAAsB,UACpB,MAAA,YACA,YAAY,KAAK,GAAG,WACpB,MAAA,QACD"}

package/out/zql/src/query/metrics-delegate.js.map

@@ -1 +1 @@
-{"version":3,"file":"metrics-delegate.js","names":[],"sources":["../../../../../zql/src/query/metrics-delegate.ts"],"sourcesContent":["import type {AST} from '../../../zero-protocol/src/ast.ts';\n\nexport type ClientMetricMap = {\n  'query-materialization-client': [queryID: string];\n  'query-materialization-end-to-end': [queryID: string, ast: AST];\n  'query-update-client': [queryID: string];\n};\n\nexport type ServerMetricMap = {\n  'query-materialization-server': [queryID: string];\n  'query-update-server': [queryID: string];\n};\n\nexport type MetricMap = ClientMetricMap & ServerMetricMap;\n\nexport interface MetricsDelegate {\n  addMetric<K extends keyof MetricMap>(\n    metric: K,\n    value: number,\n    ...args: MetricMap[K]\n  ): void;\n}\n\nexport function isClientMetric(\n  metric: keyof MetricMap,\n): metric is keyof ClientMetricMap {\n  return metric.endsWith('-client') || metric.endsWith('-end-to-end');\n}\n\nexport function isServerMetric(\n  metric: keyof MetricMap,\n): metric is keyof ServerMetricMap {\n  return metric.endsWith('-server');\n}\n"],"mappings":";AAuBA,SAAgB,eACd,QACiC;CACjC,OAAO,OAAO,SAAS,SAAS,KAAK,OAAO,SAAS,aAAa;AACpE;AAEA,SAAgB,eACd,QACiC;CACjC,OAAO,OAAO,SAAS,SAAS;AAClC"}
+{"version":3,"file":"metrics-delegate.js","names":[],"sources":["../../../../../zql/src/query/metrics-delegate.ts"],"sourcesContent":["import type {AST} from '../../../zero-protocol/src/ast.ts';\n\nexport type ClientMetricMap = {\n  'query-materialization-client': [queryID: string];\n  'query-materialization-end-to-end': [queryID: string, ast: AST];\n  'query-update-client': [queryID: string];\n};\n\nexport type ServerMetricMap = {\n  'query-materialization-server': [queryID: string];\n  'query-update-server': [queryID: string];\n};\n\nexport type MetricMap = ClientMetricMap & ServerMetricMap;\n\nexport interface MetricsDelegate {\n  addMetric<K extends keyof MetricMap>(\n    metric: K,\n    value: number,\n    ...args: MetricMap[K]\n  ): void;\n}\n\nexport function isClientMetric(\n  metric: keyof MetricMap,\n): metric is keyof ClientMetricMap {\n  return metric.endsWith('-client') || metric.endsWith('-end-to-end');\n}\n\nexport function isServerMetric(\n  metric: keyof MetricMap,\n): metric is keyof ServerMetricMap {\n  return metric.endsWith('-server');\n}\n"],"mappings":";AAuBA,SAAgB,eACd,QACiC;AACjC,QAAO,OAAO,SAAS,UAAU,IAAI,OAAO,SAAS,cAAc;;AAGrE,SAAgB,eACd,QACiC;AACjC,QAAO,OAAO,SAAS,UAAU"}

package/out/zql/src/query/named.js.map

@@ -1 +1 @@
-{"version":3,"file":"named.js","names":[],"sources":["../../../../../zql/src/query/named.ts"],"sourcesContent":["import type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {QueryParseError} from './error.ts';\nimport {asQueryInternals} from './query-internals.ts';\nimport {type AnyQuery} from './query.ts';\n\n/** @deprecated */\nexport type QueryFn<\n  TContext,\n  TTakesContext extends boolean,\n  TArg extends ReadonlyJSONValue[],\n  TReturnQuery extends AnyQuery,\n> = TTakesContext extends false\n  ? {(...args: TArg): TReturnQuery}\n  : {(context: TContext, ...args: TArg): TReturnQuery};\n\n/** @deprecated */\nexport type SyncedQuery<\n  TName extends string,\n  TContext,\n  TTakesContext extends boolean,\n  TArg extends ReadonlyJSONValue[],\n  TReturnQuery extends AnyQuery,\n> = QueryFn<TContext, TTakesContext, TArg, TReturnQuery> & {\n  queryName: TName;\n  parse: ParseFn<TArg> | undefined;\n  takesContext: TTakesContext;\n};\n\nfunction normalizeParser<T extends ReadonlyJSONValue[]>(\n  parser: ParseFn<T> | HasParseFn<T> | undefined,\n): ParseFn<T> | undefined {\n  if (parser) {\n    if ('parse' in parser) {\n      return parser.parse.bind(parser);\n    }\n    return parser;\n  }\n  return undefined;\n}\n\n/**\n * @deprecated Use {@linkcode defineQuery} instead.\n */\nexport function syncedQuery<\n  TName extends string,\n  TArg extends ReadonlyJSONValue[],\n  TReturnQuery extends AnyQuery,\n>(\n  name: TName,\n  parser: ParseFn<TArg> | HasParseFn<TArg> | undefined,\n  fn: QueryFn<unknown, false, TArg, TReturnQuery>,\n): SyncedQuery<TName, unknown, false, TArg, TReturnQuery> {\n  const impl = syncedQueryImpl(name, fn, false);\n  // oxlint-disable-next-line no-explicit-any\n  const ret: any = (...args: TArg) => impl(undefined, args);\n  ret.queryName = name;\n  ret.parse = normalizeParser(parser);\n  ret.takesContext = false;\n  return ret;\n}\n\n/**\n * @deprecated Use {@linkcode defineQuery} instead.\n */\nexport function syncedQueryWithContext<\n  TName extends string,\n  TContext,\n  TArg extends ReadonlyJSONValue[],\n  TReturnQuery extends AnyQuery,\n>(\n  name: TName,\n  parser: ParseFn<TArg> | HasParseFn<TArg> | undefined,\n  fn: QueryFn<TContext, true, TArg, TReturnQuery>,\n): SyncedQuery<TName, TContext, true, TArg, TReturnQuery> {\n  const impl = syncedQueryImpl(name, fn, true);\n  // oxlint-disable-next-line no-explicit-any\n  const ret: any = (context: TContext, ...args: TArg) => impl(context, args);\n  ret.queryName = name;\n  ret.parse = normalizeParser(parser);\n  ret.takesContext = true;\n  return ret;\n}\n\n/** @deprecated */\nfunction syncedQueryImpl<\n  TName extends string,\n  TContext,\n  TArg extends ReadonlyJSONValue[],\n  // oxlint-disable-next-line no-explicit-any\n>(name: TName, fn: any, takesContext: boolean) {\n  return (context: TContext, args: TArg) => {\n    const q = takesContext ? fn(context, ...args) : fn(...args);\n    return asQueryInternals(q).nameAndArgs(name, args);\n  };\n}\n\n/** @deprecated */\n\n// oxlint-disable-next-line no-explicit-any\ntype AnySyncedQuery = SyncedQuery<any, any, any, any, any>;\n\n/** @deprecated */\nexport function withValidation<F extends AnySyncedQuery>(\n  fn: F,\n  // oxlint-disable-next-line no-explicit-any\n): F extends SyncedQuery<infer N, infer C, any, any, infer R>\n  ? SyncedQuery<N, C, true, ReadonlyJSONValue[], R>\n  : F {\n  // If we have a parse function this is a SyncedQuery\n  if ('parse' in fn) {\n    const {parse} = fn;\n    if (!parse) {\n      throw new Error('ret does not have a parse function defined');\n    }\n    // oxlint-disable-next-line no-explicit-any\n    const ret: any = (context: unknown, ...args: unknown[]) => {\n      let parsed;\n      try {\n        parsed = parse(args);\n      } catch (error) {\n        throw new QueryParseError({cause: error});\n      }\n      // oxlint-disable-next-line no-explicit-any\n      return fn.takesContext ? fn(context, ...parsed) : (fn as any)(...parsed);\n    };\n    ret.queryName = fn.queryName;\n    ret.parse = fn.parse;\n    ret.takesContext = true;\n\n    return ret;\n  }\n\n  // If we don't have a parse function, return the function as-is\n  // (this shouldn't happen in practice)\n  // oxlint-disable-next-line no-explicit-any\n  return fn as any;\n}\n\n/** @deprecated */\nexport type ParseFn<T extends ReadonlyJSONValue[]> = (args: unknown[]) => T;\n\n/** @deprecated */\nexport type HasParseFn<T extends ReadonlyJSONValue[]> = {\n  parse: ParseFn<T>;\n};\n\n/** @deprecated */\nexport type Parser<T extends ReadonlyJSONValue[]> = ParseFn<T> | HasParseFn<T>;\n\nexport type CustomQueryID = {\n  name: string;\n  args: ReadonlyArray<ReadonlyJSONValue>;\n};\n"],"mappings":";;;;AA4BA,SAAS,gBACP,QACwB;CACxB,IAAI,QAAQ;EACV,IAAI,WAAW,QACb,OAAO,OAAO,MAAM,KAAK,MAAM;EAEjC,OAAO;CACT;AAEF;;;;AAKA,SAAgB,YAKd,MACA,QACA,IACwD;CACxD,MAAM,OAAO,gBAAgB,MAAM,IAAI,KAAK;CAE5C,MAAM,OAAY,GAAG,SAAe,KAAK,KAAA,GAAW,IAAI;CACxD,IAAI,YAAY;CAChB,IAAI,QAAQ,gBAAgB,MAAM;CAClC,IAAI,eAAe;CACnB,OAAO;AACT;;;;AAKA,SAAgB,uBAMd,MACA,QACA,IACwD;CACxD,MAAM,OAAO,gBAAgB,MAAM,IAAI,IAAI;CAE3C,MAAM,OAAY,SAAmB,GAAG,SAAe,KAAK,SAAS,IAAI;CACzE,IAAI,YAAY;CAChB,IAAI,QAAQ,gBAAgB,MAAM;CAClC,IAAI,eAAe;CACnB,OAAO;AACT;;AAGA,SAAS,gBAKP,MAAa,IAAS,cAAuB;CAC7C,QAAQ,SAAmB,SAAe;EAExC,OAAO,iBADG,eAAe,GAAG,SAAS,GAAG,IAAI,IAAI,GAAG,GAAG,IAAI,CACjC,EAAE,YAAY,MAAM,IAAI;CACnD;AACF;;AAQA,SAAgB,eACd,IAII;CAEJ,IAAI,WAAW,IAAI;EACjB,MAAM,EAAC,UAAS;EAChB,IAAI,CAAC,OACH,MAAM,IAAI,MAAM,4CAA4C;EAG9D,MAAM,OAAY,SAAkB,GAAG,SAAoB;GACzD,IAAI;GACJ,IAAI;IACF,SAAS,MAAM,IAAI;GACrB,SAAS,OAAO;IACd,MAAM,IAAI,gBAAgB,EAAC,OAAO,MAAK,CAAC;GAC1C;GAEA,OAAO,GAAG,eAAe,GAAG,SAAS,GAAG,MAAM,IAAK,GAAW,GAAG,MAAM;EACzE;EACA,IAAI,YAAY,GAAG;EACnB,IAAI,QAAQ,GAAG;EACf,IAAI,eAAe;EAEnB,OAAO;CACT;CAKA,OAAO;AACT"}
+{"version":3,"file":"named.js","names":[],"sources":["../../../../../zql/src/query/named.ts"],"sourcesContent":["import type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {QueryParseError} from './error.ts';\nimport {asQueryInternals} from './query-internals.ts';\nimport {type AnyQuery} from './query.ts';\n\n/** @deprecated */\nexport type QueryFn<\n  TContext,\n  TTakesContext extends boolean,\n  TArg extends ReadonlyJSONValue[],\n  TReturnQuery extends AnyQuery,\n> = TTakesContext extends false\n  ? {(...args: TArg): TReturnQuery}\n  : {(context: TContext, ...args: TArg): TReturnQuery};\n\n/** @deprecated */\nexport type SyncedQuery<\n  TName extends string,\n  TContext,\n  TTakesContext extends boolean,\n  TArg extends ReadonlyJSONValue[],\n  TReturnQuery extends AnyQuery,\n> = QueryFn<TContext, TTakesContext, TArg, TReturnQuery> & {\n  queryName: TName;\n  parse: ParseFn<TArg> | undefined;\n  takesContext: TTakesContext;\n};\n\nfunction normalizeParser<T extends ReadonlyJSONValue[]>(\n  parser: ParseFn<T> | HasParseFn<T> | undefined,\n): ParseFn<T> | undefined {\n  if (parser) {\n    if ('parse' in parser) {\n      return parser.parse.bind(parser);\n    }\n    return parser;\n  }\n  return undefined;\n}\n\n/**\n * @deprecated Use {@linkcode defineQuery} instead.\n */\nexport function syncedQuery<\n  TName extends string,\n  TArg extends ReadonlyJSONValue[],\n  TReturnQuery extends AnyQuery,\n>(\n  name: TName,\n  parser: ParseFn<TArg> | HasParseFn<TArg> | undefined,\n  fn: QueryFn<unknown, false, TArg, TReturnQuery>,\n): SyncedQuery<TName, unknown, false, TArg, TReturnQuery> {\n  const impl = syncedQueryImpl(name, fn, false);\n  // oxlint-disable-next-line no-explicit-any\n  const ret: any = (...args: TArg) => impl(undefined, args);\n  ret.queryName = name;\n  ret.parse = normalizeParser(parser);\n  ret.takesContext = false;\n  return ret;\n}\n\n/**\n * @deprecated Use {@linkcode defineQuery} instead.\n */\nexport function syncedQueryWithContext<\n  TName extends string,\n  TContext,\n  TArg extends ReadonlyJSONValue[],\n  TReturnQuery extends AnyQuery,\n>(\n  name: TName,\n  parser: ParseFn<TArg> | HasParseFn<TArg> | undefined,\n  fn: QueryFn<TContext, true, TArg, TReturnQuery>,\n): SyncedQuery<TName, TContext, true, TArg, TReturnQuery> {\n  const impl = syncedQueryImpl(name, fn, true);\n  // oxlint-disable-next-line no-explicit-any\n  const ret: any = (context: TContext, ...args: TArg) => impl(context, args);\n  ret.queryName = name;\n  ret.parse = normalizeParser(parser);\n  ret.takesContext = true;\n  return ret;\n}\n\n/** @deprecated */\nfunction syncedQueryImpl<\n  TName extends string,\n  TContext,\n  TArg extends ReadonlyJSONValue[],\n  // oxlint-disable-next-line no-explicit-any\n>(name: TName, fn: any, takesContext: boolean) {\n  return (context: TContext, args: TArg) => {\n    const q = takesContext ? fn(context, ...args) : fn(...args);\n    return asQueryInternals(q).nameAndArgs(name, args);\n  };\n}\n\n/** @deprecated */\n\n// oxlint-disable-next-line no-explicit-any\ntype AnySyncedQuery = SyncedQuery<any, any, any, any, any>;\n\n/** @deprecated */\nexport function withValidation<F extends AnySyncedQuery>(\n  fn: F,\n  // oxlint-disable-next-line no-explicit-any\n): F extends SyncedQuery<infer N, infer C, any, any, infer R>\n  ? SyncedQuery<N, C, true, ReadonlyJSONValue[], R>\n  : F {\n  // If we have a parse function this is a SyncedQuery\n  if ('parse' in fn) {\n    const {parse} = fn;\n    if (!parse) {\n      throw new Error('ret does not have a parse function defined');\n    }\n    // oxlint-disable-next-line no-explicit-any\n    const ret: any = (context: unknown, ...args: unknown[]) => {\n      let parsed;\n      try {\n        parsed = parse(args);\n      } catch (error) {\n        throw new QueryParseError({cause: error});\n      }\n      // oxlint-disable-next-line no-explicit-any\n      return fn.takesContext ? fn(context, ...parsed) : (fn as any)(...parsed);\n    };\n    ret.queryName = fn.queryName;\n    ret.parse = fn.parse;\n    ret.takesContext = true;\n\n    return ret;\n  }\n\n  // If we don't have a parse function, return the function as-is\n  // (this shouldn't happen in practice)\n  // oxlint-disable-next-line no-explicit-any\n  return fn as any;\n}\n\n/** @deprecated */\nexport type ParseFn<T extends ReadonlyJSONValue[]> = (args: unknown[]) => T;\n\n/** @deprecated */\nexport type HasParseFn<T extends ReadonlyJSONValue[]> = {\n  parse: ParseFn<T>;\n};\n\n/** @deprecated */\nexport type Parser<T extends ReadonlyJSONValue[]> = ParseFn<T> | HasParseFn<T>;\n\nexport type CustomQueryID = {\n  name: string;\n  args: ReadonlyArray<ReadonlyJSONValue>;\n};\n"],"mappings":";;;;AA4BA,SAAS,gBACP,QACwB;AACxB,KAAI,QAAQ;AACV,MAAI,WAAW,OACb,QAAO,OAAO,MAAM,KAAK,OAAO;AAElC,SAAO;;;;;;AAQX,SAAgB,YAKd,MACA,QACA,IACwD;CACxD,MAAM,OAAO,gBAAgB,MAAM,IAAI,MAAM;CAE7C,MAAM,OAAY,GAAG,SAAe,KAAK,KAAA,GAAW,KAAK;AACzD,KAAI,YAAY;AAChB,KAAI,QAAQ,gBAAgB,OAAO;AACnC,KAAI,eAAe;AACnB,QAAO;;;;;AAMT,SAAgB,uBAMd,MACA,QACA,IACwD;CACxD,MAAM,OAAO,gBAAgB,MAAM,IAAI,KAAK;CAE5C,MAAM,OAAY,SAAmB,GAAG,SAAe,KAAK,SAAS,KAAK;AAC1E,KAAI,YAAY;AAChB,KAAI,QAAQ,gBAAgB,OAAO;AACnC,KAAI,eAAe;AACnB,QAAO;;;AAIT,SAAS,gBAKP,MAAa,IAAS,cAAuB;AAC7C,SAAQ,SAAmB,SAAe;AAExC,SAAO,iBADG,eAAe,GAAG,SAAS,GAAG,KAAK,GAAG,GAAG,GAAG,KAAK,CACjC,CAAC,YAAY,MAAM,KAAK;;;;AAUtD,SAAgB,eACd,IAII;AAEJ,KAAI,WAAW,IAAI;EACjB,MAAM,EAAC,UAAS;AAChB,MAAI,CAAC,MACH,OAAM,IAAI,MAAM,6CAA6C;EAG/D,MAAM,OAAY,SAAkB,GAAG,SAAoB;GACzD,IAAI;AACJ,OAAI;AACF,aAAS,MAAM,KAAK;YACb,OAAO;AACd,UAAM,IAAI,gBAAgB,EAAC,OAAO,OAAM,CAAC;;AAG3C,UAAO,GAAG,eAAe,GAAG,SAAS,GAAG,OAAO,GAAI,GAAW,GAAG,OAAO;;AAE1E,MAAI,YAAY,GAAG;AACnB,MAAI,QAAQ,GAAG;AACf,MAAI,eAAe;AAEnB,SAAO;;AAMT,QAAO"}

package/out/zql/src/query/query-delegate-base.js.map

@@ -1 +1 @@
-{"version":3,"file":"query-delegate-base.js","names":[],"sources":["../../../../../zql/src/query/query-delegate-base.ts"],"sourcesContent":["import {resolver} from '@rocicorp/resolver';\nimport type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {ErroredQuery} from '../../../zero-protocol/src/custom-queries.ts';\nimport {hashOfNameAndArgs} from '../../../zero-protocol/src/query-hash.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport {buildPipeline} from '../builder/builder.ts';\nimport {ArrayView} from '../ivm/array-view.ts';\nimport type {FilterInput} from '../ivm/filter-operators.ts';\nimport {MemoryStorage} from '../ivm/memory-storage.ts';\nimport type {Input, InputBase, Storage} from '../ivm/operator.ts';\nimport type {Source, SourceInput} from '../ivm/source.ts';\nimport type {Format, ViewFactory} from '../ivm/view.ts';\nimport type {MetricMap} from './metrics-delegate.ts';\nimport type {CustomQueryID} from './named.ts';\nimport type {\n  CommitListener,\n  GotCallback,\n  QueryDelegate,\n} from './query-delegate.ts';\nimport {asQueryInternals, type QueryInternals} from './query-internals.ts';\nimport type {\n  HumanReadable,\n  MaterializeOptions,\n  PreloadOptions,\n  Query,\n  RunOptions,\n} from './query.ts';\nimport {DEFAULT_PRELOAD_TTL_MS, DEFAULT_TTL_MS, type TTL} from './ttl.ts';\nimport type {TypedView} from './typed-view.ts';\n\n/**\n * Base class that provides default implementations for common QueryDelegate methods.\n * Subclasses can override specific methods as needed.\n */\nexport abstract class QueryDelegateBase implements QueryDelegate {\n  /**\n   * Default implementation that just calls applyViewUpdates synchronously.\n   * Override if you need custom batching behavior (e.g., SolidJS).\n   */\n  batchViewUpdates<T>(applyViewUpdates: () => T): T {\n    return applyViewUpdates();\n  }\n\n  /**\n   * Default implementation returns MemoryStorage.\n   * Override if you need custom storage.\n   */\n  createStorage(): Storage {\n    return new MemoryStorage();\n  }\n\n  /**\n   * Default implementation calls materializeImpl.\n   * Override if you need custom materialization behavior.\n   */\n  materialize<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n  >(\n    query: Query<TTable, TSchema, TReturn>,\n    factory?: undefined,\n    options?: MaterializeOptions,\n  ): TypedView<HumanReadable<TReturn>>;\n\n  materialize<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n    T,\n  >(\n    query: Query<TTable, TSchema, TReturn>,\n    factory?: ViewFactory<TTable, TSchema, TReturn, T>,\n    options?: MaterializeOptions,\n  ): T;\n\n  /**\n   * Materialize a query into a custom view using a provided factory function.\n   */\n  materialize<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n    T,\n  >(\n    query: Query<TTable, TSchema, TReturn>,\n    factory?: ViewFactory<TTable, TSchema, TReturn, T>,\n    options?: MaterializeOptions,\n  ): T;\n\n  materialize<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n    T,\n  >(\n    query: Query<TTable, TSchema, TReturn>,\n    factory?: ViewFactory<TTable, TSchema, TReturn, T>,\n    options?: MaterializeOptions,\n  ): T {\n    return materializeImpl(query, this, factory, options);\n  }\n\n  /**\n   * Default implementation calls runImpl.\n   * Override if you need custom query execution (e.g., TestPGQueryDelegate).\n   */\n  run<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n  >(\n    query: Query<TTable, TSchema, TReturn>,\n    options?: RunOptions,\n  ): Promise<HumanReadable<TReturn>> {\n    return runImpl(query, this, options);\n  }\n\n  /**\n   * Default implementation calls preloadImpl.\n   * Override if you need custom preload behavior.\n   */\n  preload<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n  >(\n    query: Query<TTable, TSchema, TReturn>,\n    options?: PreloadOptions,\n  ): {\n    cleanup: () => void;\n    complete: Promise<void>;\n  } {\n    return preloadImpl(query, this, options);\n  }\n\n  /**\n   * Default no-op implementation for decorateSourceInput.\n   * Override if you need to wrap or instrument source inputs.\n   */\n  decorateSourceInput(input: SourceInput, _queryID: string): Input {\n    return input;\n  }\n\n  /**\n   * Default no-op implementation for decorateInput.\n   * Override if you need to wrap or instrument inputs.\n   */\n  decorateInput(input: Input, _name: string): Input {\n    return input;\n  }\n\n  /**\n   * Default no-op implementation for decorateFilterInput.\n   * Override if you need to wrap or instrument filter inputs.\n   */\n  decorateFilterInput(input: FilterInput, _name: string): FilterInput {\n    return input;\n  }\n\n  /**\n   * Default no-op implementation for addEdge.\n   * Override if you need to track graph edges (e.g., visualization).\n   */\n  addEdge(_source: InputBase, _dest: InputBase): void {\n    // No-op\n  }\n\n  /**\n   * Default no-op implementation for addMetric.\n   * Override if you need to collect metrics.\n   */\n  addMetric<K extends keyof MetricMap>(\n    _metric: K,\n    _value: number,\n    ..._args: MetricMap[K]\n  ): void {\n    // No-op\n  }\n\n  /**\n   * Default no-op implementation.\n   * Override if you need to track server queries (e.g., ZeroContext, test delegates).\n   */\n  addServerQuery(_ast: AST, _ttl: TTL, _gotCallback?: GotCallback): () => void {\n    return () => {};\n  }\n\n  /**\n   * Default no-op implementation.\n   * Override if you need to track custom queries (e.g., ZeroContext, test delegates).\n   */\n  addCustomQuery(\n    _ast: AST,\n    _customQueryID: CustomQueryID,\n    _ttl: TTL,\n    _gotCallback?: GotCallback,\n  ): () => void {\n    return () => {};\n  }\n\n  /**\n   * Default no-op implementation.\n   * Override if you need to handle query updates.\n   */\n  updateServerQuery(_ast: AST, _ttl: TTL): void {\n    // No-op\n  }\n\n  /**\n   * Default no-op implementation.\n   * Override if you need to handle custom query updates.\n   */\n  updateCustomQuery(_customQueryID: CustomQueryID, _ttl: TTL): void {\n    // No-op\n  }\n\n  /**\n   * Default no-op implementation.\n   * Override if you need to flush query changes.\n   */\n  flushQueryChanges(): void {\n    // No-op\n  }\n\n  /**\n   * Called when a transaction commits. Override to add custom behavior.\n   * Default implementation returns a no-op cleanup function.\n   */\n  onTransactionCommit(_cb: CommitListener): () => void {\n    return () => {};\n  }\n\n  /**\n   * Validates run options. Override to add custom validation.\n   * Default implementation is a no-op.\n   */\n  assertValidRunOptions(_options?: RunOptions): void {\n    // No-op\n  }\n\n  abstract readonly defaultQueryComplete: boolean;\n\n  // BuilderDelegate methods - must be implemented\n  abstract getSource(name: string): Source | undefined;\n}\n\n// oxlint-disable-next-line require-await\nexport async function runImpl<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n  TReturn,\n>(\n  query: Query<TTable, TSchema, TReturn>,\n  delegate: QueryDelegate,\n  options?: RunOptions,\n): Promise<HumanReadable<TReturn>> {\n  delegate.assertValidRunOptions(options);\n  const v: TypedView<HumanReadable<TReturn>> = materializeImpl(\n    query,\n    delegate,\n    undefined,\n    {\n      ttl: options?.ttl,\n    },\n  );\n  if (options?.type === 'complete') {\n    return new Promise(resolve => {\n      v.addListener((data, type) => {\n        if (type === 'complete') {\n          v.destroy();\n          resolve(data as HumanReadable<TReturn>);\n        } else if (type === 'error') {\n          v.destroy();\n          resolve(Promise.reject(data));\n        }\n      });\n    });\n  }\n\n  options?.type satisfies 'unknown' | undefined;\n\n  const ret = v.data;\n  v.destroy();\n  return ret;\n}\n\nexport function preloadImpl<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n  TReturn,\n>(\n  query: Query<TTable, TSchema, TReturn>,\n  delegate: QueryDelegate,\n  options?: PreloadOptions,\n): {\n  cleanup: () => void;\n  complete: Promise<void>;\n} {\n  const qi = asQueryInternals(query);\n  const ttl = options?.ttl ?? DEFAULT_PRELOAD_TTL_MS;\n  const {resolve, promise: complete} = resolver<void>();\n  const {customQueryID, ast} = qi;\n  if (customQueryID) {\n    const cleanup = delegate.addCustomQuery(ast, customQueryID, ttl, got => {\n      if (got) {\n        resolve();\n      }\n    });\n    return {\n      cleanup,\n      complete,\n    };\n  }\n\n  const cleanup = delegate.addServerQuery(ast, ttl, got => {\n    if (got) {\n      resolve();\n    }\n  });\n  return {\n    cleanup,\n    complete,\n  };\n}\n\nexport function materializeImpl<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n  TReturn,\n  T,\n>(\n  query: Query<TTable, TSchema, TReturn>,\n  delegate: QueryDelegate,\n  factory: ViewFactory<\n    TTable,\n    TSchema,\n    TReturn,\n    T\n    // oxlint-disable-next-line no-explicit-any\n  > = arrayViewFactory as any,\n  options?: MaterializeOptions,\n): T {\n  let ttl: TTL = options?.ttl ?? DEFAULT_TTL_MS;\n\n  const qi = asQueryInternals(query);\n  const {ast, format, customQueryID} = qi;\n  const queryHash = qi.hash();\n\n  const queryID = customQueryID\n    ? hashOfNameAndArgs(customQueryID.name, customQueryID.args)\n    : queryHash;\n  const queryCompleteResolver = resolver<true>();\n  let queryComplete: boolean | ErroredQuery = delegate.defaultQueryComplete;\n  const updateTTL = customQueryID\n    ? (newTTL: TTL) => delegate.updateCustomQuery(customQueryID, newTTL)\n    : (newTTL: TTL) => delegate.updateServerQuery(ast, newTTL);\n\n  const gotCallback: GotCallback = (got, error) => {\n    if (error) {\n      queryCompleteResolver.reject(error);\n      queryComplete = error;\n      return;\n    }\n\n    if (got) {\n      delegate.addMetric(\n        'query-materialization-end-to-end',\n        performance.now() - t0,\n        queryID,\n        ast,\n      );\n      queryComplete = true;\n      queryCompleteResolver.resolve(true);\n    }\n  };\n\n  let removeCommitObserver: (() => void) | undefined;\n  const onDestroy = () => {\n    input.destroy();\n    removeCommitObserver?.();\n    removeAddedQuery();\n  };\n\n  const t0 = performance.now();\n\n  const removeAddedQuery = customQueryID\n    ? delegate.addCustomQuery(ast, customQueryID, ttl, gotCallback)\n    : delegate.addServerQuery(ast, ttl, gotCallback);\n\n  const input = buildPipeline(ast, delegate, queryID);\n\n  const view = delegate.batchViewUpdates(() =>\n    (factory ?? arrayViewFactory)(\n      query,\n      input,\n      format,\n      onDestroy,\n      cb => {\n        removeCommitObserver = delegate.onTransactionCommit(cb);\n      },\n      queryComplete || queryCompleteResolver.promise,\n      updateTTL,\n    ),\n  );\n\n  delegate.addMetric(\n    'query-materialization-client',\n    performance.now() - t0,\n    queryID,\n  );\n\n  return view as T;\n}\n\nfunction arrayViewFactory<\n  TTable extends string,\n  TSchema extends Schema,\n  TReturn,\n>(\n  _query: QueryInternals<TTable, TSchema, TReturn>,\n  input: Input,\n  format: Format,\n  onDestroy: () => void,\n  onTransactionCommit: (cb: () => void) => void,\n  queryComplete: true | ErroredQuery | Promise<true>,\n  updateTTL: (ttl: TTL) => void,\n): TypedView<HumanReadable<TReturn>> {\n  const v = new ArrayView<HumanReadable<TReturn>>(\n    input,\n    format,\n    queryComplete,\n    updateTTL,\n  );\n  v.onDestroy = onDestroy;\n  onTransactionCommit(() => {\n    v.flush();\n  });\n  return v;\n}\n"],"mappings":"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"}
+{"version":3,"file":"query-delegate-base.js","names":[],"sources":["../../../../../zql/src/query/query-delegate-base.ts"],"sourcesContent":["import {resolver} from '@rocicorp/resolver';\nimport type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {ErroredQuery} from '../../../zero-protocol/src/custom-queries.ts';\nimport {hashOfNameAndArgs} from '../../../zero-protocol/src/query-hash.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport {buildPipeline} from '../builder/builder.ts';\nimport {ArrayView} from '../ivm/array-view.ts';\nimport type {FilterInput} from '../ivm/filter-operators.ts';\nimport {MemoryStorage} from '../ivm/memory-storage.ts';\nimport type {Input, InputBase, Storage} from '../ivm/operator.ts';\nimport type {Source, SourceInput} from '../ivm/source.ts';\nimport type {Format, ViewFactory} from '../ivm/view.ts';\nimport type {MetricMap} from './metrics-delegate.ts';\nimport type {CustomQueryID} from './named.ts';\nimport type {\n  CommitListener,\n  GotCallback,\n  QueryDelegate,\n} from './query-delegate.ts';\nimport {asQueryInternals, type QueryInternals} from './query-internals.ts';\nimport type {\n  HumanReadable,\n  MaterializeOptions,\n  PreloadOptions,\n  Query,\n  RunOptions,\n} from './query.ts';\nimport {DEFAULT_PRELOAD_TTL_MS, DEFAULT_TTL_MS, type TTL} from './ttl.ts';\nimport type {TypedView} from './typed-view.ts';\n\n/**\n * Base class that provides default implementations for common QueryDelegate methods.\n * Subclasses can override specific methods as needed.\n */\nexport abstract class QueryDelegateBase implements QueryDelegate {\n  /**\n   * Default implementation that just calls applyViewUpdates synchronously.\n   * Override if you need custom batching behavior (e.g., SolidJS).\n   */\n  batchViewUpdates<T>(applyViewUpdates: () => T): T {\n    return applyViewUpdates();\n  }\n\n  /**\n   * Default implementation returns MemoryStorage.\n   * Override if you need custom storage.\n   */\n  createStorage(): Storage {\n    return new MemoryStorage();\n  }\n\n  /**\n   * Default implementation calls materializeImpl.\n   * Override if you need custom materialization behavior.\n   */\n  materialize<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n  >(\n    query: Query<TTable, TSchema, TReturn>,\n    factory?: undefined,\n    options?: MaterializeOptions,\n  ): TypedView<HumanReadable<TReturn>>;\n\n  materialize<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n    T,\n  >(\n    query: Query<TTable, TSchema, TReturn>,\n    factory?: ViewFactory<TTable, TSchema, TReturn, T>,\n    options?: MaterializeOptions,\n  ): T;\n\n  /**\n   * Materialize a query into a custom view using a provided factory function.\n   */\n  materialize<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n    T,\n  >(\n    query: Query<TTable, TSchema, TReturn>,\n    factory?: ViewFactory<TTable, TSchema, TReturn, T>,\n    options?: MaterializeOptions,\n  ): T;\n\n  materialize<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n    T,\n  >(\n    query: Query<TTable, TSchema, TReturn>,\n    factory?: ViewFactory<TTable, TSchema, TReturn, T>,\n    options?: MaterializeOptions,\n  ): T {\n    return materializeImpl(query, this, factory, options);\n  }\n\n  /**\n   * Default implementation calls runImpl.\n   * Override if you need custom query execution (e.g., TestPGQueryDelegate).\n   */\n  run<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n  >(\n    query: Query<TTable, TSchema, TReturn>,\n    options?: RunOptions,\n  ): Promise<HumanReadable<TReturn>> {\n    return runImpl(query, this, options);\n  }\n\n  /**\n   * Default implementation calls preloadImpl.\n   * Override if you need custom preload behavior.\n   */\n  preload<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n  >(\n    query: Query<TTable, TSchema, TReturn>,\n    options?: PreloadOptions,\n  ): {\n    cleanup: () => void;\n    complete: Promise<void>;\n  } {\n    return preloadImpl(query, this, options);\n  }\n\n  /**\n   * Default no-op implementation for decorateSourceInput.\n   * Override if you need to wrap or instrument source inputs.\n   */\n  decorateSourceInput(input: SourceInput, _queryID: string): Input {\n    return input;\n  }\n\n  /**\n   * Default no-op implementation for decorateInput.\n   * Override if you need to wrap or instrument inputs.\n   */\n  decorateInput(input: Input, _name: string): Input {\n    return input;\n  }\n\n  /**\n   * Default no-op implementation for decorateFilterInput.\n   * Override if you need to wrap or instrument filter inputs.\n   */\n  decorateFilterInput(input: FilterInput, _name: string): FilterInput {\n    return input;\n  }\n\n  /**\n   * Default no-op implementation for addEdge.\n   * Override if you need to track graph edges (e.g., visualization).\n   */\n  addEdge(_source: InputBase, _dest: InputBase): void {\n    // No-op\n  }\n\n  /**\n   * Default no-op implementation for addMetric.\n   * Override if you need to collect metrics.\n   */\n  addMetric<K extends keyof MetricMap>(\n    _metric: K,\n    _value: number,\n    ..._args: MetricMap[K]\n  ): void {\n    // No-op\n  }\n\n  /**\n   * Default no-op implementation.\n   * Override if you need to track server queries (e.g., ZeroContext, test delegates).\n   */\n  addServerQuery(_ast: AST, _ttl: TTL, _gotCallback?: GotCallback): () => void {\n    return () => {};\n  }\n\n  /**\n   * Default no-op implementation.\n   * Override if you need to track custom queries (e.g., ZeroContext, test delegates).\n   */\n  addCustomQuery(\n    _ast: AST,\n    _customQueryID: CustomQueryID,\n    _ttl: TTL,\n    _gotCallback?: GotCallback,\n  ): () => void {\n    return () => {};\n  }\n\n  /**\n   * Default no-op implementation.\n   * Override if you need to handle query updates.\n   */\n  updateServerQuery(_ast: AST, _ttl: TTL): void {\n    // No-op\n  }\n\n  /**\n   * Default no-op implementation.\n   * Override if you need to handle custom query updates.\n   */\n  updateCustomQuery(_customQueryID: CustomQueryID, _ttl: TTL): void {\n    // No-op\n  }\n\n  /**\n   * Default no-op implementation.\n   * Override if you need to flush query changes.\n   */\n  flushQueryChanges(): void {\n    // No-op\n  }\n\n  /**\n   * Called when a transaction commits. Override to add custom behavior.\n   * Default implementation returns a no-op cleanup function.\n   */\n  onTransactionCommit(_cb: CommitListener): () => void {\n    return () => {};\n  }\n\n  /**\n   * Validates run options. Override to add custom validation.\n   * Default implementation is a no-op.\n   */\n  assertValidRunOptions(_options?: RunOptions): void {\n    // No-op\n  }\n\n  abstract readonly defaultQueryComplete: boolean;\n\n  // BuilderDelegate methods - must be implemented\n  abstract getSource(name: string): Source | undefined;\n}\n\n// oxlint-disable-next-line require-await\nexport async function runImpl<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n  TReturn,\n>(\n  query: Query<TTable, TSchema, TReturn>,\n  delegate: QueryDelegate,\n  options?: RunOptions,\n): Promise<HumanReadable<TReturn>> {\n  delegate.assertValidRunOptions(options);\n  const v: TypedView<HumanReadable<TReturn>> = materializeImpl(\n    query,\n    delegate,\n    undefined,\n    {\n      ttl: options?.ttl,\n    },\n  );\n  if (options?.type === 'complete') {\n    return new Promise(resolve => {\n      v.addListener((data, type) => {\n        if (type === 'complete') {\n          v.destroy();\n          resolve(data as HumanReadable<TReturn>);\n        } else if (type === 'error') {\n          v.destroy();\n          resolve(Promise.reject(data));\n        }\n      });\n    });\n  }\n\n  options?.type satisfies 'unknown' | undefined;\n\n  const ret = v.data;\n  v.destroy();\n  return ret;\n}\n\nexport function preloadImpl<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n  TReturn,\n>(\n  query: Query<TTable, TSchema, TReturn>,\n  delegate: QueryDelegate,\n  options?: PreloadOptions,\n): {\n  cleanup: () => void;\n  complete: Promise<void>;\n} {\n  const qi = asQueryInternals(query);\n  const ttl = options?.ttl ?? DEFAULT_PRELOAD_TTL_MS;\n  const {resolve, promise: complete} = resolver<void>();\n  const {customQueryID, ast} = qi;\n  if (customQueryID) {\n    const cleanup = delegate.addCustomQuery(ast, customQueryID, ttl, got => {\n      if (got) {\n        resolve();\n      }\n    });\n    return {\n      cleanup,\n      complete,\n    };\n  }\n\n  const cleanup = delegate.addServerQuery(ast, ttl, got => {\n    if (got) {\n      resolve();\n    }\n  });\n  return {\n    cleanup,\n    complete,\n  };\n}\n\nexport function materializeImpl<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n  TReturn,\n  T,\n>(\n  query: Query<TTable, TSchema, TReturn>,\n  delegate: QueryDelegate,\n  factory: ViewFactory<\n    TTable,\n    TSchema,\n    TReturn,\n    T\n    // oxlint-disable-next-line no-explicit-any\n  > = arrayViewFactory as any,\n  options?: MaterializeOptions,\n): T {\n  let ttl: TTL = options?.ttl ?? DEFAULT_TTL_MS;\n\n  const qi = asQueryInternals(query);\n  const {ast, format, customQueryID} = qi;\n  const queryHash = qi.hash();\n\n  const queryID = customQueryID\n    ? hashOfNameAndArgs(customQueryID.name, customQueryID.args)\n    : queryHash;\n  const queryCompleteResolver = resolver<true>();\n  let queryComplete: boolean | ErroredQuery = delegate.defaultQueryComplete;\n  const updateTTL = customQueryID\n    ? (newTTL: TTL) => delegate.updateCustomQuery(customQueryID, newTTL)\n    : (newTTL: TTL) => delegate.updateServerQuery(ast, newTTL);\n\n  const gotCallback: GotCallback = (got, error) => {\n    if (error) {\n      queryCompleteResolver.reject(error);\n      queryComplete = error;\n      return;\n    }\n\n    if (got) {\n      delegate.addMetric(\n        'query-materialization-end-to-end',\n        performance.now() - t0,\n        queryID,\n        ast,\n      );\n      queryComplete = true;\n      queryCompleteResolver.resolve(true);\n    }\n  };\n\n  let removeCommitObserver: (() => void) | undefined;\n  const onDestroy = () => {\n    input.destroy();\n    removeCommitObserver?.();\n    removeAddedQuery();\n  };\n\n  const t0 = performance.now();\n\n  const removeAddedQuery = customQueryID\n    ? delegate.addCustomQuery(ast, customQueryID, ttl, gotCallback)\n    : delegate.addServerQuery(ast, ttl, gotCallback);\n\n  const input = buildPipeline(ast, delegate, queryID);\n\n  const view = delegate.batchViewUpdates(() =>\n    (factory ?? arrayViewFactory)(\n      query,\n      input,\n      format,\n      onDestroy,\n      cb => {\n        removeCommitObserver = delegate.onTransactionCommit(cb);\n      },\n      queryComplete || queryCompleteResolver.promise,\n      updateTTL,\n    ),\n  );\n\n  delegate.addMetric(\n    'query-materialization-client',\n    performance.now() - t0,\n    queryID,\n  );\n\n  return view as T;\n}\n\nfunction arrayViewFactory<\n  TTable extends string,\n  TSchema extends Schema,\n  TReturn,\n>(\n  _query: QueryInternals<TTable, TSchema, TReturn>,\n  input: Input,\n  format: Format,\n  onDestroy: () => void,\n  onTransactionCommit: (cb: () => void) => void,\n  queryComplete: true | ErroredQuery | Promise<true>,\n  updateTTL: (ttl: TTL) => void,\n): TypedView<HumanReadable<TReturn>> {\n  const v = new ArrayView<HumanReadable<TReturn>>(\n    input,\n    format,\n    queryComplete,\n    updateTTL,\n  );\n  v.onDestroy = onDestroy;\n  onTransactionCommit(() => {\n    v.flush();\n  });\n  return v;\n}\n"],"mappings":"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"}

package/out/zql/src/query/query-impl.js

@@ -50,7 +50,7 @@ var QueryImpl = class {
 		}, this.#currentJunction);
 	}
 	hash() {
-		if (!this.#hash) this.#hash = hashOfAST(this.#ast) + (this.format.singular ? "t" : "f");
+		if (!this.#hash) this.#hash = hashOfAST(this.#ast);
 		return this.#hash;
 	}
 	one = () => this.#newQuery(this.#tableName, {