@boboddy/sdk 0.4.3 → 0.5.0

package/dist/push/index.js

@@ -30,7 +30,7 @@ __export(exports_core2, {
   safeDecode: () => safeDecode,
   registry: () => registry,
   regexes: () => exports_regexes,
-  process: () => process,
+  process: () => process2,
   prettifyError: () => prettifyError,
   parseAsync: () => parseAsync,
   parse: () => parse,
@@ -11017,7 +11017,7 @@ function initializeContext(params) {
     external: params?.external ?? undefined
   };
 }
-function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a3;
   const def = schema._zod.def;
   const seen = ctx.seen.get(schema);
@@ -11054,7 +11054,7 @@ function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
     if (parent) {
       if (!result.ref)
         result.ref = parent;
-      process(parent, ctx, params);
+      process2(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
@@ -11337,14 +11337,14 @@ function isTransforming(_schema, _ctx) {
 }
 var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
 var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
@@ -11584,7 +11584,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
   if (typeof maximum === "number")
     json.maxItems = maximum;
   json.type = "array";
-  json.items = process(def.element, ctx, {
+  json.items = process2(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
@@ -11596,7 +11596,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
   json.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json.properties[key] = process(shape[key], ctx, {
+    json.properties[key] = process2(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -11619,7 +11619,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
     if (ctx.io === "output")
       json.additionalProperties = false;
   } else if (def.catchall) {
-    json.additionalProperties = process(def.catchall, ctx, {
+    json.additionalProperties = process2(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -11628,7 +11628,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 var unionProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
-  const options = def.options.map((x, i) => process(x, ctx, {
+  const options = def.options.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
@@ -11640,11 +11640,11 @@ var unionProcessor = (schema, ctx, json, params) => {
 };
 var intersectionProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  const a = process(def.left, ctx, {
+  const a = process2(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
   });
-  const b = process(def.right, ctx, {
+  const b = process2(def.right, ctx, {
     ...params,
     path: [...params.path, "allOf", 1]
   });
@@ -11661,11 +11661,11 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   json.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-  const prefixItems = def.items.map((x, i) => process(x, ctx, {
+  const prefixItems = def.items.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, prefixPath, i]
   }));
-  const rest = def.rest ? process(def.rest, ctx, {
+  const rest = def.rest ? process2(def.rest, ctx, {
     ...params,
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
@@ -11705,7 +11705,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
-    const valueSchema = process(def.valueType, ctx, {
+    const valueSchema = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
@@ -11715,12 +11715,12 @@ var recordProcessor = (schema, ctx, _json, params) => {
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json.propertyNames = process(def.keyType, ctx, {
+      json.propertyNames = process2(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json.additionalProperties = process(def.valueType, ctx, {
+    json.additionalProperties = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -11735,7 +11735,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
 };
 var nullableProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  const inner = process(def.innerType, ctx, params);
+  const inner = process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
@@ -11746,20 +11746,20 @@ var nullableProcessor = (schema, ctx, json, params) => {
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
@@ -11767,7 +11767,7 @@ var prefaultProcessor = (schema, ctx, json, params) => {
 };
 var catchProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   let catchValue;
@@ -11782,32 +11782,32 @@ var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   const inIsTransform = def.in._zod.traits.has("$ZodTransform");
   const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var lazyProcessor = (schema, ctx, _json, params) => {
   const innerType = schema._zod.innerType;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
@@ -11859,7 +11859,7 @@ function toJSONSchema(input, params) {
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
       const [_, schema] = entry;
-      process(schema, ctx2);
+      process2(schema, ctx2);
     }
     const schemas = {};
     const external = {
@@ -11882,7 +11882,7 @@ function toJSONSchema(input, params) {
     return { schemas };
   }
   const ctx = initializeContext({ ...params, processors: allProcessors });
-  process(input, ctx);
+  process2(input, ctx);
   extractDefs(ctx, input);
   return finalize(ctx, input);
 }
@@ -11928,7 +11928,7 @@ class JSONSchemaGenerator {
     });
   }
   process(schema, _params = { path: [], schemaPath: [] }) {
-    return process(schema, this.ctx, _params);
+    return process2(schema, this.ctx, _params);
   }
   emit(schema, _params) {
     if (_params) {
@@ -12080,6 +12080,32 @@ ${feature._promptAddition}` : feature._promptAddition;
   };
   return spec;
 }
+// src/definitions/steps/define-code-step.ts
+function codeStep(config2) {
+  const spec = {
+    key: config2.key,
+    name: config2.name,
+    description: config2.description ?? null,
+    version: config2.version ?? 1,
+    kind: "code",
+    status: config2.status ?? "active",
+    prompt: null,
+    inputSchemaJson: config2.inputSchema ? toJSONSchema(config2.inputSchema) : null,
+    resultSchemaJson: config2.resultSchema ? toJSONSchema(config2.resultSchema) : null,
+    signalExtractorDefinitions: (config2.signals ?? []).map((signal) => ({
+      key: signal.key ?? signal.sourcePath,
+      sourcePath: signal.sourcePath,
+      type: signal.type,
+      required: signal.required ?? true,
+      availableWhenResultStatusIn: signal.availableWhenResultStatusIn ?? null
+    })),
+    opencodeMcpJson: null,
+    opencodePluginJson: null,
+    healthChecksJson: null,
+    entrypoint: { fn: config2.fn }
+  };
+  return spec;
+}
 // src/generated/core/bodySerializer.gen.ts
 var jsonBodySerializer = {
   bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
@@ -13159,29 +13185,6 @@ class PipelineDefinitions extends HeyApiClient {
   unarchivePipelineDefinition(options) {
     return (options.client ?? this.client).put({ url: "/api/pipeline-definitions/{pipelineDefinitionId}/unarchive", ...options });
   }
-  addPipelineStep(options) {
-    return (options.client ?? this.client).post({
-      url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  removePipelineStep(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/pipeline-definitions/{pipelineDefinitionId}/steps/{pipelineStepDefinitionId}",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
   setPipelineStepAdvancementPolicy(options) {
     return (options.client ?? this.client).put({
       url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps/{pipelineStepDefinitionId}/advancement-policy",
@@ -13710,8 +13713,21 @@ var buildStepDefinitionsClient = (stepDefinitions) => {
     },
     upsertFromSpec: async (projectId, spec, options) => {
       const body = {
-        ...spec,
+        key: spec.key,
+        name: spec.name,
+        description: spec.description,
         prompt: spec.prompt ?? "",
+        version: spec.version,
+        kind: spec.kind,
+        entrypointJson: spec.entrypointJson ?? null,
+        executionMode: spec.executionMode,
+        inputSchemaJson: spec.inputSchemaJson,
+        resultSchemaJson: spec.resultSchemaJson,
+        opencodeMcpJson: spec.opencodeMcpJson,
+        opencodePluginJson: spec.opencodePluginJson,
+        healthChecksJson: spec.healthChecksJson,
+        status: spec.status,
+        signalExtractorDefinitions: spec.signalExtractorDefinitions,
         projectId
       };
       const result = await stepDefinitions.upsertStepDefinition({
@@ -16168,10 +16184,19 @@ function any2(conditions, outcome) {
   return { _tag: "rule", mode: "any", conditions, outcome };
 }
 function when(signal2, operator, value, outcome) {
+  const condition = {
+    _tag: "signal",
+    signal: signal2,
+    operator,
+    value
+  };
+  if (outcome === undefined) {
+    return condition;
+  }
   return {
     _tag: "rule",
     mode: "all",
-    conditions: [{ _tag: "signal", signal: signal2, operator, value }],
+    conditions: [condition],
     outcome
   };
 }
@@ -16347,188 +16372,10 @@ function extractInlineStepSignalsListDefinitions(policy) {
   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") {
-    return { source: "pipeline_input", path: binding.path };
-  }
-  if (binding.source === "work_item") {
-    return { source: "work_item", field: binding.field };
-  }
-  if (binding.source === "step_signal") {
-    return {
-      source: "step_signal",
-      stepKey: binding.step.key,
-      signalKey: binding.signalKey
-    };
-  }
-  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 nodes = config2.nodes;
-  const stepDefMap = new Map;
-  const registerStepDef = (step) => {
-    const mapKey = `${step.key}@v${String(step.version)}`;
-    if (!stepDefMap.has(mapKey)) {
-      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;
-  if (config2.input) {
-    try {
-      inputSchemaJson = exports_external.toJSONSchema(config2.input);
-    } catch {
-      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,
-    description: config2.description ?? null,
-    version: config2.version ?? 1,
-    status: config2.status ?? "active",
-    inputSchemaJson,
-    _stepDefinitions: [...stepDefMap.values()],
-    nodeDefinitions,
-    dependencyEdges
-  };
-}
-// src/definitions/advancement-policies/fluent-rules.ts
-var LEAF_BRAND = Symbol.for("boboddy.fluentRule.leaf");
-var GROUP_BRAND = Symbol.for("boboddy.fluentRule.group");
-var SIGNAL_KEY = Symbol.for("boboddy.fluentRule.signalKey");
-function createSignalRef(signal2) {
+// src/definitions/advancement-policies/cohort-fluent-rules.ts
+var LEAF_BRAND = Symbol("boboddy.cohortRule.leaf");
+var GROUP_BRAND = Symbol("boboddy.cohortRule.group");
+function createCohortSignalRef(signal2) {
   const leaf = (operator, value) => {
     const condition = {
       _tag: "signal",
@@ -16538,12 +16385,13 @@ function createSignalRef(signal2) {
     };
     return {
       [LEAF_BRAND]: condition,
-      then(outcome) {
+      then(outcome, paramsJson) {
         return {
           _tag: "rule",
           mode: "all",
           conditions: [condition],
-          outcome
+          outcome,
+          ...paramsJson ? { outcomeJson: paramsJson } : {}
         };
       }
     };
@@ -16561,109 +16409,172 @@ function createSignalRef(signal2) {
     doesNotContain: (v) => leaf("doesNotContain", v)
   };
 }
-function extractCondition(ref) {
+function createCohortLeafFromCondition(condition) {
+  return {
+    [LEAF_BRAND]: condition,
+    then(outcome, paramsJson) {
+      return {
+        _tag: "rule",
+        mode: "all",
+        conditions: [condition],
+        outcome,
+        ...paramsJson ? { outcomeJson: paramsJson } : {}
+      };
+    }
+  };
+}
+function extractCohortCondition(ref) {
   if (LEAF_BRAND in ref)
     return ref[LEAF_BRAND];
   const group = ref[GROUP_BRAND];
   return group.mode === "all" ? { _tag: "all", conditions: group.conditions } : { _tag: "any", conditions: group.conditions };
 }
-function createGroup(mode, refs) {
-  const conditions = refs.map(extractCondition);
+function createCohortGroup(mode, refs) {
+  const conditions = refs.map(extractCohortCondition);
   return {
     [GROUP_BRAND]: { mode, conditions },
-    then(outcome) {
-      return { _tag: "rule", mode, conditions, outcome };
+    then(outcome, paramsJson) {
+      return {
+        _tag: "rule",
+        mode,
+        conditions,
+        outcome,
+        ...paramsJson ? { outcomeJson: paramsJson } : {}
+      };
     }
   };
 }
-function resolveComputedArg(arg) {
-  return arg[SIGNAL_KEY];
-}
-function makeKeyedSignalRef(key) {
-  const ref = createSignalRef(key);
-  return Object.assign(ref, {
-    [SIGNAL_KEY]: key
-  });
+function makeKeyedCohortSignalRef(key) {
+  return createCohortSignalRef(key);
 }
-function makeAdvanceCtx() {
-  const wrapComputed = (token) => createSignalRef(token);
+function makeAdvanceEachCtx() {
   return {
-    signal: (key) => makeKeyedSignalRef(key),
+    signal: (key) => makeKeyedCohortSignalRef(key),
     stepSignals: new Proxy({}, {
       get(_, key) {
         if (typeof key === "string")
-          return makeKeyedSignalRef(key);
+          return makeKeyedCohortSignalRef(key);
         return;
       }
     }),
-    avg: (...args) => wrapComputed(Computed.average(args.map(resolveComputedArg))),
-    weightedAvg: (...args) => wrapComputed(Computed.weightedAverage(args.map(resolveComputedArg))),
-    sum: (...args) => wrapComputed(Computed.sum(args.map(resolveComputedArg))),
-    min: (...args) => wrapComputed(Computed.min(args.map(resolveComputedArg))),
-    max: (...args) => wrapComputed(Computed.max(args.map(resolveComputedArg))),
-    count: (...args) => wrapComputed(Computed.count(args.map(resolveComputedArg))),
-    booleanAny: (...args) => wrapComputed(Computed.booleanAny(args.map(resolveComputedArg))),
-    booleanAll: (...args) => wrapComputed(Computed.booleanAll(args.map(resolveComputedArg))),
-    all: (...refs) => createGroup("all", refs),
-    any: (...refs) => createGroup("any", refs),
-    route: (pipelineKey, inputJson) => inputJson !== undefined ? { outcome: "route", pipelineKey, inputJson } : { outcome: "route", pipelineKey }
+    all: (...refs) => createCohortGroup("all", refs),
+    any: (...refs) => createCohortGroup("any", refs)
   };
 }
-
-// src/definitions/pipelines/input-accessor.ts
-var ACCESSOR_BRAND = Symbol.for("boboddy.inputAccessor.brand");
-var ACCESSOR_PATH = Symbol.for("boboddy.inputAccessor.path");
-function createInputAccessor(_schema) {
-  return createProxy([]);
-}
-function createProxy(path) {
-  const pathStr = path.join(".");
-  const target = Object.freeze({});
-  return new Proxy(target, {
-    get(_t, prop) {
-      if (prop === ACCESSOR_BRAND)
-        return true;
-      if (prop === ACCESSOR_PATH)
-        return pathStr;
-      if (prop === "toJSON") {
-        return () => ({
-          source: "pipeline_input",
-          path: pathStr
-        });
-      }
-      if (prop === Symbol.toPrimitive) {
-        return () => {
-          throw new Error(`Pipeline input accessor at path "${pathStr || "<root>"}" cannot be coerced to a primitive. ` + `Pass it to a step input field instead of using it in a string/number expression.`);
-        };
-      }
-      if (typeof prop === "symbol")
-        return;
-      return createProxy([...path, prop]);
-    },
-    has(_t, prop) {
-      return prop === ACCESSOR_BRAND || prop === ACCESSOR_PATH;
-    },
-    ownKeys() {
-      throw new Error(`Pipeline input accessor at path "${pathStr || "<root>"}" cannot be enumerated. ` + `Drill into specific fields instead of spreading the input.`);
-    },
-    set() {
-      throw new Error(`Pipeline input accessor at path "${pathStr || "<root>"}" is read-only.`);
-    }
-  });
+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 isInputAccessor(value) {
-  return typeof value === "object" && value !== null && value[ACCESSOR_BRAND] === true;
+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 materializeAccessor(accessor) {
+function makeAdvanceAllCtx() {
   return {
-    source: "pipeline_input",
-    path: accessor[ACCESSOR_PATH]
+    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/work-item-fields.ts
-var WORK_ITEM_TOP_LEVEL_FIELDS = [
-  "id",
+// src/definitions/pipelines/bindings.ts
+function serializeBinding(binding) {
+  if (binding.source === "pipeline_input") {
+    return { source: "pipeline_input", path: binding.path };
+  }
+  if (binding.source === "work_item") {
+    return { source: "work_item", field: binding.field };
+  }
+  if (binding.source === "step_signal") {
+    return {
+      source: "step_signal",
+      stepKey: binding.nodeKey,
+      signalKey: binding.signalKey
+    };
+  }
+  if (binding.source === "literal") {
+    return { source: "literal", value: binding.value };
+  }
+  if (binding.source === "signals_list") {
+    return { source: "signals_list", stepKey: binding.nodeKey };
+  }
+  if (binding.source === "fan_out_item") {
+    return { source: "fan_out_item" };
+  }
+  return { source: "step_output", stepKey: binding.nodeKey };
+}
+function serializeInputBindings(input) {
+  const autoBindings = {
+    workItemTitle: { source: "work_item", field: "title" },
+    workItemDescription: { source: "work_item", field: "description" }
+  };
+  const explicitBindings = Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== undefined).map(([key, binding]) => [key, serializeBinding(binding)]));
+  return { ...autoBindings, ...explicitBindings };
+}
+
+// src/definitions/pipelines/work-item-fields.ts
+var WORK_ITEM_TOP_LEVEL_FIELDS = [
+  "id",
   "projectId",
   "platform",
   "platformId",
@@ -16704,372 +16615,382 @@ var WORK_ITEM_ACCESSOR = Object.freeze({
     field: `${WORK_ITEM_FIELDS_PATH_PREFIX}${fieldName}`
   })
 });
-var WORK_ITEM_FIELD_BINDINGS = {
-  workItemTitle: { source: "work_item", field: "title" },
-  workItemDescription: { source: "work_item", field: "description" }
-};
-function makeStepInputCtx(inputSchema) {
-  const baseAccessor = createInputAccessor(inputSchema);
-  const input = new Proxy(baseAccessor, {
-    get(target, prop) {
-      if (typeof prop === "string" && prop in WORK_ITEM_FIELD_BINDINGS) {
-        return WORK_ITEM_FIELD_BINDINGS[prop];
-      }
-      return target[prop];
-    }
-  });
-  return {
-    input,
-    signal(step, key) {
-      return { source: "step_signal", step, signalKey: key };
-    },
-    output(step) {
-      return { source: "step_output", step };
-    },
-    literal: literal2,
-    signalsList(fanOutStep) {
-      return { source: "signals_list", fanOutStep };
-    }
-  };
-}
 function literal2(value) {
   return { source: "literal", value };
 }
-function normalizeInputMapping(mapping) {
-  if (!mapping)
-    return;
-  const out = {};
-  for (const [key, value] of Object.entries(mapping)) {
-    if (value === undefined)
-      continue;
-    out[key] = isInputAccessor(value) ? materializeAccessor(value) : value;
-  }
-  return out;
-}
-function resolveAdditionalStepInputBindings(label, definition) {
-  if (!definition) {
-    return {};
-  }
-  const raw = definition.bindings({
-    workItemField: (fieldName) => ({
-      source: "work_item",
-      field: `${WORK_ITEM_FIELDS_PATH_PREFIX}${fieldName}`
+
+// src/definitions/pipelines/node-input-ctx.ts
+function makeBaseNodeInputCtx() {
+  return {
+    pipelineInput: (path) => ({ source: "pipeline_input", path }),
+    workItem: WORK_ITEM_ACCESSOR,
+    signal: (nodeKey, signalKey) => ({
+      source: "step_signal",
+      nodeKey,
+      signalKey
     }),
+    output: (nodeKey) => ({ source: "step_output", nodeKey }),
+    signalsList: (nodeKey) => ({ source: "signals_list", nodeKey }),
     literal: literal2
-  });
-  if (definition.schema instanceof exports_external.ZodObject) {
-    const validKeys = new Set(Object.keys(definition.schema.shape));
-    const unknown2 = Object.keys(raw).filter((key) => !validKeys.has(key));
-    if (unknown2.length > 0) {
-      throw new Error(`${label}.bindings returned key${unknown2.length > 1 ? "s" : ""} not in schema: ${unknown2.map((key) => `"${key}"`).join(", ")}`);
-    }
-  }
-  return normalizeInputMapping(raw) ?? {};
+  };
+}
+function makeNodeInputCtx() {
+  return makeBaseNodeInputCtx();
 }
-function mergeStepBindings(pipelineBindings, explicitBindings) {
-  const merged = {
-    ...pipelineBindings,
-    ...explicitBindings ?? {}
+function makeFanOutNodeInputCtx() {
+  return {
+    ...makeBaseNodeInputCtx(),
+    item: { source: "fan_out_item" }
   };
-  return Object.keys(merged).length > 0 ? merged : undefined;
 }
 
-// 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
-    };
+// src/definitions/pipelines/compile-node-definitions.ts
+function assertTargetExists(ctx, fromKey, toKey) {
+  if (!ctx.stateKeys.has(toKey)) {
+    throw new Error(`Pipeline "${ctx.pipelineKey}": state "${fromKey}" targets unknown state "${toKey}"`);
+  }
+}
+function overSignalKeyOf(over) {
+  const lastDot = over.lastIndexOf(".");
+  return lastDot === -1 ? over : over.slice(lastDot + 1);
+}
+function compileStepState(stateKey, state, ctx) {
+  ctx.registerStep(state.step);
+  const inputCtx = makeNodeInputCtx();
+  const rawInput = state.input ? state.input(inputCtx) : {};
+  const inputBindingsJson = serializeInputBindings(rawInput);
+  const routeTarget = typeof state.next === "object" ? state.next : null;
+  const defaultOutcome = routeTarget ? {
+    outcome: "route",
+    pipelineKey: routeTarget.routeToPipeline,
+    ...routeTarget.input ? { inputJson: routeTarget.input } : {}
+  } : "continue";
+  const rules = state.blockWhen ? [{ _tag: "rule", mode: "all", conditions: [state.blockWhen], outcome: "block" }] : [];
+  const policy = { defaultOutcome, rules };
+  const nodeDefinitions = [
+    {
+      nodeKey: stateKey,
+      kind: "step",
+      stepKey: state.step.key,
+      stepName: state.step.name,
+      stepDescription: state.step.description,
+      inputBindingsJson,
+      timeoutSeconds: state.timeout ?? null,
+      advancementPolicyDefinition: serializeAdvancementPolicy(policy),
+      computedSignalDefinitions: extractInlineComputedSignals(policy)
+    }
+  ];
+  const edges = [];
+  if (!routeTarget) {
+    const nextKey = state.next;
+    assertTargetExists(ctx, stateKey, nextKey);
+    edges.push({ fromNodeKey: stateKey, toNodeKey: nextKey });
+  }
+  return { nodeDefinitions, edges };
+}
+function compileChoiceState(stateKey, state, ctx) {
+  const stateChoices = state.choices ?? [];
+  if (stateChoices.length === 0 && !state.default) {
+    throw new Error(`Pipeline "${ctx.pipelineKey}": choice state "${stateKey}" requires at least one entry in choices or a default target`);
+  }
+  const choices = stateChoices.map((choiceCase) => {
+    assertTargetExists(ctx, stateKey, choiceCase.next);
     return {
-      [LEAF_BRAND2]: condition,
-      then(outcome, paramsJson) {
-        return {
-          _tag: "rule",
-          mode: "all",
-          conditions: [condition],
-          outcome,
-          ...paramsJson ? { outcomeJson: paramsJson } : {}
-        };
-      }
+      conditionJson: serializeCondition(choiceCase.when),
+      targetNodeKey: choiceCase.next
     };
-  };
+  });
+  if (state.default)
+    assertTargetExists(ctx, stateKey, state.default);
+  const edges = stateChoices.map((choiceCase) => ({
+    fromNodeKey: stateKey,
+    toNodeKey: choiceCase.next,
+    discriminantJson: { conditionSummary: serializeCondition(choiceCase.when) }
+  }));
+  if (state.default) {
+    edges.push({
+      fromNodeKey: stateKey,
+      toNodeKey: state.default,
+      discriminantJson: { default: true }
+    });
+  }
   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)
+    nodeDefinitions: [
+      { nodeKey: stateKey, kind: "choice", choices, default: state.default ?? null }
+    ],
+    edges
   };
 }
-function createCohortLeafFromCondition(condition) {
-  return {
-    [LEAF_BRAND2]: condition,
-    then(outcome, paramsJson) {
-      return {
-        _tag: "rule",
-        mode: "all",
-        conditions: [condition],
-        outcome,
-        ...paramsJson ? { outcomeJson: paramsJson } : {}
-      };
-    }
+function compileFanOutState(stateKey, state, ctx) {
+  ctx.registerStep(state.step);
+  const inputCtx = makeFanOutNodeInputCtx();
+  const rawInput = state.input ? state.input(inputCtx) : {};
+  const inputBindingsJson = serializeInputBindings(rawInput);
+  const advanceEachResult = state.advanceEach(makeAdvanceEachCtx());
+  const advanceEachPolicy = {
+    default: advanceEachResult.default,
+    ...advanceEachResult.rules !== undefined ? { rules: advanceEachResult.rules } : {}
   };
-}
-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);
+  const advanceAllResult = state.advanceAll(makeAdvanceAllCtx());
+  const advanceAllPolicy = {
+    default: advanceAllResult.default,
+    ...advanceAllResult.rules !== undefined ? { rules: advanceAllResult.rules } : {}
+  };
+  const gateKey = `${stateKey}__cohortGate`;
+  if (ctx.stateKeys.has(gateKey)) {
+    throw new Error(`Pipeline "${ctx.pipelineKey}": synthesized cohortGate key "${gateKey}" collides with an author-declared state \u2014 rename state "${stateKey}"`);
+  }
+  assertTargetExists(ctx, stateKey, state.next);
   return {
-    [GROUP_BRAND2]: { mode, conditions },
-    then(outcome, paramsJson) {
-      return {
-        _tag: "rule",
-        mode,
-        conditions,
-        outcome,
-        ...paramsJson ? { outcomeJson: paramsJson } : {}
-      };
-    }
+    nodeDefinitions: [
+      {
+        nodeKey: stateKey,
+        kind: "fanOut",
+        stepKey: state.step.key,
+        stepName: state.step.name,
+        stepDescription: state.step.description,
+        inputBindingsJson,
+        timeoutSeconds: state.timeout ?? null,
+        overSignalKey: overSignalKeyOf(state.over),
+        advanceEachPolicyDefinition: serializeCohortAdvancementPolicy(advanceEachPolicy),
+        maxConcurrency: state.maxConcurrency ?? null
+      },
+      {
+        nodeKey: gateKey,
+        kind: "cohortGate",
+        advanceAllPolicyDefinition: serializeCohortAdvancementPolicy(advanceAllPolicy),
+        stepSignalsListDefinitions: extractInlineStepSignalsListDefinitions(advanceAllPolicy)
+      }
+    ],
+    edges: [
+      { fromNodeKey: stateKey, toNodeKey: gateKey },
+      { fromNodeKey: gateKey, toNodeKey: state.next }
+    ]
+  };
+}
+function compileParallelState(stateKey, state, ctx) {
+  const branchEntries = Object.entries(state.branches);
+  if (branchEntries.length === 0) {
+    throw new Error(`Pipeline "${ctx.pipelineKey}": parallel state "${stateKey}" requires at least one branch`);
+  }
+  const branches = {};
+  for (const [branchKey, branchConfig] of branchEntries) {
+    ctx.registerStep(branchConfig.step);
+    const inputCtx = makeNodeInputCtx();
+    const rawInput = branchConfig.input ? branchConfig.input(inputCtx) : {};
+    branches[branchKey] = {
+      stepKey: branchConfig.step.key,
+      stepName: branchConfig.step.name,
+      stepDescription: branchConfig.step.description,
+      inputBindingsJson: serializeInputBindings(rawInput)
+    };
+  }
+  let advanceAllPolicyDefinition;
+  if (state.advanceAll) {
+    const advanceAllResult = state.advanceAll(makeAdvanceAllCtx());
+    const advanceAllPolicy = {
+      default: advanceAllResult.default,
+      ...advanceAllResult.rules !== undefined ? { rules: advanceAllResult.rules } : {}
+    };
+    advanceAllPolicyDefinition = serializeCohortAdvancementPolicy(advanceAllPolicy);
+  }
+  assertTargetExists(ctx, stateKey, state.next);
+  return {
+    nodeDefinitions: [
+      {
+        nodeKey: stateKey,
+        kind: "parallel",
+        branches,
+        ...advanceAllPolicyDefinition ? { advanceAllPolicyDefinition } : {}
+      }
+    ],
+    edges: [{ fromNodeKey: stateKey, toNodeKey: state.next }]
   };
 }
-function makeKeyedCohortSignalRef(key) {
-  return createCohortSignalRef(key);
-}
-function makeAdvanceEachCtx() {
+function compileLoopState(stateKey, state, ctx) {
+  ctx.registerStep(state.step);
+  const inputCtx = makeNodeInputCtx();
+  const rawInput = state.input ? state.input(inputCtx) : {};
+  assertTargetExists(ctx, stateKey, state.next);
+  assertTargetExists(ctx, stateKey, state.onExhausted);
   return {
-    signal: (key) => makeKeyedCohortSignalRef(key),
-    stepSignals: new Proxy({}, {
-      get(_, key) {
-        if (typeof key === "string")
-          return makeKeyedCohortSignalRef(key);
-        return;
+    nodeDefinitions: [
+      {
+        nodeKey: stateKey,
+        kind: "loop",
+        stepKey: state.step.key,
+        stepName: state.step.name,
+        stepDescription: state.step.description,
+        inputBindingsJson: serializeInputBindings(rawInput),
+        timeoutSeconds: state.timeout ?? null,
+        maxIterations: state.maxIterations,
+        untilConditionJson: serializeCondition(state.until)
       }
-    }),
-    all: (...refs) => createCohortGroup("all", refs),
-    any: (...refs) => createCohortGroup("any", refs)
+    ],
+    edges: [
+      { fromNodeKey: stateKey, toNodeKey: state.next, discriminantJson: { loopExit: "next" } },
+      {
+        fromNodeKey: stateKey,
+        toNodeKey: state.onExhausted,
+        discriminantJson: { loopExit: "onExhausted" }
+      }
+    ]
   };
 }
-var branchOutcomeValues = [
-  "continue",
-  "block",
-  "error",
-  "abandoned"
-];
-function summarizeTransformOp(op) {
-  if (op.op === "filter") {
-    return `filter_${op.operator}_${JSON.stringify(op.value)}`;
+function compileTerminalState(stateKey, kind) {
+  return { nodeDefinitions: [{ nodeKey: stateKey, kind }], edges: [] };
+}
+function assertNoIllegalConvergentEdges(pipelineKey, nodeKindByKey, edges) {
+  const incoming = new Map;
+  for (const edge of edges) {
+    const list = incoming.get(edge.toNodeKey) ?? [];
+    list.push(edge);
+    incoming.set(edge.toNodeKey, list);
   }
-  if (op.op === "sortBy") {
-    return `sortBy_${op.direction}`;
+  for (const [targetKey, incomingEdges] of incoming) {
+    if (incomingEdges.length <= 1)
+      continue;
+    const hasInvalidSource = incomingEdges.some((edge) => {
+      const kind = nodeKindByKey.get(edge.fromNodeKey);
+      return kind !== "choice" && kind !== "loop";
+    });
+    if (hasInvalidSource) {
+      throw new Error(`Pipeline "${pipelineKey}": state "${targetKey}" has more than one incoming edge, but not every source is a 'choice'/'loop' state (unconditional convergent edges are not allowed \u2014 see docs/research/flat-pipeline-sdk-and-visual-designer.md \xA76).`);
+    }
   }
-  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;
+
+// src/definitions/pipelines/define-pipeline.ts
+function isWorkingNodeDefinition(node) {
+  return node.kind === "step" || node.kind === "fanOut" || node.kind === "loop";
 }
-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);
+function definePipeline(config2) {
+  const stateEntries = Object.entries(config2.states);
+  if (stateEntries.length === 0) {
+    throw new Error(`Pipeline "${config2.key}" must declare at least one state`);
+  }
+  const startState = config2.states[config2.startAt];
+  if (!startState) {
+    throw new Error(`Pipeline "${config2.key}"'s startAt "${config2.startAt}" does not name a declared state`);
+  }
+  if (startState.kind === "choice" || startState.kind === "succeed" || startState.kind === "fail") {
+    throw new Error(`Pipeline "${config2.key}"'s startAt "${config2.startAt}" names a '${startState.kind}' state, which cannot be an entry point`);
+  }
+  const stateKeys = new Set(Object.keys(config2.states));
+  const stepDefMap = new Map;
+  const registerStep = (step) => {
+    const mapKey = `${step.key}@v${String(step.version)}`;
+    if (!stepDefMap.has(mapKey))
+      stepDefMap.set(mapKey, step);
   };
-  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" })
+  const compileContext = {
+    pipelineKey: config2.key,
+    stateKeys,
+    registerStep
   };
-}
-function makeAdvanceAllCtx() {
+  const nodeDefinitions = [];
+  const dependencyEdges = [];
+  for (const [stateKey, state] of stateEntries) {
+    const compiled = state.kind === "step" ? compileStepState(stateKey, state, compileContext) : state.kind === "choice" ? compileChoiceState(stateKey, state, compileContext) : state.kind === "fanOut" ? compileFanOutState(stateKey, state, compileContext) : state.kind === "parallel" ? compileParallelState(stateKey, state, compileContext) : state.kind === "loop" ? compileLoopState(stateKey, state, compileContext) : compileTerminalState(stateKey, state.kind);
+    nodeDefinitions.push(...compiled.nodeDefinitions);
+    dependencyEdges.push(...compiled.edges);
+  }
+  const nodeKindByKey = new Map(nodeDefinitions.map((node) => [node.nodeKey, node.kind]));
+  assertNoIllegalConvergentEdges(config2.key, nodeKindByKey, dependencyEdges);
+  let inputSchemaJson = null;
+  if (config2.input) {
+    try {
+      inputSchemaJson = exports_external.toJSONSchema(config2.input);
+    } catch {
+      inputSchemaJson = null;
+    }
+  }
   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)
+    key: config2.key,
+    name: config2.name ?? config2.key,
+    description: config2.description ?? null,
+    version: config2.version ?? 1,
+    status: config2.status ?? "active",
+    inputSchemaJson,
+    _stepDefinitions: [...stepDefMap.values()],
+    nodeDefinitions,
+    dependencyEdges
   };
 }
-
-// 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/pipeline-definitions-client.ts
+function createPipelineDefinitionsClient(baseUrl) {
+  const client2 = createClient({ baseUrl });
+  return buildPipelineDefinitionsClient(new PipelineDefinitions({ client: client2 }));
 }
-
-// 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);
+function resolveStepRef(pipelineKey, nodeKey, stepKey, stepDefMap) {
+  const stepDef = stepDefMap.get(stepKey);
+  if (!stepDef) {
+    throw new Error(`Step "${stepKey}" referenced by node "${nodeKey}" in pipeline "${pipelineKey}" was not found on ` + `the server. Run \`boboddy steps push\` first to push your step definitions.`);
+  }
+  return {
+    stepDefinitionId: stepDef.id,
+    stepDefinitionVersion: stepDef.version
+  };
 }
-
-class PipelineStepBuilder {
-  inputSchema;
-  meta;
-  nodes;
-  pipelineInputBindings;
-  pipelineStepInputBindings;
-  constructor(inputSchema, meta3, nodes, pipelineInputBindings = {}, pipelineStepInputBindings = {}) {
-    this.inputSchema = inputSchema;
-    this.meta = meta3;
-    this.nodes = nodes;
-    this.pipelineInputBindings = pipelineInputBindings;
-    this.pipelineStepInputBindings = 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 = {
-      key: this.meta.key,
-      name: this.meta.name,
-      description: this.meta.description,
-      version: this.meta.version,
-      status: this.meta.status,
-      input: this.inputSchema,
-      nodes: this.nodes,
-      pipelineInputBindings: this.pipelineInputBindings
+function buildConfigJson(pipelineKey, node, stepDefMap) {
+  if (node.kind === "choice") {
+    return { choices: node.choices, default: node.default };
+  }
+  if (node.kind === "loop") {
+    return {
+      maxIterations: node.maxIterations,
+      untilConditionJson: node.untilConditionJson
     };
-    return buildPipelineSpec(config2);
   }
-}
-
-class PipelineBuilder {
-  inputSchema;
-  meta;
-  nodes = [];
-  pipelineInputBindings;
-  pipelineStepInputBindings;
-  constructor(meta3) {
-    const { additionalPipelineInput, additionalStepInput, ...rest } = meta3;
-    this.inputSchema = additionalPipelineInput?.schema ?? exports_external.unknown();
-    this.meta = rest;
-    if (additionalPipelineInput) {
-      const raw = additionalPipelineInput.bindings({
-        workItem: WORK_ITEM_ACCESSOR,
-        literal: literal2
-      });
-      if (additionalPipelineInput.schema instanceof exports_external.ZodObject) {
-        const validKeys = new Set(Object.keys(additionalPipelineInput.schema.shape));
-        const unknown2 = Object.keys(raw).filter((k) => !validKeys.has(k));
-        if (unknown2.length > 0) {
-          throw new Error(`additionalPipelineInput.bindings returned key${unknown2.length > 1 ? "s" : ""} not in schema: ${unknown2.map((k) => `"${k}"`).join(", ")}`);
-        }
-      }
-      this.pipelineInputBindings = normalizeInputMapping(raw) ?? {};
-    } else {
-      this.pipelineInputBindings = {};
+  if (node.kind === "parallel") {
+    const branches = {};
+    for (const [branchKey, branch] of Object.entries(node.branches)) {
+      branches[branchKey] = {
+        ...resolveStepRef(pipelineKey, node.nodeKey, branch.stepKey, stepDefMap),
+        inputBindingsJson: branch.inputBindingsJson
+      };
     }
-    this.pipelineStepInputBindings = resolveAdditionalStepInputBindings("additionalStepInput", additionalStepInput);
+    return {
+      branches,
+      ...node.advanceAllPolicyDefinition ? { advanceAllPolicyDefinition: node.advanceAllPolicyDefinition } : {}
+    };
+  }
+  if (node.kind === "fanOut") {
+    return {
+      overSignalKey: node.overSignalKey,
+      advanceEachPolicyDefinition: node.advanceEachPolicyDefinition,
+      maxConcurrency: node.maxConcurrency
+    };
   }
-  step(step, options) {
-    return pushStep(this.inputSchema, this.meta, this.nodes, this.pipelineInputBindings, this.pipelineStepInputBindings, step, options);
+  if (node.kind === "cohortGate") {
+    return {
+      advanceAllPolicyDefinition: node.advanceAllPolicyDefinition,
+      stepSignalsListDefinitions: node.stepSignalsListDefinitions
+    };
   }
+  return null;
 }
-function pipeline(meta3) {
-  return new PipelineBuilder(meta3);
-}
-// src/definitions/pipelines/pipeline-definitions-client.ts
-function createPipelineDefinitionsClient(baseUrl) {
-  const client2 = createClient({ baseUrl });
-  return buildPipelineDefinitionsClient(new PipelineDefinitions({ client: client2 }));
+function buildGraphNodeInput(pipelineKey, node, stepDefMap) {
+  const working = isWorkingNodeDefinition(node) ? node : null;
+  const stepRef = working ? resolveStepRef(pipelineKey, node.nodeKey, working.stepKey, stepDefMap) : null;
+  const policy = node.kind === "step" ? node.advancementPolicyDefinition : undefined;
+  return {
+    key: node.nodeKey,
+    kind: node.kind,
+    name: working?.stepName ?? node.nodeKey,
+    ...stepRef ?? {},
+    description: working?.stepDescription ?? null,
+    inputBindingsJson: working ? working.inputBindingsJson : null,
+    timeoutSeconds: working?.timeoutSeconds ?? null,
+    ...policy ? {
+      advancementPolicyRulesJson: policy.rulesJson,
+      advancementPolicyDefaultEventType: policy.defaultEventType,
+      advancementPolicyDefaultEventParamsJson: policy.defaultEventParamsJson,
+      advancementPolicyAllowedEventTypes: policy.allowedEventTypes
+    } : {},
+    configJson: buildConfigJson(pipelineKey, node, stepDefMap),
+    computedSignalDefinitions: node.kind === "step" ? node.computedSignalDefinitions : []
+  };
 }
 var buildPipelineDefinitionsClient = (pipelineDefinitions) => {
   return {
@@ -17090,37 +17011,12 @@ var buildPipelineDefinitionsClient = (pipelineDefinitions) => {
           stepDefMap.set(s.key, s);
         }
       }
-      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 "${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: node.nodeKey,
-          name: node.stepName ?? "",
-          description: node.stepDescription ?? null,
-          position: index + 1,
-          inputBindingsJson: node.inputBindingsJson ?? {},
-          timeoutSeconds: node.timeoutSeconds ?? null,
-          retryPolicyJson: null,
-          advancementPolicyDefinition: node.advancementPolicyDefinition,
-          computedSignalDefinitions: node.computedSignalDefinitions ?? []
-        };
-      });
+      const nodeDefinitions = spec.nodeDefinitions.map((node) => buildGraphNodeInput(spec.key, node, stepDefMap));
+      const dependencyEdges = spec.dependencyEdges.map((edge) => ({
+        fromNodeKey: edge.fromNodeKey,
+        toNodeKey: edge.toNodeKey,
+        discriminantJson: edge.discriminantJson ?? null
+      }));
       const body = {
         projectId,
         key: spec.key,
@@ -17128,7 +17024,8 @@ var buildPipelineDefinitionsClient = (pipelineDefinitions) => {
         description: spec.description,
         status: spec.status,
         inputSchemaJson: spec.inputSchemaJson,
-        stepDefinitions
+        nodeDefinitions,
+        dependencyEdges
       };
       const result = await pipelineDefinitions.upsertPipelineDefinition({
         body,
@@ -17186,17 +17083,17 @@ function buildWorkItemAccessor() {
   }
   return accessor;
 }
-function makeAssign(pipeline2) {
-  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.");
+function makeAssign(pipeline) {
+  if (typeof pipeline !== "object" || typeof pipeline["key"] !== "string" || !Array.isArray(pipeline["nodeDefinitions"])) {
+    throw new Error("assign() requires a pipeline spec produced by definePipeline(). " + "Pass the default-exported value from a pipeline definition file.");
   }
-  return { _tag: "assign", pipeline: pipeline2 };
+  return { _tag: "assign", pipeline };
 }
-function extractCondition2(ref) {
+function extractCondition(ref) {
   return ref._condition;
 }
 function makeGroup(mode, refs) {
-  const conditions = refs.map(extractCondition2);
+  const conditions = refs.map(extractCondition);
   const condition = { _tag: "group", mode, conditions };
   return {
     _condition: condition,
@@ -17508,6 +17405,58 @@ function resolveSourcePath(schema, sourcePath) {
   }
   return { kind: "resolved" };
 }
+// src/definitions/pipelines/chain-graph.ts
+function tryComputeTopoRanks(nodeDefinitions, dependencyEdges) {
+  const nodeKeys = new Set(nodeDefinitions.map((node) => node.nodeKey));
+  const outgoing = new Map;
+  const inDegree = new Map;
+  for (const key of nodeKeys) {
+    outgoing.set(key, []);
+    inDegree.set(key, 0);
+  }
+  for (const edge of dependencyEdges) {
+    if (!nodeKeys.has(edge.fromNodeKey) || !nodeKeys.has(edge.toNodeKey)) {
+      return null;
+    }
+    outgoing.get(edge.fromNodeKey)?.push(edge.toNodeKey);
+    inDegree.set(edge.toNodeKey, (inDegree.get(edge.toNodeKey) ?? 0) + 1);
+  }
+  const rank = new Map;
+  const queue = [];
+  for (const key of nodeKeys) {
+    if ((inDegree.get(key) ?? 0) === 0) {
+      rank.set(key, 0);
+      queue.push(key);
+    }
+  }
+  let visitedCount = 0;
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === undefined)
+      break;
+    visitedCount += 1;
+    for (const next of outgoing.get(current) ?? []) {
+      rank.set(next, Math.max(rank.get(next) ?? 0, (rank.get(current) ?? 0) + 1));
+      const remaining = (inDegree.get(next) ?? 0) - 1;
+      inDegree.set(next, remaining);
+      if (remaining === 0)
+        queue.push(next);
+    }
+  }
+  if (visitedCount !== nodeKeys.size)
+    return null;
+  return rank;
+}
+function tryOrderNodeDefinitionsByTopoRank(nodeDefinitions, dependencyEdges) {
+  const rankByKey = tryComputeTopoRanks(nodeDefinitions, dependencyEdges);
+  if (rankByKey === null)
+    return null;
+  return nodeDefinitions.map((node, declarationIndex) => ({ node, declarationIndex })).sort((left, right) => {
+    const rankDiff = (rankByKey.get(left.node.nodeKey) ?? 0) - (rankByKey.get(right.node.nodeKey) ?? 0);
+    return rankDiff !== 0 ? rankDiff : left.declarationIndex - right.declarationIndex;
+  }).map(({ node }) => node);
+}
+
 // src/definitions/validation/validate-definition-specs.ts
 function listPaths(paths, limit = 24) {
   if (paths.length === 0)
@@ -17570,9 +17519,10 @@ function checkHealthChecks(steps) {
   }
   return issues;
 }
-function routeTargets(policy) {
-  if (!policy)
+function routeTargets(node) {
+  if (node.kind !== "step" || !node.advancementPolicyDefinition)
     return [];
+  const policy = node.advancementPolicyDefinition;
   const keys = [];
   if (policy.defaultEventType === "route" && typeof policy.defaultEventParamsJson?.["pipelineKey"] === "string") {
     keys.push(policy.defaultEventParamsJson["pipelineKey"]);
@@ -17587,17 +17537,20 @@ function routeTargets(policy) {
 function checkRouteTargets(pipelines, knownPipelineKeys) {
   const issues = [];
   const known = new Set([
-    ...pipelines.map((pipeline2) => pipeline2.key),
+    ...pipelines.map((pipeline) => pipeline.key),
     ...knownPipelineKeys
   ]);
-  for (const pipeline2 of pipelines) {
-    for (const node of pipeline2.nodeDefinitions) {
-      for (const target of routeTargets(node.advancementPolicyDefinition)) {
+  for (const pipeline of pipelines) {
+    for (const node of pipeline.nodeDefinitions) {
+      const stepLabel = (isWorkingNodeDefinition(node) ? node.stepKey : undefined) ?? node.nodeKey;
+      for (const target of routeTargets(node)) {
         if (known.has(target))
           continue;
         issues.push({
           check: "route-target",
-          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.`
+          pipelineKey: pipeline.key,
+          nodeKey: node.nodeKey,
+          message: `Pipeline "${pipeline.key}" step "${stepLabel}" 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.`
         });
       }
     }
@@ -17606,7 +17559,7 @@ function checkRouteTargets(pipelines, knownPipelineKeys) {
 }
 function executionRanks(nodeDefinitions, dependencyEdges) {
   const indexes = nodeDefinitions.map((_, index) => index);
-  const orderedNodes = tryOrderChainNodeDefinitions(nodeDefinitions, dependencyEdges);
+  const orderedNodes = tryOrderNodeDefinitionsByTopoRank(nodeDefinitions, dependencyEdges);
   if (orderedNodes === null) {
     return new Map(indexes.map((index, rank) => [index, rank]));
   }
@@ -17616,70 +17569,81 @@ function executionRanks(nodeDefinitions, dependencyEdges) {
 }
 function bindingSource(binding) {
   if (binding.source === "step_signal") {
-    return { stepKey: binding.stepKey, signalKey: binding.signalKey, kind: "signal" };
+    return { nodeKey: binding.stepKey, signalKey: binding.signalKey, kind: "signal" };
   }
   if (binding.source === "step_output") {
-    return { stepKey: binding.stepKey, signalKey: null, kind: "output" };
+    return { nodeKey: binding.stepKey, signalKey: null, kind: "output" };
   }
   if (binding.source === "signals_list") {
-    return { stepKey: binding.stepKey, signalKey: null, kind: "signals_list" };
+    return { nodeKey: binding.stepKey, signalKey: null, kind: "signals_list" };
   }
   return null;
 }
-function declaredSignalKeys(stepKey, stepsByKey, pipelineNodeDefinitions) {
-  const specs = stepsByKey.get(stepKey);
-  if (!specs || specs.length === 0)
-    return null;
+function declaredSignalKeys(producerNode, stepsByKey) {
+  const stepKey = isWorkingNodeDefinition(producerNode) ? producerNode.stepKey : undefined;
+  const specs = stepKey ? stepsByKey.get(stepKey) : undefined;
+  const computedSignalDefinitions = (producerNode.kind === "step" ? producerNode.computedSignalDefinitions : []) ?? [];
   const keys = new Set;
-  for (const spec of specs) {
+  for (const spec of specs ?? []) {
     for (const signal2 of spec.signalExtractorDefinitions)
       keys.add(signal2.key);
   }
-  for (const node of pipelineNodeDefinitions) {
-    if (node.stepKey !== stepKey)
-      continue;
-    for (const computed of node.computedSignalDefinitions ?? [])
-      keys.add(computed.key);
+  for (const computed of computedSignalDefinitions) {
+    keys.add(computed.key);
+  }
+  if (!specs && computedSignalDefinitions.length === 0) {
+    return null;
   }
   return [...keys];
 }
 function checkSignalBindings(pipelines, stepsByKey) {
   const issues = [];
-  for (const pipeline2 of pipelines) {
-    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.nodeDefinitions.forEach((node, index) => {
+  for (const pipeline of pipelines) {
+    const ranks = executionRanks(pipeline.nodeDefinitions, pipeline.dependencyEdges);
+    const order = [...pipeline.nodeDefinitions.keys()].sort((left, right) => (ranks.get(left) ?? 0) - (ranks.get(right) ?? 0)).map((index) => pipeline.nodeDefinitions[index]?.nodeKey ?? "");
+    const orderHint = `Nodes in "${pipeline.key}", in order: ${order.join(" \u2192 ")}.`;
+    const nodeByKey = new Map(pipeline.nodeDefinitions.map((node) => [node.nodeKey, node]));
+    pipeline.nodeDefinitions.forEach((node, index) => {
       const consumerRank = ranks.get(index) ?? index;
-      const where = `Pipeline "${pipeline2.key}" step "${node.stepKey ?? node.nodeKey}"`;
-      for (const [field, binding] of Object.entries(node.inputBindingsJson ?? {})) {
+      const where = `Pipeline "${pipeline.key}" node "${node.nodeKey}"`;
+      const inputBindingsJson = (isWorkingNodeDefinition(node) ? node.inputBindingsJson : {}) ?? {};
+      for (const [field, binding] of Object.entries(inputBindingsJson)) {
         const source = bindingSource(binding);
         if (!source)
           continue;
-        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) {
+        const what = source.kind === "signal" ? `binds input "${field}" to signal "${source.signalKey ?? ""}" of node "${source.nodeKey}"` : source.kind === "signals_list" ? `binds input "${field}" to the signals list of fan-out node "${source.nodeKey}"` : `binds input "${field}" to the output of node "${source.nodeKey}"`;
+        const issueBase = {
+          pipelineKey: pipeline.key,
+          nodeKey: node.nodeKey,
+          targetNodeKey: source.nodeKey
+        };
+        const producerNode = nodeByKey.get(source.nodeKey);
+        const producerRank = producerNode ? ranks.get(pipeline.nodeDefinitions.indexOf(producerNode)) ?? null : null;
+        if (!producerNode || producerRank === null) {
           issues.push({
             check: "signal-binding",
-            message: `${where} ${what}, but no step with that key is in the pipeline. ${orderHint}`
+            ...issueBase,
+            message: `${where} ${what}, but no node with that key is in the pipeline. ${orderHint}`
           });
           continue;
         }
-        if (!producerRanks.some((rank) => rank < consumerRank)) {
+        if (producerRank >= consumerRank) {
           issues.push({
             check: "signal-binding",
-            message: `${where} ${what}, but that step does not run before it, so the ` + `value will never exist. ${orderHint}`
+            ...issueBase,
+            message: `${where} ${what}, but that node does not run before it, so the ` + `value will never exist. ${orderHint}`
           });
           continue;
         }
         if (source.signalKey === null)
           continue;
-        const available = declaredSignalKeys(source.stepKey, stepsByKey, pipeline2.nodeDefinitions);
+        const available = declaredSignalKeys(producerNode, stepsByKey);
         if (available === null || available.includes(source.signalKey))
           continue;
         issues.push({
           check: "signal-binding",
-          message: `${where} ${what}, but "${source.stepKey}" declares no such signal. ` + `Signals on "${source.stepKey}": ${available.length > 0 ? listPaths([...available].sort()) : "(none)"}.`
+          ...issueBase,
+          message: `${where} ${what}, but "${source.nodeKey}" declares no such signal. ` + `Signals on "${source.nodeKey}": ${available.length > 0 ? listPaths([...available].sort()) : "(none)"}.`
         });
       }
     });
@@ -17712,14 +17676,38 @@ function assertValidDefinitionSpecs(specs, options = {}) {
 }
 // src/push/collect-definitions.ts
 import { existsSync, readdirSync } from "fs";
-import { join, resolve } from "path";
+import { join, relative, resolve } from "path";
 import { pathToFileURL } from "url";
-var PUSH_SCRIPT_NAMES = new Set(["push.ts", "push.mjs", "push.js"]);
+var INTERNAL_SCRIPT_NAMES = new Set([
+  "push.ts",
+  "push.mjs",
+  "push.js",
+  ".boboddy-studio-collect.mjs"
+]);
 function isStepDefinitionSpec(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" && obj["kind"] === "user_defined";
+  return typeof obj["key"] === "string" && typeof obj["name"] === "string" && typeof obj["version"] === "number" && (obj["kind"] === "user_defined" || obj["kind"] === "code");
+}
+function resolveCodeStepEntrypoint(spec, mod, absoluteFilePath) {
+  if (spec.kind !== "code")
+    return spec;
+  const fn = spec.entrypoint?.fn;
+  if (!fn) {
+    throw new Error(`Code step "${spec.key}" (kind: "code") has no entrypoint.fn to resolve. ` + `Build it with codeStep({ fn, ... }) from "@boboddy/sdk/definitions/steps".`);
+  }
+  const exportName = Object.entries(mod).find(([, exportedValue]) => exportedValue === fn)?.[0];
+  if (!exportName) {
+    throw new Error(`Code step "${spec.key}"'s fn is not a named export of ${absoluteFilePath}. ` + `codeStep({ fn }) requires fn to be exported by name from the same module ` + `so its entrypoint can be resolved to a portable {sourceFile, exportName} pair.`);
+  }
+  const resolved = { ...spec };
+  delete resolved.entrypoint;
+  resolved.entrypointJson = {
+    sourceFile: relative(process.cwd(), absoluteFilePath),
+    exportName
+  };
+  return resolved;
 }
 function isPipelineDefinitionSpec(value) {
   if (typeof value !== "object" || value === null)
@@ -17730,31 +17718,48 @@ function isPipelineDefinitionSpec(value) {
 async function importModule(path) {
   return await import(pathToFileURL(path).href);
 }
+function listSourceFiles(absDir) {
+  const allFiles = readdirSync(absDir).filter((file2) => file2.endsWith(".ts") || file2.endsWith(".js"));
+  return allFiles.filter((file2) => !INTERNAL_SCRIPT_NAMES.has(file2) && file2 !== DEFAULT_PIPELINE_ASSIGNMENT_FILENAME);
+}
+function fileNameWithoutExtension(file2) {
+  return file2.replace(/\.(ts|js)$/, "");
+}
+async function collectFile(absoluteFilePath, pipelines, stepMap) {
+  const mod = await importModule(absoluteFilePath);
+  for (const [exportName, value] of Object.entries(mod)) {
+    if (exportName === "default") {
+      if (isPipelineDefinitionSpec(value))
+        pipelines.push(value);
+      continue;
+    }
+    if (isStepDefinitionSpec(value)) {
+      const resolved = resolveCodeStepEntrypoint(value, mod, absoluteFilePath);
+      stepMap.set(`${resolved.key}@v${String(resolved.version)}`, resolved);
+    }
+  }
+}
+function foldEmbeddedSteps(dir, spec, stepMap) {
+  for (const embedded of spec._stepDefinitions ?? []) {
+    const key = `${embedded.key}@v${String(embedded.version)}`;
+    if (stepMap.has(key))
+      continue;
+    if (embedded.kind === "code") {
+      throw new Error(`Code step "${embedded.key}" is only referenced inside a pipeline and is not exported by name from any file in "${dir}". codeStep({ fn }) requires fn to be ` + `a named export so its entrypoint can be resolved \u2014 export the step itself, e.g. ` + `\`export const ${embedded.key} = codeStep({ ... })\`.`);
+    }
+    stepMap.set(key, embedded);
+  }
+}
 async function collectDefinitionsFromDirectory(dir) {
   const absDir = resolve(dir);
-  const allFiles = readdirSync(absDir).filter((file2) => file2.endsWith(".ts") || file2.endsWith(".js"));
-  const sourceFiles = allFiles.filter((file2) => !PUSH_SCRIPT_NAMES.has(file2) && file2 !== DEFAULT_PIPELINE_ASSIGNMENT_FILENAME);
+  const sourceFiles = listSourceFiles(absDir);
   const pipelines = [];
   const stepMap = new Map;
   for (const file2 of sourceFiles) {
-    const mod = await importModule(join(absDir, file2));
-    for (const [exportName, value] of Object.entries(mod)) {
-      if (exportName === "default") {
-        if (isPipelineDefinitionSpec(value))
-          pipelines.push(value);
-        continue;
-      }
-      if (isStepDefinitionSpec(value)) {
-        stepMap.set(`${value.key}@v${String(value.version)}`, value);
-      }
-    }
+    await collectFile(join(absDir, file2), pipelines, stepMap);
   }
   for (const spec of pipelines) {
-    for (const embedded of spec._stepDefinitions ?? []) {
-      const key = `${embedded.key}@v${String(embedded.version)}`;
-      if (!stepMap.has(key))
-        stepMap.set(key, embedded);
-    }
+    foldEmbeddedSteps(dir, spec, stepMap);
   }
   return {
     pipelines,
@@ -17762,6 +17767,50 @@ async function collectDefinitionsFromDirectory(dir) {
     defaultPipelineAssignment: await collectDefaultPipelineAssignment(absDir)
   };
 }
+async function collectDefinitionsFromDirectoryTolerant(dir) {
+  const absDir = resolve(dir);
+  const sourceFiles = listSourceFiles(absDir);
+  const pipelines = [];
+  const stepMap = new Map;
+  const brokenPipelines = [];
+  for (const file2 of sourceFiles) {
+    try {
+      await collectFile(join(absDir, file2), pipelines, stepMap);
+    } catch (error51) {
+      brokenPipelines.push({
+        key: fileNameWithoutExtension(file2),
+        message: error51 instanceof Error ? error51.message : String(error51)
+      });
+    }
+  }
+  const okPipelines = [];
+  for (const spec of pipelines) {
+    try {
+      foldEmbeddedSteps(dir, spec, stepMap);
+      okPipelines.push(spec);
+    } catch (error51) {
+      brokenPipelines.push({
+        key: spec.key,
+        message: error51 instanceof Error ? error51.message : String(error51)
+      });
+    }
+  }
+  let defaultPipelineAssignment2 = null;
+  try {
+    defaultPipelineAssignment2 = await collectDefaultPipelineAssignment(absDir);
+  } catch (error51) {
+    brokenPipelines.push({
+      key: fileNameWithoutExtension(DEFAULT_PIPELINE_ASSIGNMENT_FILENAME),
+      message: error51 instanceof Error ? error51.message : String(error51)
+    });
+  }
+  return {
+    pipelines: okPipelines,
+    steps: [...stepMap.values()],
+    defaultPipelineAssignment: defaultPipelineAssignment2,
+    brokenPipelines
+  };
+}
 async function collectDefaultPipelineAssignment(absDir) {
   const path = join(absDir, DEFAULT_PIPELINE_ASSIGNMENT_FILENAME);
   if (!existsSync(path))
@@ -17784,7 +17833,7 @@ async function pushFromDirectory(dir, opts) {
   log(`Found ${String(pipelines.length)} pipeline(s) and ${String(steps.length)} step(s).`);
   const stepsClient = createStepDefinitionsClient(opts.baseUrl);
   const pipelinesClient = createPipelineDefinitionsClient(opts.baseUrl);
-  const serverPipelineKeys = pipelines.length > 0 ? (await pipelinesClient.listByProjectId(opts.projectId, { headers })).map((pipeline2) => pipeline2.key) : [];
+  const serverPipelineKeys = pipelines.length > 0 ? (await pipelinesClient.listByProjectId(opts.projectId, { headers })).map((pipeline) => pipeline.key) : [];
   assertValidDefinitionSpecs({ pipelines, steps }, { knownPipelineKeys: serverPipelineKeys });
   for (const spec of steps) {
     await stepsClient.upsertFromSpec(opts.projectId, spec, { headers });
@@ -17882,5 +17931,6 @@ async function syncDefaultPipelineAssignment(spec, opts, headers, pipelinesClien
 }
 export {
   pushFromDirectory,
+  collectDefinitionsFromDirectoryTolerant,
   collectDefinitionsFromDirectory
 };