@boboddy/sdk 0.3.1 → 0.4.0

package/dist/push/index.js

@@ -13135,7 +13135,7 @@ class StepExecutions extends HeyApiClient {
 class PipelineDefinitions extends HeyApiClient {
   createPipelineDefinition(options) {
     return (options.client ?? this.client).post({
-      url: "/api/linear-pipeline-definitions",
+      url: "/api/pipeline-definitions",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -13145,7 +13145,7 @@ class PipelineDefinitions extends HeyApiClient {
   }
   upsertPipelineDefinition(options) {
     return (options.client ?? this.client).put({
-      url: "/api/linear-pipeline-definitions",
+      url: "/api/pipeline-definitions",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -13154,14 +13154,14 @@ class PipelineDefinitions extends HeyApiClient {
     });
   }
   archivePipelineDefinition(options) {
-    return (options.client ?? this.client).put({ url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}/archive", ...options });
+    return (options.client ?? this.client).put({ url: "/api/pipeline-definitions/{pipelineDefinitionId}/archive", ...options });
   }
   unarchivePipelineDefinition(options) {
-    return (options.client ?? this.client).put({ url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}/unarchive", ...options });
+    return (options.client ?? this.client).put({ url: "/api/pipeline-definitions/{pipelineDefinitionId}/unarchive", ...options });
   }
   addPipelineStep(options) {
     return (options.client ?? this.client).post({
-      url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}/steps",
+      url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -13170,11 +13170,11 @@ class PipelineDefinitions extends HeyApiClient {
     });
   }
   removePipelineStep(options) {
-    return (options.client ?? this.client).delete({ url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}/steps/{linearPipelineStepDefinitionId}", ...options });
+    return (options.client ?? this.client).delete({ url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps/{pipelineStepDefinitionId}", ...options });
   }
   updatePipelineStep(options) {
     return (options.client ?? this.client).put({
-      url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}/steps/{linearPipelineStepDefinitionId}",
+      url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps/{pipelineStepDefinitionId}",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -13184,7 +13184,7 @@ class PipelineDefinitions extends HeyApiClient {
   }
   setPipelineStepAdvancementPolicy(options) {
     return (options.client ?? this.client).put({
-      url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}/steps/{linearPipelineStepDefinitionId}/advancement-policy",
+      url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps/{pipelineStepDefinitionId}/advancement-policy",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -13193,20 +13193,20 @@ class PipelineDefinitions extends HeyApiClient {
     });
   }
   getPipelineDefinition(options) {
-    return (options.client ?? this.client).get({ url: "/api/linear-pipeline-definitions/{linearPipelineDefinitionId}", ...options });
+    return (options.client ?? this.client).get({ url: "/api/pipeline-definitions/{pipelineDefinitionId}", ...options });
   }
   listPipelineDefinitions(options) {
-    return (options.client ?? this.client).get({ url: "/api/projects/{projectId}/linear-pipeline-definitions", ...options });
+    return (options.client ?? this.client).get({ url: "/api/projects/{projectId}/pipeline-definitions", ...options });
   }
 }
 
 class PipelineExecutions extends HeyApiClient {
   listPipelineExecutions(options) {
-    return (options.client ?? this.client).get({ url: "/api/linear-pipeline-executions", ...options });
+    return (options.client ?? this.client).get({ url: "/api/pipeline-executions", ...options });
   }
   createPipelineExecution(options) {
     return (options.client ?? this.client).post({
-      url: "/api/linear-pipeline-executions",
+      url: "/api/pipeline-executions",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -13215,17 +13215,17 @@ class PipelineExecutions extends HeyApiClient {
     });
   }
   startPipelineExecution(options) {
-    return (options.client ?? this.client).put({ url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/start", ...options });
+    return (options.client ?? this.client).put({ url: "/api/pipeline-executions/{pipelineExecutionId}/start", ...options });
   }
   queueFirstPipelineStepRun(options) {
-    return (options.client ?? this.client).post({ url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/step-runs/first", ...options });
+    return (options.client ?? this.client).post({ url: "/api/pipeline-executions/{pipelineExecutionId}/step-runs/first", ...options });
   }
   markPipelineStepRunRunning(options) {
-    return (options.client ?? this.client).put({ url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/step-runs/{linearPipelineStepRunId}/running", ...options });
+    return (options.client ?? this.client).put({ url: "/api/pipeline-executions/{pipelineExecutionId}/step-runs/{pipelineStepRunId}/running", ...options });
   }
   applyPipelineStepResult(options) {
     return (options.client ?? this.client).post({
-      url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/step-runs/{linearPipelineStepRunId}/results",
+      url: "/api/pipeline-executions/{pipelineExecutionId}/step-runs/{pipelineStepRunId}/results",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -13235,7 +13235,17 @@ class PipelineExecutions extends HeyApiClient {
   }
   acceptPipelineStepRun(options) {
     return (options.client ?? this.client).post({
-      url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/step-runs/{linearPipelineStepRunId}/accept",
+      url: "/api/pipeline-executions/{pipelineExecutionId}/step-runs/{pipelineStepRunId}/accept",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  acceptPipelineCohort(options) {
+    return (options.client ?? this.client).post({
+      url: "/api/pipeline-executions/{pipelineExecutionId}/cohorts/{originNodeDefinitionId}/accept",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -13245,7 +13255,7 @@ class PipelineExecutions extends HeyApiClient {
   }
   rerunPipelineExecution(options) {
     return (options.client ?? this.client).post({
-      url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/rerun",
+      url: "/api/pipeline-executions/{pipelineExecutionId}/rerun",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -13254,19 +13264,22 @@ class PipelineExecutions extends HeyApiClient {
     });
   }
   cancelPipelineExecution(options) {
-    return (options.client ?? this.client).put({ url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}/cancel", ...options });
+    return (options.client ?? this.client).put({ url: "/api/pipeline-executions/{pipelineExecutionId}/cancel", ...options });
   }
   getPipelineExecution(options) {
-    return (options.client ?? this.client).get({ url: "/api/linear-pipeline-executions/{linearPipelineExecutionId}", ...options });
+    return (options.client ?? this.client).get({ url: "/api/pipeline-executions/{pipelineExecutionId}", ...options });
+  }
+  getPipelineExecutionRoutedChain(options) {
+    return (options.client ?? this.client).get({ url: "/api/pipeline-executions/{pipelineExecutionId}/routed-chain", ...options });
   }
   countPipelineExecutionsByPipeline(options) {
-    return (options.client ?? this.client).get({ url: "/api/linear-pipeline-executions/counts/by-pipeline", ...options });
+    return (options.client ?? this.client).get({ url: "/api/pipeline-executions/counts/by-pipeline", ...options });
   }
   listPipelineDefinitionStepRollups(options) {
-    return (options.client ?? this.client).get({ url: "/api/linear-pipeline-executions/step-rollups/by-definition/{linearPipelineDefinitionId}", ...options });
+    return (options.client ?? this.client).get({ url: "/api/pipeline-executions/step-rollups/by-definition/{pipelineDefinitionId}", ...options });
   }
   listPipelineDefinitionStepRuns(options) {
-    return (options.client ?? this.client).get({ url: "/api/linear-pipeline-executions/step-runs/by-definition/{linearPipelineDefinitionId}", ...options });
+    return (options.client ?? this.client).get({ url: "/api/pipeline-executions/step-runs/by-definition/{pipelineDefinitionId}", ...options });
   }
 }
 
@@ -16205,6 +16218,140 @@ function extractInlineComputedSignals(policy) {
   return [...byKey.values()];
 }
 
+// src/definitions/advancement-policies/cohort-advancement-policy.ts
+var cohortAdvancementEventTypeValues = ["continue", "block"];
+function serializeCohortCondition(condition) {
+  if (condition._tag === "signal") {
+    return {
+      fact: typeof condition.signal === "string" ? condition.signal : condition.signal.key,
+      operator: condition.operator,
+      value: condition.value
+    };
+  }
+  if (condition._tag === "all") {
+    return { all: condition.conditions.map(serializeCohortCondition) };
+  }
+  return { any: condition.conditions.map(serializeCohortCondition) };
+}
+function serializeCohortRule(rule) {
+  return {
+    conditions: { [rule.mode]: rule.conditions.map(serializeCohortCondition) },
+    event: {
+      type: rule.outcome,
+      ...rule.outcomeJson ? { params: rule.outcomeJson } : {}
+    }
+  };
+}
+function serializeCohortAdvancementPolicy(policy) {
+  if (!policy) {
+    return { rules: [], defaultEventType: "continue", defaultEventParamsJson: null };
+  }
+  return {
+    rules: (policy.rules ?? []).map(serializeCohortRule),
+    defaultEventType: policy.default,
+    defaultEventParamsJson: policy.defaultParamsJson ?? null
+  };
+}
+function visitCohortSignalConditions(conditions, visit) {
+  for (const c of conditions) {
+    if (c._tag === "signal") {
+      visit(c);
+    } else {
+      visitCohortSignalConditions(c.conditions, visit);
+    }
+  }
+}
+function isSameStepSignalsListDefinition(a, b) {
+  return JSON.stringify(a.ops) === JSON.stringify(b.ops) && JSON.stringify(a.reducer) === JSON.stringify(b.reducer);
+}
+function extractInlineStepSignalsListDefinitions(policy) {
+  if (!policy?.rules)
+    return [];
+  const byKey = new Map;
+  for (const rule of policy.rules) {
+    visitCohortSignalConditions(rule.conditions, (cond) => {
+      if (typeof cond.signal === "string")
+        return;
+      const inline = cond.signal;
+      const def = {
+        key: inline.key,
+        ops: inline.ops,
+        reducer: inline.reducer
+      };
+      const existing = byKey.get(def.key);
+      if (existing) {
+        if (!isSameStepSignalsListDefinition(existing, def)) {
+          throw new Error(`Conflicting inline stepSignalsList definitions for key "${def.key}"`);
+        }
+        return;
+      }
+      byKey.set(def.key, def);
+    });
+  }
+  return [...byKey.values()];
+}
+
+// src/definitions/pipelines/chain-graph.ts
+function tryOrderChainNodeDefinitions(nodeDefinitions, dependencyEdges) {
+  const nodesByKey = new Map;
+  for (const nodeDefinition of nodeDefinitions) {
+    nodesByKey.set(nodeDefinition.nodeKey, nodeDefinition);
+  }
+  const outgoing = new Map;
+  const incomingCount = new Map;
+  for (const nodeDefinition of nodeDefinitions) {
+    incomingCount.set(nodeDefinition.nodeKey, 0);
+  }
+  for (const edge of dependencyEdges) {
+    if (!nodesByKey.has(edge.fromNodeKey) || !nodesByKey.has(edge.toNodeKey)) {
+      return null;
+    }
+    if (outgoing.has(edge.fromNodeKey))
+      return null;
+    outgoing.set(edge.fromNodeKey, edge.toNodeKey);
+    incomingCount.set(edge.toNodeKey, (incomingCount.get(edge.toNodeKey) ?? 0) + 1);
+  }
+  for (const count of incomingCount.values()) {
+    if (count > 1)
+      return null;
+  }
+  if (nodeDefinitions.length === 0)
+    return [];
+  const roots = nodeDefinitions.filter((nodeDefinition) => (incomingCount.get(nodeDefinition.nodeKey) ?? 0) === 0);
+  if (roots.length !== 1)
+    return null;
+  const rootNode = roots[0];
+  if (!rootNode)
+    return null;
+  const ordered = [];
+  const visited = new Set;
+  let currentKey = rootNode.nodeKey;
+  while (currentKey !== undefined) {
+    if (visited.has(currentKey))
+      return null;
+    visited.add(currentKey);
+    const currentNode = nodesByKey.get(currentKey);
+    if (!currentNode)
+      return null;
+    ordered.push(currentNode);
+    currentKey = outgoing.get(currentKey);
+  }
+  if (ordered.length !== nodeDefinitions.length)
+    return null;
+  return ordered;
+}
+function buildChainDependencyEdges(orderedNodes) {
+  const dependencyEdges = [];
+  for (let index = 0;index < orderedNodes.length - 1; index += 1) {
+    const from = orderedNodes[index];
+    const to = orderedNodes[index + 1];
+    if (!from || !to)
+      continue;
+    dependencyEdges.push({ fromNodeKey: from.nodeKey, toNodeKey: to.nodeKey });
+  }
+  return dependencyEdges;
+}
+
 // src/definitions/pipelines/define-pipeline.ts
 function serializeBinding(binding) {
   if (binding.source === "pipeline_input") {
@@ -16223,15 +16370,42 @@ function serializeBinding(binding) {
   if (binding.source === "literal") {
     return { source: "literal", value: binding.value };
   }
+  if (binding.source === "signals_list") {
+    return { source: "signals_list", stepKey: binding.fanOutStep.key };
+  }
+  if (binding.source === "fan_out_item") {
+    return { source: "fan_out_item" };
+  }
   return { source: "step_output", stepKey: binding.step.key };
 }
+var isFanOutConfig = (node) => ("nodeType" in node) && node.nodeType === "fanOut";
+var isCohortGateConfig = (node) => ("nodeType" in node) && node.nodeType === "cohortGate";
+function serializeInputBindings(input, pipelineInputBindings) {
+  const autoBindings = {
+    workItemTitle: { source: "work_item", field: "title" },
+    workItemDescription: { source: "work_item", field: "description" }
+  };
+  const pipelineBindings = {};
+  for (const [key, binding] of Object.entries(pipelineInputBindings ?? {})) {
+    pipelineBindings[key] = serializeBinding(binding);
+  }
+  const explicitBindings = Object.fromEntries(Object.entries(input ?? {}).filter((entry) => entry[1] !== undefined).map(([key, binding]) => [key, serializeBinding(binding)]));
+  return { ...autoBindings, ...pipelineBindings, ...explicitBindings };
+}
 function buildPipelineSpec(config2) {
-  const steps = config2.steps;
+  const nodes = config2.nodes;
   const stepDefMap = new Map;
-  for (const stepConfig of steps) {
-    const mapKey = `${stepConfig.step.key}@v${String(stepConfig.step.version)}`;
+  const registerStepDef = (step) => {
+    const mapKey = `${step.key}@v${String(step.version)}`;
     if (!stepDefMap.has(mapKey)) {
-      stepDefMap.set(mapKey, stepConfig.step);
+      stepDefMap.set(mapKey, step);
+    }
+  };
+  for (const node of nodes) {
+    if (isFanOutConfig(node)) {
+      registerStepDef(node.fanOutStep);
+    } else if (!isCohortGateConfig(node)) {
+      registerStepDef(node.step);
     }
   }
   let inputSchemaJson = null;
@@ -16242,6 +16416,46 @@ function buildPipelineSpec(config2) {
       inputSchemaJson = null;
     }
   }
+  const nodeDefinitions = nodes.map((node) => {
+    if (isCohortGateConfig(node)) {
+      const serializedPolicy = serializeCohortAdvancementPolicy(node.advanceAll);
+      const inlineStepSignalsListDefinitions = extractInlineStepSignalsListDefinitions(node.advanceAll);
+      return {
+        nodeKey: node.nodeKey,
+        kind: "cohortGate",
+        advanceAllPolicyDefinition: serializedPolicy,
+        stepSignalsListDefinitions: [
+          ...inlineStepSignalsListDefinitions,
+          ...node.stepSignalsListDefinitions ?? []
+        ]
+      };
+    }
+    if (isFanOutConfig(node)) {
+      return {
+        nodeKey: node.fanOutStep.key,
+        kind: "fanOut",
+        stepKey: node.fanOutStep.key,
+        stepName: node.fanOutStep.name,
+        stepDescription: node.fanOutStep.description,
+        inputBindingsJson: serializeInputBindings(node.input, config2.pipelineInputBindings),
+        timeoutSeconds: node.timeout ?? null,
+        overSignalKey: node.overSignalKey,
+        advanceEachPolicyDefinition: serializeCohortAdvancementPolicy(node.advanceEach)
+      };
+    }
+    return {
+      nodeKey: node.step.key,
+      kind: "step",
+      stepKey: node.step.key,
+      stepName: node.step.name,
+      stepDescription: node.step.description,
+      inputBindingsJson: serializeInputBindings(node.input, config2.pipelineInputBindings),
+      timeoutSeconds: node.timeout ?? null,
+      advancementPolicyDefinition: serializeAdvancementPolicy(node.advancement),
+      computedSignalDefinitions: extractInlineComputedSignals(node.advancement)
+    };
+  });
+  const dependencyEdges = buildChainDependencyEdges(nodeDefinitions);
   return {
     key: config2.key,
     name: config2.name,
@@ -16250,31 +16464,8 @@ function buildPipelineSpec(config2) {
     status: config2.status ?? "active",
     inputSchemaJson,
     _stepDefinitions: [...stepDefMap.values()],
-    steps: steps.map((stepConfig, index) => {
-      const autoBindings = {
-        workItemTitle: { source: "work_item", field: "title" },
-        workItemDescription: { source: "work_item", field: "description" }
-      };
-      const pipelineBindings = {};
-      for (const [key, binding] of Object.entries(config2.pipelineInputBindings ?? {})) {
-        pipelineBindings[key] = serializeBinding(binding);
-      }
-      const explicitStepBindings = Object.fromEntries(Object.entries(stepConfig.input ?? {}).filter((entry) => entry[1] !== undefined).map(([key, binding]) => [key, serializeBinding(binding)]));
-      return {
-        stepKey: stepConfig.step.key,
-        stepName: stepConfig.step.name,
-        stepDescription: stepConfig.step.description,
-        position: index + 1,
-        inputBindingsJson: {
-          ...autoBindings,
-          ...pipelineBindings,
-          ...explicitStepBindings
-        },
-        timeoutSeconds: stepConfig.timeout ?? null,
-        advancementPolicyDefinition: serializeAdvancementPolicy(stepConfig.advancement),
-        computedSignalDefinitions: extractInlineComputedSignals(stepConfig.advancement)
-      };
-    })
+    nodeDefinitions,
+    dependencyEdges
   };
 }
 // src/definitions/advancement-policies/fluent-rules.ts
@@ -16445,7 +16636,10 @@ function makeStepInputCtx(inputSchema) {
     output(step) {
       return { source: "step_output", step };
     },
-    literal: literal2
+    literal: literal2,
+    signalsList(fanOutStep) {
+      return { source: "signals_list", fanOutStep };
+    }
   };
 }
 function literal2(value) {
@@ -16490,61 +16684,247 @@ function mergeStepBindings(pipelineBindings, explicitBindings) {
   return Object.keys(merged).length > 0 ? merged : undefined;
 }
 
-// src/definitions/pipelines/builder.ts
-class PipelineStepAdvancementBuilder {
-  inputSchema;
-  meta;
-  steps;
-  pipelineInputBindings;
-  pipelineStepInputBindings;
-  constructor(inputSchema, meta3, steps, pipelineInputBindings = {}, pipelineStepInputBindings = {}) {
-    this.inputSchema = inputSchema;
-    this.meta = meta3;
-    this.steps = steps;
-    this.pipelineInputBindings = pipelineInputBindings;
-    this.pipelineStepInputBindings = pipelineStepInputBindings;
-  }
-  advance(callback) {
-    const last = this.steps.at(-1);
-    if (!last)
-      throw new Error("Internal error: no steps available");
-    const ctx = makeAdvanceCtx();
-    const result = callback(ctx);
-    const policy = {
-      defaultOutcome: result.default,
-      ...result.rules !== undefined ? { rules: result.rules } : {}
+// src/definitions/advancement-policies/cohort-fluent-rules.ts
+var LEAF_BRAND2 = Symbol("boboddy.cohortRule.leaf");
+var GROUP_BRAND2 = Symbol("boboddy.cohortRule.group");
+function createCohortSignalRef(signal2) {
+  const leaf = (operator, value) => {
+    const condition = {
+      _tag: "signal",
+      signal: signal2,
+      operator,
+      value
     };
-    last.advancement = policy;
-    return new PipelineStepBuilder(this.inputSchema, this.meta, this.steps, this.pipelineInputBindings, this.pipelineStepInputBindings);
-  }
+    return {
+      [LEAF_BRAND2]: condition,
+      then(outcome, paramsJson) {
+        return {
+          _tag: "rule",
+          mode: "all",
+          conditions: [condition],
+          outcome,
+          ...paramsJson ? { outcomeJson: paramsJson } : {}
+        };
+      }
+    };
+  };
+  return {
+    eq: (v) => leaf("equal", v),
+    ne: (v) => leaf("notEqual", v),
+    gt: (v) => leaf("greaterThan", v),
+    gte: (v) => leaf("greaterThanInclusive", v),
+    lt: (v) => leaf("lessThan", v),
+    lte: (v) => leaf("lessThanInclusive", v),
+    in: (vs) => leaf("in", vs),
+    notIn: (vs) => leaf("notIn", vs),
+    contains: (v) => leaf("contains", v),
+    doesNotContain: (v) => leaf("doesNotContain", v)
+  };
+}
+function createCohortLeafFromCondition(condition) {
+  return {
+    [LEAF_BRAND2]: condition,
+    then(outcome, paramsJson) {
+      return {
+        _tag: "rule",
+        mode: "all",
+        conditions: [condition],
+        outcome,
+        ...paramsJson ? { outcomeJson: paramsJson } : {}
+      };
+    }
+  };
+}
+function extractCohortCondition(ref) {
+  if (LEAF_BRAND2 in ref)
+    return ref[LEAF_BRAND2];
+  const group = ref[GROUP_BRAND2];
+  return group.mode === "all" ? { _tag: "all", conditions: group.conditions } : { _tag: "any", conditions: group.conditions };
+}
+function createCohortGroup(mode, refs) {
+  const conditions = refs.map(extractCohortCondition);
+  return {
+    [GROUP_BRAND2]: { mode, conditions },
+    then(outcome, paramsJson) {
+      return {
+        _tag: "rule",
+        mode,
+        conditions,
+        outcome,
+        ...paramsJson ? { outcomeJson: paramsJson } : {}
+      };
+    }
+  };
+}
+function makeKeyedCohortSignalRef(key) {
+  return createCohortSignalRef(key);
+}
+function makeAdvanceEachCtx() {
+  return {
+    signal: (key) => makeKeyedCohortSignalRef(key),
+    stepSignals: new Proxy({}, {
+      get(_, key) {
+        if (typeof key === "string")
+          return makeKeyedCohortSignalRef(key);
+        return;
+      }
+    }),
+    all: (...refs) => createCohortGroup("all", refs),
+    any: (...refs) => createCohortGroup("any", refs)
+  };
+}
+var branchOutcomeValues = [
+  "continue",
+  "block",
+  "error",
+  "abandoned"
+];
+function summarizeTransformOp(op) {
+  if (op.op === "filter") {
+    return `filter_${op.operator}_${JSON.stringify(op.value)}`;
+  }
+  if (op.op === "sortBy") {
+    return `sortBy_${op.direction}`;
+  }
+  return "unique";
+}
+function deriveStepSignalsListKey(ops, reducer) {
+  const pluck = ops.find((op) => op.op === "pluck");
+  const base = `${reducer.op}_${pluck?.signalKey ?? "value"}`;
+  const extras = ops.filter((op) => op.op !== "pluck").map(summarizeTransformOp);
+  const reducerExtra = reducer.op === "join" ? `sep_${reducer.separator}` : null;
+  const suffixParts = [...extras, ...reducerExtra ? [reducerExtra] : []];
+  return suffixParts.length > 0 ? `${base}_${suffixParts.join("_")}` : base;
+}
+function createStepSignalsListBuilder(ops) {
+  const withOp = (op) => createStepSignalsListBuilder([...ops, op]);
+  const reduce = (reducer) => {
+    const token = {
+      _tag: "step_signals_list",
+      key: deriveStepSignalsListKey(ops, reducer),
+      ops: [...ops],
+      reducer
+    };
+    return createCohortSignalRef(token);
+  };
+  return {
+    filter: (operator, value) => withOp({ op: "filter", operator, value }),
+    sortBy: (direction = "asc") => withOp({ op: "sortBy", direction }),
+    unique: () => withOp({ op: "unique" }),
+    count: () => reduce({ op: "count" }),
+    sum: () => reduce({ op: "sum" }),
+    avg: () => reduce({ op: "avg" }),
+    min: () => reduce({ op: "min" }),
+    max: () => reduce({ op: "max" }),
+    booleanAll: () => reduce({ op: "booleanAll" }),
+    booleanAny: () => reduce({ op: "booleanAny" }),
+    join: (separator = ",") => reduce({ op: "join", separator }),
+    first: () => reduce({ op: "first" }),
+    last: () => reduce({ op: "last" })
+  };
+}
+function makeAdvanceAllCtx() {
+  return {
+    branchOutcomes: {
+      total: () => createCohortSignalRef("branchCount"),
+      count: (outcome) => createCohortSignalRef(`${outcome}Count`),
+      every: (outcome) => createCohortLeafFromCondition({
+        _tag: "signal",
+        signal: `${outcome}Count`,
+        operator: "equal",
+        value: { fact: "branchCount" }
+      }),
+      some: (outcome) => createCohortLeafFromCondition({
+        _tag: "signal",
+        signal: `${outcome}Count`,
+        operator: "greaterThan",
+        value: 0
+      })
+    },
+    stepSignalsList: {
+      pluck: (signalKey) => createStepSignalsListBuilder([{ op: "pluck", signalKey }])
+    },
+    all: (...refs) => createCohortGroup("all", refs),
+    any: (...refs) => createCohortGroup("any", refs)
+  };
+}
+
+// src/definitions/pipelines/fan-out-builder.ts
+function beginFanOut(inputSchema, meta3, nodes, pipelineInputBindings, pipelineStepInputBindings, step, config2) {
+  const baseCtx = makeStepInputCtx(inputSchema);
+  const ctx = {
+    ...baseCtx,
+    item: { source: "fan_out_item" }
+  };
+  const rawInput = config2.input ? config2.input(ctx) : {};
+  const input = mergeStepBindings(pipelineStepInputBindings, normalizeInputMapping(rawInput));
+  const fanOutNodeConfig = {
+    nodeType: "fanOut",
+    fanOutStep: step,
+    overSignalKey: config2.over,
+    ...input ? { input } : {},
+    ...config2.timeout !== undefined ? { timeout: config2.timeout } : {}
+  };
+  const advanceEachCtx = makeAdvanceEachCtx();
+  const advanceEachResult = config2.advance(advanceEachCtx);
+  const advanceEachPolicy = {
+    default: advanceEachResult.default,
+    ...advanceEachResult.rules !== undefined ? { rules: advanceEachResult.rules } : {}
+  };
+  fanOutNodeConfig.advanceEach = advanceEachPolicy;
+  const cohortGateNodeConfig = {
+    nodeType: "cohortGate",
+    nodeKey: `${step.key}__cohortGate`
+  };
+  const advanceAllCtx = makeAdvanceAllCtx();
+  const advanceAllResult = config2.advanceAll(advanceAllCtx);
+  const advanceAllPolicy = {
+    default: advanceAllResult.default,
+    ...advanceAllResult.rules !== undefined ? { rules: advanceAllResult.rules } : {}
+  };
+  cohortGateNodeConfig.advanceAll = advanceAllPolicy;
+  nodes.push(fanOutNodeConfig, cohortGateNodeConfig);
+  return new PipelineStepBuilder(inputSchema, meta3, nodes, pipelineInputBindings, pipelineStepInputBindings);
+}
+
+// src/definitions/pipelines/builder.ts
+function pushStep(inputSchema, meta3, nodes, pipelineInputBindings, pipelineStepInputBindings, step, rawOptions) {
+  const options = rawOptions;
+  const ctx = makeStepInputCtx(inputSchema);
+  const rawInput = options.input ? options.input(ctx) : {};
+  const input = mergeStepBindings(pipelineStepInputBindings, normalizeInputMapping(rawInput));
+  const stepConfig = { step, input };
+  if (options.timeout !== undefined)
+    stepConfig.timeout = options.timeout;
+  const advanceCtx = makeAdvanceCtx();
+  const result = options.advance(advanceCtx);
+  const policy = {
+    defaultOutcome: result.default,
+    ...result.rules !== undefined ? { rules: result.rules } : {}
+  };
+  stepConfig.advancement = policy;
+  nodes.push(stepConfig);
+  return new PipelineStepBuilder(inputSchema, meta3, nodes, pipelineInputBindings, pipelineStepInputBindings);
 }
 
 class PipelineStepBuilder {
   inputSchema;
   meta;
-  steps;
+  nodes;
   pipelineInputBindings;
   pipelineStepInputBindings;
-  constructor(inputSchema, meta3, steps, pipelineInputBindings = {}, pipelineStepInputBindings = {}) {
+  constructor(inputSchema, meta3, nodes, pipelineInputBindings = {}, pipelineStepInputBindings = {}) {
     this.inputSchema = inputSchema;
     this.meta = meta3;
-    this.steps = steps;
+    this.nodes = nodes;
     this.pipelineInputBindings = pipelineInputBindings;
     this.pipelineStepInputBindings = pipelineStepInputBindings;
   }
-  step(step, mapper, configFn) {
-    const ctx = makeStepInputCtx(this.inputSchema);
-    const rawInput = mapper ? mapper(ctx) : {};
-    const input = mergeStepBindings(this.pipelineStepInputBindings, normalizeInputMapping(rawInput));
-    const stepConfig = { step, input };
-    if (configFn) {
-      const cfg = {};
-      configFn(cfg);
-      if (cfg.timeout !== undefined)
-        stepConfig.timeout = cfg.timeout;
-    }
-    this.steps.push(stepConfig);
-    return new PipelineStepAdvancementBuilder(this.inputSchema, this.meta, this.steps, this.pipelineInputBindings, this.pipelineStepInputBindings);
+  step(step, options) {
+    return pushStep(this.inputSchema, this.meta, this.nodes, this.pipelineInputBindings, this.pipelineStepInputBindings, step, options);
+  }
+  fanOutStep(step, config2) {
+    return beginFanOut(this.inputSchema, this.meta, this.nodes, this.pipelineInputBindings, this.pipelineStepInputBindings, step, config2);
   }
   build() {
     const config2 = {
@@ -16554,7 +16934,7 @@ class PipelineStepBuilder {
       version: this.meta.version,
       status: this.meta.status,
       input: this.inputSchema,
-      steps: this.steps,
+      nodes: this.nodes,
       pipelineInputBindings: this.pipelineInputBindings
     };
     return buildPipelineSpec(config2);
@@ -16564,7 +16944,7 @@ class PipelineStepBuilder {
 class PipelineBuilder {
   inputSchema;
   meta;
-  steps = [];
+  nodes = [];
   pipelineInputBindings;
   pipelineStepInputBindings;
   constructor(meta3) {
@@ -16589,19 +16969,8 @@ class PipelineBuilder {
     }
     this.pipelineStepInputBindings = resolveAdditionalStepInputBindings("additionalStepInput", additionalStepInput);
   }
-  step(step, mapper, configFn) {
-    const ctx = makeStepInputCtx(this.inputSchema);
-    const rawInput = mapper ? mapper(ctx) : {};
-    const input = mergeStepBindings(this.pipelineStepInputBindings, normalizeInputMapping(rawInput));
-    const stepConfig = { step, input };
-    if (configFn) {
-      const cfg = {};
-      configFn(cfg);
-      if (cfg.timeout !== undefined)
-        stepConfig.timeout = cfg.timeout;
-    }
-    this.steps.push(stepConfig);
-    return new PipelineStepAdvancementBuilder(this.inputSchema, this.meta, this.steps, this.pipelineInputBindings, this.pipelineStepInputBindings);
+  step(step, options) {
+    return pushStep(this.inputSchema, this.meta, this.nodes, this.pipelineInputBindings, this.pipelineStepInputBindings, step, options);
   }
 }
 function pipeline(meta3) {
@@ -16631,23 +17000,35 @@ var buildPipelineDefinitionsClient = (pipelineDefinitions) => {
           stepDefMap.set(s.key, s);
         }
       }
-      const stepDefinitions = spec.steps.map((step) => {
-        const stepDef = stepDefMap.get(step.stepKey);
+      const nonStepNode = spec.nodeDefinitions.find((node) => node.kind !== "step");
+      if (nonStepNode) {
+        throw new Error(`Pipeline "${spec.key}" contains a "${nonStepNode.kind}" node ("${nonStepNode.nodeKey}"), ` + `but fan-out pipelines cannot be pushed via the current wire contract yet. ` + `Only "step"-only (chain) pipelines can be pushed with \`upsertFromSpec\` today.`);
+      }
+      const ordered = tryOrderChainNodeDefinitions(spec.nodeDefinitions, spec.dependencyEdges);
+      if (ordered === null) {
+        throw new Error(`Pipeline "${spec.key}" has a malformed step graph: its node and ` + `dependency-edge definitions do not form a single connected, ` + `acyclic chain. This should not happen from the \`pipeline()\` ` + `builder \u2014 check for hand-edited or generated pipeline specs.`);
+      }
+      const stepDefinitions = ordered.map((node, index) => {
+        const stepKey = node.stepKey;
+        if (!stepKey) {
+          throw new Error(`Node "${node.nodeKey}" in pipeline "${spec.key}" has no stepKey.`);
+        }
+        const stepDef = stepDefMap.get(stepKey);
         if (!stepDef) {
-          throw new Error(`Step "${step.stepKey}" referenced in pipeline "${spec.key}" was not found on the server. ` + `Run \`boboddy steps push\` first to push your step definitions.`);
+          throw new Error(`Step "${stepKey}" referenced in pipeline "${spec.key}" was not found on the server. ` + `Run \`boboddy steps push\` first to push your step definitions.`);
         }
         return {
           stepDefinitionId: stepDef.id,
           stepDefinitionVersion: stepDef.version,
-          key: step.stepKey,
-          name: step.stepName,
-          description: step.stepDescription,
-          position: step.position,
-          inputBindingsJson: step.inputBindingsJson,
-          timeoutSeconds: step.timeoutSeconds,
+          key: node.nodeKey,
+          name: node.stepName ?? "",
+          description: node.stepDescription ?? null,
+          position: index + 1,
+          inputBindingsJson: node.inputBindingsJson ?? {},
+          timeoutSeconds: node.timeoutSeconds ?? null,
           retryPolicyJson: null,
-          advancementPolicyDefinition: step.advancementPolicyDefinition,
-          computedSignalDefinitions: step.computedSignalDefinitions
+          advancementPolicyDefinition: node.advancementPolicyDefinition,
+          computedSignalDefinitions: node.computedSignalDefinitions ?? []
         };
       });
       const body = {
@@ -16682,7 +17063,12 @@ function makeLeaf(fact, path, operator, value) {
   return {
     _condition: condition,
     then(outcome) {
-      return { _tag: "assignment_rule", conditions: [condition], mode: "all", outcome };
+      return {
+        _tag: "assignment_rule",
+        conditions: [condition],
+        mode: "all",
+        outcome
+      };
     }
   };
 }
@@ -16701,7 +17087,7 @@ function makeFieldRef(fact, path) {
   };
 }
 function makeAssign(pipeline2) {
-  if (typeof pipeline2 !== "object" || typeof pipeline2["key"] !== "string" || !Array.isArray(pipeline2["steps"])) {
+  if (typeof pipeline2 !== "object" || typeof pipeline2["key"] !== "string" || !Array.isArray(pipeline2["nodeDefinitions"])) {
     throw new Error("assign() requires a pipeline spec produced by pipeline().build(). " + "Pass the default-exported value from a pipeline definition file.");
   }
   return { _tag: "assign", pipeline: pipeline2 };
@@ -16789,7 +17175,7 @@ function serializeDefaultPipelineAssignment(spec) {
     return serializeAssignmentRule(rule);
   });
   return {
-    linearPipelineDefinitionKey: primaryKey,
+    pipelineDefinitionKey: primaryKey,
     rulesJson: { rules: serializedRules },
     defaultEventType: defaultType,
     defaultEventParamsJson: defaultParams,
@@ -17087,6 +17473,8 @@ function checkHealthChecks(steps) {
   return issues;
 }
 function routeTargets(policy) {
+  if (!policy)
+    return [];
   const keys = [];
   if (policy.defaultEventType === "route" && typeof policy.defaultEventParamsJson?.["pipelineKey"] === "string") {
     keys.push(policy.defaultEventParamsJson["pipelineKey"]);
@@ -17105,36 +17493,42 @@ function checkRouteTargets(pipelines, knownPipelineKeys) {
     ...knownPipelineKeys
   ]);
   for (const pipeline2 of pipelines) {
-    for (const step of pipeline2.steps) {
-      for (const target of routeTargets(step.advancementPolicyDefinition)) {
+    for (const node of pipeline2.nodeDefinitions) {
+      for (const target of routeTargets(node.advancementPolicyDefinition)) {
         if (known.has(target))
           continue;
         issues.push({
           check: "route-target",
-          message: `Pipeline "${pipeline2.key}" step "${step.stepKey}" routes to pipeline ` + `"${target}", but no pipeline with that key was found on the server or ` + `in the current push batch. Push the target pipeline first.`
+          message: `Pipeline "${pipeline2.key}" step "${node.stepKey ?? node.nodeKey}" routes to pipeline ` + `"${target}", but no pipeline with that key was found on the server or ` + `in the current push batch. Push the target pipeline first.`
         });
       }
     }
   }
   return issues;
 }
-function executionRanks(steps) {
-  const positions = steps.map((step) => step.position);
-  const usable = positions.every((value) => Number.isInteger(value) && value > 0) && new Set(positions).size === positions.length;
-  const indexes = steps.map((_, index) => index);
-  const ordered = usable ? [...indexes].sort((left, right) => (positions[left] ?? 0) - (positions[right] ?? 0)) : indexes;
+function executionRanks(nodeDefinitions, dependencyEdges) {
+  const indexes = nodeDefinitions.map((_, index) => index);
+  const orderedNodes = tryOrderChainNodeDefinitions(nodeDefinitions, dependencyEdges);
+  if (orderedNodes === null) {
+    return new Map(indexes.map((index, rank) => [index, rank]));
+  }
+  const indexByNodeKey = new Map(nodeDefinitions.map((node, index) => [node.nodeKey, index]));
+  const ordered = orderedNodes.map((node) => indexByNodeKey.get(node.nodeKey) ?? 0);
   return new Map(ordered.map((index, rank) => [index, rank]));
 }
 function bindingSource(binding) {
   if (binding.source === "step_signal") {
-    return { stepKey: binding.stepKey, signalKey: binding.signalKey };
+    return { stepKey: binding.stepKey, signalKey: binding.signalKey, kind: "signal" };
   }
   if (binding.source === "step_output") {
-    return { stepKey: binding.stepKey, signalKey: null };
+    return { stepKey: binding.stepKey, signalKey: null, kind: "output" };
+  }
+  if (binding.source === "signals_list") {
+    return { stepKey: binding.stepKey, signalKey: null, kind: "signals_list" };
   }
   return null;
 }
-function declaredSignalKeys(stepKey, stepsByKey, pipelineSteps) {
+function declaredSignalKeys(stepKey, stepsByKey, pipelineNodeDefinitions) {
   const specs = stepsByKey.get(stepKey);
   if (!specs || specs.length === 0)
     return null;
@@ -17143,10 +17537,10 @@ function declaredSignalKeys(stepKey, stepsByKey, pipelineSteps) {
     for (const signal2 of spec.signalExtractorDefinitions)
       keys.add(signal2.key);
   }
-  for (const step of pipelineSteps) {
-    if (step.stepKey !== stepKey)
+  for (const node of pipelineNodeDefinitions) {
+    if (node.stepKey !== stepKey)
       continue;
-    for (const computed of step.computedSignalDefinitions)
+    for (const computed of node.computedSignalDefinitions ?? [])
       keys.add(computed.key);
   }
   return [...keys];
@@ -17154,18 +17548,18 @@ function declaredSignalKeys(stepKey, stepsByKey, pipelineSteps) {
 function checkSignalBindings(pipelines, stepsByKey) {
   const issues = [];
   for (const pipeline2 of pipelines) {
-    const ranks = executionRanks(pipeline2.steps);
-    const order = [...pipeline2.steps.keys()].sort((left, right) => (ranks.get(left) ?? 0) - (ranks.get(right) ?? 0)).map((index) => pipeline2.steps[index]?.stepKey ?? "");
+    const ranks = executionRanks(pipeline2.nodeDefinitions, pipeline2.dependencyEdges);
+    const order = [...pipeline2.nodeDefinitions.keys()].sort((left, right) => (ranks.get(left) ?? 0) - (ranks.get(right) ?? 0)).map((index) => pipeline2.nodeDefinitions[index]?.stepKey ?? "");
     const orderHint = `Steps in "${pipeline2.key}", in order: ${order.join(" \u2192 ")}.`;
-    pipeline2.steps.forEach((step, index) => {
+    pipeline2.nodeDefinitions.forEach((node, index) => {
       const consumerRank = ranks.get(index) ?? index;
-      const where = `Pipeline "${pipeline2.key}" step "${step.stepKey}"`;
-      for (const [field, binding] of Object.entries(step.inputBindingsJson)) {
+      const where = `Pipeline "${pipeline2.key}" step "${node.stepKey ?? node.nodeKey}"`;
+      for (const [field, binding] of Object.entries(node.inputBindingsJson ?? {})) {
         const source = bindingSource(binding);
         if (!source)
           continue;
-        const what = source.signalKey ? `binds input "${field}" to signal "${source.signalKey}" of step "${source.stepKey}"` : `binds input "${field}" to the output of step "${source.stepKey}"`;
-        const producerRanks = pipeline2.steps.map((candidate, candidateIndex) => candidate.stepKey === source.stepKey ? ranks.get(candidateIndex) ?? candidateIndex : null).filter((rank) => rank !== null);
+        const what = source.kind === "signal" ? `binds input "${field}" to signal "${source.signalKey ?? ""}" of step "${source.stepKey}"` : source.kind === "signals_list" ? `binds input "${field}" to the signals list of fan-out step "${source.stepKey}"` : `binds input "${field}" to the output of step "${source.stepKey}"`;
+        const producerRanks = pipeline2.nodeDefinitions.map((candidate, candidateIndex) => candidate.stepKey === source.stepKey ? ranks.get(candidateIndex) ?? candidateIndex : null).filter((rank) => rank !== null);
         if (producerRanks.length === 0) {
           issues.push({
             check: "signal-binding",
@@ -17182,7 +17576,7 @@ function checkSignalBindings(pipelines, stepsByKey) {
         }
         if (source.signalKey === null)
           continue;
-        const available = declaredSignalKeys(source.stepKey, stepsByKey, pipeline2.steps);
+        const available = declaredSignalKeys(source.stepKey, stepsByKey, pipeline2.nodeDefinitions);
         if (available === null || available.includes(source.signalKey))
           continue;
         issues.push({
@@ -17233,7 +17627,7 @@ function isPipelineDefinitionSpec(value) {
   if (typeof value !== "object" || value === null)
     return false;
   const obj = value;
-  return typeof obj["key"] === "string" && typeof obj["name"] === "string" && typeof obj["version"] === "number" && Array.isArray(obj["steps"]);
+  return typeof obj["key"] === "string" && typeof obj["name"] === "string" && typeof obj["version"] === "number" && Array.isArray(obj["nodeDefinitions"]);
 }
 async function importModule(path) {
   return await import(pathToFileURL(path).href);
@@ -17331,7 +17725,7 @@ async function syncDefaultPipelineAssignment(spec, opts, headers, pipelinesClien
     p.id
   ]));
   const referencedKeys = new Set;
-  referencedKeys.add(serialized.linearPipelineDefinitionKey);
+  referencedKeys.add(serialized.pipelineDefinitionKey);
   for (const rule of serialized.rulesJson.rules) {
     if (rule.event.type === "assign" && typeof rule.event.params?.["pipelineKey"] === "string") {
       referencedKeys.add(rule.event.params["pipelineKey"]);
@@ -17342,9 +17736,9 @@ async function syncDefaultPipelineAssignment(spec, opts, headers, pipelinesClien
       throw new Error(`${DEFAULT_PIPELINE_ASSIGNMENT_FILENAME} references pipeline "${key}", ` + `but no pipeline with that key was found on the server. ` + `Push the pipeline first with \`boboddy pipelines push\`.`);
     }
   }
-  const linearPipelineDefinitionId = pipelineKeyToId.get(serialized.linearPipelineDefinitionKey);
-  if (!linearPipelineDefinitionId) {
-    throw new Error(`Pipeline key "${serialized.linearPipelineDefinitionKey}" was not found on the server.`);
+  const pipelineDefinitionId = pipelineKeyToId.get(serialized.pipelineDefinitionKey);
+  if (!pipelineDefinitionId) {
+    throw new Error(`Pipeline key "${serialized.pipelineDefinitionKey}" was not found on the server.`);
   }
   const resolvedRules = serialized.rulesJson.rules.map((rule) => {
     if (rule.event.type === "assign" && typeof rule.event.params?.["pipelineKey"] === "string") {
@@ -17373,7 +17767,7 @@ async function syncDefaultPipelineAssignment(spec, opts, headers, pipelinesClien
     path: { projectId: opts.projectId },
     body: {
       defaultPipelineAssignment: {
-        linearPipelineDefinitionId,
+        pipelineDefinitionId,
         rulesJson: { rules: resolvedRules },
         defaultEventType: serialized.defaultEventType,
         defaultEventParamsJson: serialized.defaultEventParamsJson,
@@ -17385,7 +17779,7 @@ async function syncDefaultPipelineAssignment(spec, opts, headers, pipelinesClien
   if (result.error) {
     throw new Error(`Failed to update project default pipeline assignment: ${JSON.stringify(result.error)}`);
   }
-  log(`\u2713 default pipeline assignment \u2192 synced (primary pipeline: ${serialized.linearPipelineDefinitionKey})`);
+  log(`\u2713 default pipeline assignment \u2192 synced (primary pipeline: ${serialized.pipelineDefinitionKey})`);
   return true;
 }
 export {