@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

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

@@ -1,215 +1,225 @@
 import { assert } from "../../../shared/src/asserts.js";
-import { mergeConstraints } from "./planner-constraint.js";
 import { omitFanout } from "./planner-node.js";
-class PlannerConnection {
-  kind = "connection";
-  // ========================================================================
-  // IMMUTABLE STRUCTURE (set during construction, never changes)
-  // ========================================================================
-  #sort;
-  #filters;
-  #model;
-  table;
-  name;
-  // Human-readable name for debugging (defaults to table name)
-  #baseConstraints;
-  // Constraints from parent correlation
-  #baseLimit;
-  // Original limit from query structure (never modified)
-  selectivity;
-  // Fraction of rows passing filters (1.0 = no filtering)
-  #output;
-  // Set once during graph construction
-  // ========================================================================
-  // MUTABLE PLANNING STATE (changes during plan search)
-  // ========================================================================
-  /**
-   * Current limit during planning. Can be cleared (set to undefined) when a
-   * parent join is flipped, indicating this connection is now in an outer loop
-   * and should not be limited by EXISTS semantics.
-   */
-  limit;
-  /**
-   * Constraints accumulated from parent joins during planning.
-   * Key is a path through the graph (e.g., "0,1" for branch pattern [0,1]).
-   *
-   * Undefined constraints are possible when a FO converts to UFO and only
-   * a single join in the UFO is flipped - other branches report undefined.
-   */
-  #constraints;
-  #isRoot;
-  /**
-   * Cached per-constraint costs to avoid redundant cost model calls.
-   * Maps constraint key (branch pattern string) to computed cost.
-   * Invalidated when constraints change.
-   */
-  #cachedConstraintCosts = /* @__PURE__ */ new Map();
-  constructor(table, model, sort, filters, isRoot, baseConstraints, limit, name) {
-    this.table = table;
-    this.name = name ?? table;
-    this.#sort = sort;
-    this.#filters = filters;
-    this.#model = model;
-    this.#baseConstraints = baseConstraints;
-    this.#baseLimit = limit;
-    this.limit = limit;
-    this.#constraints = /* @__PURE__ */ new Map();
-    this.#isRoot = isRoot;
-    if (limit !== void 0 && filters) {
-      const costWithFilters = model(table, sort, filters, void 0);
-      const costWithoutFilters = model(table, sort, void 0, void 0);
-      this.selectivity = costWithoutFilters.rows > 0 ? costWithFilters.rows / costWithoutFilters.rows : 1;
-    } else {
-      this.selectivity = 1;
-    }
-  }
-  setOutput(node) {
-    this.#output = node;
-  }
-  get output() {
-    assert(this.#output !== void 0, "Output not set");
-    return this.#output;
-  }
-  closestJoinOrSource() {
-    return "connection";
-  }
-  /**
-   * Constraints are uniquely identified by their path through the
-   * graph.
-   *
-   * FO represents all sub-joins as a single path.
-   * UFO represents each sub-join as a separate path.
-   * The first branch in a UFO will match the path of FO so no re-set needs to happen
-   * when swapping from FO to UFO.
-   *
-   * FO swaps to UFO when a join inside FO-FI gets flipped.
-   *
-   * The max of the last element of the paths is the number of
-   * root branches.
-   */
-  propagateConstraints(path, c, from, planDebugger) {
-    const key = path.join(",");
-    this.#constraints.set(key, c);
-    this.#cachedConstraintCosts.clear();
-    planDebugger?.log({
-      type: "node-constraint",
-      nodeType: "connection",
-      node: this.name,
-      branchPattern: path,
-      constraint: c,
-      from: from?.kind ?? "unknown"
-    });
-  }
-  estimateCost(downstreamChildSelectivity, branchPattern, planDebugger) {
-    const key = branchPattern.join(",");
-    let cost = this.#cachedConstraintCosts.get(key);
-    if (cost !== void 0) {
-      return cost;
-    }
-    const constraint = this.#constraints.get(key);
-    const mergedConstraint = mergeConstraints(
-      this.#baseConstraints,
-      constraint
-    );
-    const { startupCost, fanout, rows } = this.#model(
-      this.table,
-      this.#sort,
-      this.#filters,
-      mergedConstraint
-    );
-    cost = {
-      startupCost,
-      scanEst: this.limit === void 0 ? rows : Math.min(rows, this.limit / downstreamChildSelectivity),
-      cost: 0,
-      returnedRows: rows,
-      selectivity: this.selectivity,
-      limit: this.limit,
-      fanout
-    };
-    this.#cachedConstraintCosts.set(key, cost);
-    if (planDebugger) {
-      planDebugger.log({
-        type: "node-cost",
-        nodeType: "connection",
-        node: this.name,
-        branchPattern,
-        downstreamChildSelectivity,
-        costEstimate: omitFanout(cost),
-        filters: this.#filters,
-        ordering: this.#sort
-      });
-    }
-    return cost;
-  }
-  /**
-   * Remove the limit from this connection.
-   * Called when a parent join is flipped, making this connection part of an
-   * outer loop that should produce all rows rather than stopping at the limit.
-   */
-  unlimit() {
-    if (this.#isRoot) {
-      return;
-    }
-    if (this.limit !== void 0) {
-      this.limit = void 0;
-    }
-  }
-  /**
-   * Propagate unlimiting when a parent join is flipped.
-   * For connections, we simply remove the limit.
-   */
-  propagateUnlimitFromFlippedJoin() {
-    this.unlimit();
-  }
-  reset() {
-    this.#constraints.clear();
-    this.limit = this.#baseLimit;
-    this.#cachedConstraintCosts.clear();
-  }
-  /**
-   * Capture constraint state for snapshotting.
-   * Used by PlannerGraph to save/restore planning state.
-   */
-  captureConstraints() {
-    return new Map(this.#constraints);
-  }
-  /**
-   * Restore constraint state from a snapshot.
-   * Used by PlannerGraph to restore planning state.
-   */
-  restoreConstraints(constraints) {
-    this.#constraints.clear();
-    for (const [key, value] of constraints) {
-      this.#constraints.set(key, value);
-    }
-    this.#cachedConstraintCosts.clear();
-  }
-  /** Get current constraints for debugging. */
-  getConstraintsForDebug() {
-    const record = {};
-    for (const [key, value] of this.#constraints) {
-      record[key] = value;
-    }
-    return record;
-  }
-  /** Get filters for debugging. */
-  getFiltersForDebug() {
-    return this.#filters;
-  }
-  /** Get sort/ordering for debugging. */
-  getSortForDebug() {
-    return this.#sort;
-  }
-  /** Get estimated cost for each constraint branch. */
-  getConstraintCostsForDebug() {
-    const record = {};
-    for (const [key, value] of this.#cachedConstraintCosts) {
-      record[key] = value;
-    }
-    return record;
-  }
-}
-export {
-  PlannerConnection
+import { mergeConstraints } from "./planner-constraint.js";
+//#region ../zql/src/planner/planner-connection.ts
+/**
+* Represents a connection to a source (table scan).
+*
+* # Dual State Pattern
+* Like all planner nodes, PlannerConnection separates:
+* 1. immutable structure: Ordering, filters, cost model (set at construction)
+* 2. mutable state: Pinned status, constraints (mutated during planning)
+*
+* # Cost Estimation
+* The ordering and filters determine the initial cost. As planning progresses,
+* constraints from parent joins refine the cost estimate.
+*
+* # Constraint Flow
+* When a connection is pinned as the outer loop, it reveals constraints for
+* connected joins. These constraints propagate through the graph, allowing
+* other connections to update their cost estimates.
+*
+* Example:
+*
+* ```ts
+* builder.issue.whereExists('assignee', a => a.where('name', 'Alice'))
+* ```
+*
+* ```
+* [issue]  [assignee]
+*   |         |
+*   |         +-- where name = 'Alice'
+*    \        /
+*     \      /
+*      [join]
+*        |
+* ```
+*
+* - Initial state: Both connections have no constraints, costs are unconstrained
+* - If `issue` chosen first: Reveals constraint `assignee_id` for assignee connection
+* - If `assignee` chosen first: Reveals constraint `assignee_id` for issue connection
+* - Updated costs guide the next selection
+*
+* # Lifecycle
+* 1. Construct with immutable structure (ordering, filters, cost model)
+* 2. Wire to output node during graph construction
+* 3. Planning mutates pinned status and accumulates constraints
+* 4. reset() clears mutable state for replanning
+*/
+var PlannerConnection = class {
+	kind = "connection";
+	#sort;
+	#filters;
+	#model;
+	table;
+	name;
+	#baseConstraints;
+	#baseLimit;
+	selectivity;
+	#output;
+	/**
+	* Current limit during planning. Can be cleared (set to undefined) when a
+	* parent join is flipped, indicating this connection is now in an outer loop
+	* and should not be limited by EXISTS semantics.
+	*/
+	limit;
+	/**
+	* Constraints accumulated from parent joins during planning.
+	* Key is a path through the graph (e.g., "0,1" for branch pattern [0,1]).
+	*
+	* Undefined constraints are possible when a FO converts to UFO and only
+	* a single join in the UFO is flipped - other branches report undefined.
+	*/
+	#constraints;
+	#isRoot;
+	/**
+	* Cached per-constraint costs to avoid redundant cost model calls.
+	* Maps constraint key (branch pattern string) to computed cost.
+	* Invalidated when constraints change.
+	*/
+	#cachedConstraintCosts = /* @__PURE__ */ new Map();
+	constructor(table, model, sort, filters, isRoot, baseConstraints, limit, name) {
+		this.table = table;
+		this.name = name ?? table;
+		this.#sort = sort;
+		this.#filters = filters;
+		this.#model = model;
+		this.#baseConstraints = baseConstraints;
+		this.#baseLimit = limit;
+		this.limit = limit;
+		this.#constraints = /* @__PURE__ */ new Map();
+		this.#isRoot = isRoot;
+		if (limit !== void 0 && filters) {
+			const costWithFilters = model(table, sort, filters, void 0);
+			const costWithoutFilters = model(table, sort, void 0, void 0);
+			this.selectivity = costWithoutFilters.rows > 0 ? costWithFilters.rows / costWithoutFilters.rows : 1;
+		} else this.selectivity = 1;
+	}
+	setOutput(node) {
+		this.#output = node;
+	}
+	get output() {
+		assert(this.#output !== void 0, "Output not set");
+		return this.#output;
+	}
+	closestJoinOrSource() {
+		return "connection";
+	}
+	/**
+	* Constraints are uniquely identified by their path through the
+	* graph.
+	*
+	* FO represents all sub-joins as a single path.
+	* UFO represents each sub-join as a separate path.
+	* The first branch in a UFO will match the path of FO so no re-set needs to happen
+	* when swapping from FO to UFO.
+	*
+	* FO swaps to UFO when a join inside FO-FI gets flipped.
+	*
+	* The max of the last element of the paths is the number of
+	* root branches.
+	*/
+	propagateConstraints(path, c, from, planDebugger) {
+		const key = path.join(",");
+		this.#constraints.set(key, c);
+		this.#cachedConstraintCosts.clear();
+		planDebugger?.log({
+			type: "node-constraint",
+			nodeType: "connection",
+			node: this.name,
+			branchPattern: path,
+			constraint: c,
+			from: from?.kind ?? "unknown"
+		});
+	}
+	estimateCost(downstreamChildSelectivity, branchPattern, planDebugger) {
+		const key = branchPattern.join(",");
+		let cost = this.#cachedConstraintCosts.get(key);
+		if (cost !== void 0) return cost;
+		const constraint = this.#constraints.get(key);
+		const mergedConstraint = mergeConstraints(this.#baseConstraints, constraint);
+		const { startupCost, fanout, rows } = this.#model(this.table, this.#sort, this.#filters, mergedConstraint);
+		cost = {
+			startupCost,
+			scanEst: this.limit === void 0 ? rows : Math.min(rows, this.limit / downstreamChildSelectivity),
+			cost: 0,
+			returnedRows: rows,
+			selectivity: this.selectivity,
+			limit: this.limit,
+			fanout
+		};
+		this.#cachedConstraintCosts.set(key, cost);
+		if (planDebugger) planDebugger.log({
+			type: "node-cost",
+			nodeType: "connection",
+			node: this.name,
+			branchPattern,
+			downstreamChildSelectivity,
+			costEstimate: omitFanout(cost),
+			filters: this.#filters,
+			ordering: this.#sort
+		});
+		return cost;
+	}
+	/**
+	* Remove the limit from this connection.
+	* Called when a parent join is flipped, making this connection part of an
+	* outer loop that should produce all rows rather than stopping at the limit.
+	*/
+	unlimit() {
+		if (this.#isRoot) return;
+		if (this.limit !== void 0) this.limit = void 0;
+	}
+	/**
+	* Propagate unlimiting when a parent join is flipped.
+	* For connections, we simply remove the limit.
+	*/
+	propagateUnlimitFromFlippedJoin() {
+		this.unlimit();
+	}
+	reset() {
+		this.#constraints.clear();
+		this.limit = this.#baseLimit;
+		this.#cachedConstraintCosts.clear();
+	}
+	/**
+	* Capture constraint state for snapshotting.
+	* Used by PlannerGraph to save/restore planning state.
+	*/
+	captureConstraints() {
+		return new Map(this.#constraints);
+	}
+	/**
+	* Restore constraint state from a snapshot.
+	* Used by PlannerGraph to restore planning state.
+	*/
+	restoreConstraints(constraints) {
+		this.#constraints.clear();
+		for (const [key, value] of constraints) this.#constraints.set(key, value);
+		this.#cachedConstraintCosts.clear();
+	}
+	/** Get current constraints for debugging. */
+	getConstraintsForDebug() {
+		const record = {};
+		for (const [key, value] of this.#constraints) record[key] = value;
+		return record;
+	}
+	/** Get filters for debugging. */
+	getFiltersForDebug() {
+		return this.#filters;
+	}
+	/** Get sort/ordering for debugging. */
+	getSortForDebug() {
+		return this.#sort;
+	}
+	/** Get estimated cost for each constraint branch. */
+	getConstraintCostsForDebug() {
+		const record = {};
+		for (const [key, value] of this.#cachedConstraintCosts) record[key] = value;
+		return record;
+	}
 };
-//# sourceMappingURL=planner-connection.js.map
+//#endregion
+export { PlannerConnection };
+
+//# sourceMappingURL=planner-connection.js.map

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

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

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

@@ -1,9 +1,17 @@
+//#region ../zql/src/planner/planner-constraint.ts
+/**
+* Multiple flipped joins will contribute extra constraints to a parent join.
+* These need to be merged.
+*/
 function mergeConstraints(a, b) {
-  if (!a) return b;
-  if (!b) return a;
-  return { ...a, ...b };
+	if (!a) return b;
+	if (!b) return a;
+	return {
+		...a,
+		...b
+	};
 }
-export {
-  mergeConstraints
-};
-//# sourceMappingURL=planner-constraint.js.map
+//#endregion
+export { mergeConstraints };
+
+//# sourceMappingURL=planner-constraint.js.map

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

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