@rocicorp/zero 0.25.0-canary.6 → 0.25.0-canary.8

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"planner-join.js","sourceRoot":"","sources":["../../../../../zql/src/planner/planner-join.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,gCAAgC,CAAC;AACtD,OAAO,EACL,gBAAgB,GAEjB,MAAM,yBAAyB,CAAC;AASjC;;;;;;;;;;GAUG;AACH,SAAS,kCAAkC,CACzC,kBAAiD,EACjD,gBAAmC,EACnC,eAAkC;IAElC,IAAI,CAAC,kBAAkB;QAAE,OAAO,SAAS,CAAC;IAE1C,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACjD,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC/C,MAAM,UAAU,GAAsB,EAAE,CAAC;IAEzC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE,CAAC;QAC9D,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,+CAA+C;YAC/C,oCAAoC;YACpC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC;QACvC,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC;AACrE,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,6CAA6C;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,OAAO,WAAW;IACb,IAAI,GAAG,MAAe,CAAC;IAEvB,OAAO,CAAwC;IAC/C,MAAM,CAAwC;IAC9C,iBAAiB,CAAoB;IACrC,gBAAgB,CAAoB;IACpC,UAAU,CAAU;IACpB,MAAM,CAAS;IACxB,OAAO,CAA2B,CAAC,qCAAqC;IAExE,kCAAkC;IAClC,KAAK,CAAqB;IACjB,YAAY,CAAqB;IAE1C,YACE,MAA6C,EAC7C,KAA4C,EAC5C,gBAAmC,EACnC,eAAkC,EAClC,SAAkB,EAClB,MAAc,EACd,cAAkC,MAAM;QAExC,IAAI,CAAC,KAAK,GAAG,WAAW,CAAC;QACzB,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;QAChC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,gBAAgB,GAAG,eAAe,CAAC;QACxC,IAAI,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;QAC1C,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,SAAS,CAAC,IAAiB;QACzB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED,IAAI,MAAM;QACR,MAAM,CAAC,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,gBAAgB,CAAC,CAAC;QACrD,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,mBAAmB;QACjB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,YAAY,CAAC,KAAkB;QAC7B,IAAI,KAAK,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;YAC1B,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC;aAAM,CAAC;YACN,MAAM,CACJ,KAAK,KAAK,IAAI,CAAC,OAAO,EACtB,6CAA6C,CAC9C,CAAC;QACJ,CAAC;IACH,CAAC;IAED,IAAI;QACF,MAAM,CAAC,IAAI,CAAC,KAAK,KAAK,MAAM,EAAE,2BAA2B,CAAC,CAAC;QAC3D,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,MAAM,IAAI,oBAAoB,CAC5B,qDAAqD,CACtD,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;IACzB,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,WAAW;QACT,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAAgB;QACd,MAAM,CAAC,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,iCAAiC,CAAC,CAAC;QACpE,IAAI,CAAC,OAAO,CAAC,+BAA+B,EAAE,CAAC;QAC/C,IAAI,CAAC,MAAM,CAAC,+BAA+B,EAAE,CAAC,CAAC,qBAAqB;IACtE,CAAC;IAED;;;;OAIG;IACH,+BAA+B;QAC7B,IAAI,IAAI,CAAC,KAAK,KAAK,MAAM,EAAE,CAAC;YAC1B,IAAI,CAAC,OAAO,CAAC,+BAA+B,EAAE,CAAC;QACjD,CAAC;QACD,sCAAsC;IACxC,CAAC;IAED,oBAAoB,CAClB,aAAuB,EACvB,UAAyC,EACzC,IAAkB,EAClB,YAA2B;QAE3B,YAAY,EAAE,GAAG,CAAC;YAChB,IAAI,EAAE,iBAAiB;YACvB,QAAQ,EAAE,MAAM;YAChB,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE;YACpB,aAAa;YACb,UAAU;YACV,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS;SAC3C,CAAC,CAAC;QAEH,IAAI,IAAI,CAAC,KAAK,KAAK,MAAM,EAAE,CAAC;YAC1B,oDAAoD;YACpD,gEAAgE;YAChE,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAC9B,aAAa,EACb,IAAI,CAAC,gBAAgB,EACrB,IAAI,EACJ,YAAY,CACb,CAAC;YACF,kDAAkD;YAClD,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAC/B,aAAa,EACb,UAAU,EACV,IAAI,EACJ,YAAY,CACb,CAAC;QACJ,CAAC;aAAM,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YACpC,0EAA0E;YAC1E,6EAA6E;YAC7E,oDAAoD;YACpD,gEAAgE;YAChE,2CAA2C;YAC3C,MAAM,oBAAoB,GAAG,kCAAkC,CAC7D,UAAU,EACV,IAAI,CAAC,iBAAiB,EACtB,IAAI,CAAC,gBAAgB,CACtB,CAAC;YACF,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAC9B,aAAa,EACb,oBAAoB,EACpB,IAAI,EACJ,YAAY,CACb,CAAC;YACF,8DAA8D;YAC9D,oCAAoC;YACpC,sCAAsC;YACtC,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAC/B,aAAa,EACb,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,iBAAiB,CAAC,EACpD,IAAI,EACJ,YAAY,CACb,CAAC;QACJ,CAAC;IACH,CAAC;IAED,KAAK;QACH,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC;IACjC,CAAC;IAED,YAAY;IACV;;;;;OAKG;IACH,0BAAkC;IAClC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,aAAuB,EACvB,YAA2B;QAE3B;;;;;;WAMG;QACH,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,EAAE,aAAa,EAAE,YAAY,CAAC,CAAC;QACvE;;;;;;;;;;;;WAYG;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY;QACtC,sDAAsD;QACtD,wEAAwE;QACxE,KAAK,CAAC,WAAW,GAAG,0BAA0B,EAC9C,aAAa,EACb,YAAY,CACb,CAAC;QAEF,IAAI,YAA0B,CAAC;QAE/B,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YACzB,YAAY,GAAG;gBACb,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,OAAO,EACL,MAAM,CAAC,KAAK,KAAK,SAAS;oBACxB,CAAC,CAAC,MAAM,CAAC,YAAY;oBACrB,CAAC,CAAC,IAAI,CAAC,GAAG,CACN,MAAM,CAAC,YAAY,EACnB,MAAM,CAAC,KAAK,GAAG,0BAA0B,CAC1C;gBACP,IAAI,EACF,MAAM,CAAC,IAAI;oBACX,MAAM,CAAC,OAAO,GAAG,CAAC,KAAK,CAAC,WAAW,GAAG,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC;gBACnE,YAAY,EAAE,MAAM,CAAC,YAAY,GAAG,KAAK,CAAC,WAAW;gBACrD,WAAW,EAAE,KAAK,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW;gBACnD,KAAK,EAAE,MAAM,CAAC,KAAK;aACpB,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,YAAY,GAAG;gBACb,WAAW,EAAE,KAAK,CAAC,WAAW;gBAC9B,OAAO,EACL,MAAM,CAAC,KAAK,KAAK,SAAS;oBACxB,CAAC,CAAC,MAAM,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY;oBAC1C,CAAC,CAAC,IAAI,CAAC,GAAG,CACN,MAAM,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,EACxC,MAAM,CAAC,KAAK,GAAG,0BAA0B,CAC1C;gBACP,IAAI,EACF,KAAK,CAAC,IAAI;oBACV,KAAK,CAAC,OAAO,GAAG,CAAC,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC;gBACrE,YAAY,EACV,MAAM,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,GAAG,KAAK,CAAC,WAAW;gBAC9D,WAAW,EAAE,MAAM,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW;gBACnD,KAAK,EAAE,MAAM,CAAC,KAAK;aACpB,CAAC;QACJ,CAAC;QAED,YAAY,EAAE,GAAG,CAAC;YAChB,IAAI,EAAE,WAAW;YACjB,QAAQ,EAAE,MAAM;YAChB,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE;YACpB,aAAa;YACb,0BAA0B;YAC1B,YAAY;YACZ,QAAQ,EAAE,IAAI,CAAC,KAAK;SACrB,CAAC,CAAC;QAEH,OAAO,YAAY,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,OAAO;QACL,MAAM,UAAU,GAAG,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC7C,MAAM,SAAS,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3C,OAAO,GAAG,UAAU,MAAM,SAAS,EAAE,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,YAAY;QAKV,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE;YACpB,IAAI,EAAE,IAAI,CAAC,KAAK;YAChB,MAAM,EAAE,IAAI,CAAC,MAAM;SACpB,CAAC;IACJ,CAAC;CACF;AAED,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF;AAED;;;GAGG;AACH,SAAS,WAAW,CAAC,IAAiB;IACpC,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,YAAY;YACf,OAAO,IAAI,CAAC,IAAI,CAAC;QACnB,KAAK,MAAM;YACT,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;QACxB,KAAK,SAAS;YACZ,OAAO,IAAI,CAAC;QACd,KAAK,QAAQ;YACX,OAAO,IAAI,CAAC;QACd,KAAK,UAAU;YACb,OAAO,UAAU,CAAC;IACtB,CAAC;AACH,CAAC"}
+{"version":3,"file":"planner-join.js","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 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    /**\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        returnedRows:\n          parent.returnedRows * child.returnedRows * child.selectivity,\n        selectivity: parent.selectivity * child.selectivity,\n        limit: parent.limit,\n        fanout: parent.fanout,\n      };\n    }\n\n    planDebugger?.log({\n      type: 'node-cost',\n      nodeType: 'join',\n      node: this.getName(),\n      branchPattern,\n      downstreamChildSelectivity,\n      costEstimate,\n      joinType: this.#type,\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"],"names":[],"mappings":";;AAwBA,SAAS,mCACP,oBACA,kBACA,iBAC+B;AAC/B,MAAI,CAAC,mBAAoB,QAAO;AAEhC,QAAM,aAAa,OAAO,KAAK,gBAAgB;AAC/C,QAAM,YAAY,OAAO,KAAK,eAAe;AAC7C,QAAM,aAAgC,CAAA;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,kBAAkB,GAAG;AAC7D,UAAM,QAAQ,WAAW,QAAQ,GAAG;AACpC,QAAI,UAAU,IAAI;AAGhB,iBAAW,UAAU,KAAK,CAAC,IAAI;AAAA,IACjC;AAAA,EACF;AAEA,SAAO,OAAO,KAAK,UAAU,EAAE,SAAS,IAAI,aAAa;AAC3D;AAgDO,MAAM,YAAY;AAAA,EACd,OAAO;AAAA,EAEP;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACT;AAAA;AAAA;AAAA,EAGA;AAAA,EACS;AAAA,EAET,YACE,QACA,OACA,kBACA,iBACA,WACA,QACA,cAAkC,QAClC;AACA,SAAK,QAAQ;AACb,SAAK,eAAe;AACpB,SAAK,UAAU;AACf,SAAK,SAAS;AACd,SAAK,mBAAmB;AACxB,SAAK,oBAAoB;AACzB,SAAK,aAAa;AAClB,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,UAAU,MAAyB;AACjC,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,IAAI,SAAsB;AACxB,WAAO,KAAK,YAAY,QAAW,gBAAgB;AACnD,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,sBAAwC;AACtC,WAAO;AAAA,EACT;AAAA,EAEA,aAAa,OAA0B;AACrC,QAAI,UAAU,KAAK,QAAQ;AACzB,WAAK,KAAA;AAAA,IACP,OAAO;AACL;AAAA,QACE,UAAU,KAAK;AAAA,QACf;AAAA,MAAA;AAAA,IAEJ;AAAA,EACF;AAAA,EAEA,OAAa;AACX,WAAO,KAAK,UAAU,QAAQ,2BAA2B;AACzD,QAAI,CAAC,KAAK,YAAY;AACpB,YAAM,IAAI;AAAA,QACR;AAAA,MAAA;AAAA,IAEJ;AACA,SAAK,QAAQ;AAAA,EACf;AAAA,EAEA,IAAI,OAA2B;AAC7B,WAAO,KAAK;AAAA,EACd;AAAA,EACA,cAAuB;AACrB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,mBAAyB;AACvB,WAAO,KAAK,UAAU,WAAW,iCAAiC;AAElE,SAAK,OAAO,gCAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,kCAAwC;AACtC,SAAK,QAAQ,gCAAA;AAAA,EACf;AAAA,EAEA,qBACE,eACA,YACA,MACA,cACM;AACN,kBAAc,IAAI;AAAA,MAChB,MAAM;AAAA,MACN,UAAU;AAAA,MACV,MAAM,KAAK,QAAA;AAAA,MACX;AAAA,MACA;AAAA,MACA,MAAM,OAAO,YAAY,IAAI,IAAI;AAAA,IAAA,CAClC;AAED,QAAI,KAAK,UAAU,QAAQ;AAGzB,WAAK,OAAO;AAAA,QACV;AAAA,QACA,KAAK;AAAA,QACL;AAAA,QACA;AAAA,MAAA;AAGF,WAAK,QAAQ;AAAA,QACX;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MAAA;AAAA,IAEJ,WAAW,KAAK,UAAU,WAAW;AAMnC,YAAM,uBAAuB;AAAA,QAC3B;AAAA,QACA,KAAK;AAAA,QACL,KAAK;AAAA,MAAA;AAEP,WAAK,OAAO;AAAA,QACV;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MAAA;AAKF,WAAK,QAAQ;AAAA,QACX;AAAA,QACA,iBAAiB,YAAY,KAAK,iBAAiB;AAAA,QACnD;AAAA,QACA;AAAA,MAAA;AAAA,IAEJ;AAAA,EACF;AAAA,EAEA,QAAc;AACZ,SAAK,QAAQ,KAAK;AAAA,EACpB;AAAA,EAEA,aAUE,4BA0BA,eACA,cACc;AAQd,UAAM,QAAQ,KAAK,OAAO,aAAa,GAAG,eAAe,YAAY;AAErE,UAAM,eAAe,MAAM,OAAO,OAAO,KAAK,KAAK,gBAAgB,CAAC;AAMpE,UAAM,yBACJ,IAAI,KAAK,IAAI,IAAI,MAAM,aAAa,aAAa,MAAM;AAezD,UAAM,SAAS,KAAK,QAAQ;AAAA;AAAA;AAAA,MAG1B,KAAK,UAAU,YACX,IAAI,6BACJ,yBAAyB;AAAA,MAC7B;AAAA,MACA;AAAA,IAAA;AAGF,QAAI;AAEJ,QAAI,KAAK,SAAS,QAAQ;AACxB,qBAAe;AAAA,QACb,aAAa,OAAO;AAAA,QACpB,SACE,OAAO,UAAU,SACb,OAAO,eACP,KAAK;AAAA,UACH,OAAO;AAAA,UACP,+BAA+B,IAC3B,IACA,OAAO,QAAQ;AAAA,QAAA;AAAA,QAE3B,MACE,OAAO,OACP,OAAO,WAAW,MAAM,cAAc,MAAM,OAAO,MAAM;AAAA,QAC3D,cAAc,OAAO,eAAe,MAAM;AAAA,QAC1C,aAAa,MAAM,cAAc,OAAO;AAAA,QACxC,OAAO,OAAO;AAAA,QACd,QAAQ,OAAO;AAAA,MAAA;AAAA,IAEnB,OAAO;AACL,qBAAe;AAAA,QACb,aAAa,MAAM;AAAA,QACnB,SACE,OAAO,UAAU,SACb,OAAO,eAAe,MAAM,eAC5B,KAAK;AAAA,UACH,OAAO,eAAe,MAAM;AAAA,UAC5B,+BAA+B,IAC3B,IACA,OAAO,QAAQ;AAAA,QAAA;AAAA,QAE3B,MACE,MAAM,OACN,MAAM,WAAW,OAAO,cAAc,OAAO,OAAO,OAAO;AAAA,QAC7D,cACE,OAAO,eAAe,MAAM,eAAe,MAAM;AAAA,QACnD,aAAa,OAAO,cAAc,MAAM;AAAA,QACxC,OAAO,OAAO;AAAA,QACd,QAAQ,OAAO;AAAA,MAAA;AAAA,IAEnB;AAEA,kBAAc,IAAI;AAAA,MAChB,MAAM;AAAA,MACN,UAAU;AAAA,MACV,MAAM,KAAK,QAAA;AAAA,MACX;AAAA,MACA;AAAA,MACA;AAAA,MACA,UAAU,KAAK;AAAA,IAAA,CAChB;AAED,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,UAAkB;AAChB,UAAM,aAAa,YAAY,KAAK,OAAO;AAC3C,UAAM,YAAY,YAAY,KAAK,MAAM;AACzC,WAAO,GAAG,UAAU,MAAM,SAAS;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA,EAKA,eAIE;AACA,WAAO;AAAA,MACL,MAAM,KAAK,QAAA;AAAA,MACX,MAAM,KAAK;AAAA,MACX,QAAQ,KAAK;AAAA,IAAA;AAAA,EAEjB;AACF;AAEO,MAAM,6BAA6B,MAAM;AAAA,EAC9C,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAMA,SAAS,YAAY,MAA2B;AAC9C,UAAQ,KAAK,MAAA;AAAA,IACX,KAAK;AACH,aAAO,KAAK;AAAA,IACd,KAAK;AACH,aAAO,KAAK,QAAA;AAAA,IACd,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,EAAA;AAEb;"}