@boboddy/sdk 0.3.1 → 0.4.0

package/dist/client.js

@@ -1069,7 +1069,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",
@@ -1079,7 +1079,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",
@@ -1088,14 +1088,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",
@@ -1104,11 +1104,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",
@@ -1118,7 +1118,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",
@@ -1127,20 +1127,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",
@@ -1149,17 +1149,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",
@@ -1169,7 +1169,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",
@@ -1179,7 +1189,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",
@@ -1188,19 +1198,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 });
   }
 }
 

package/dist/definitions/advancement-policies/cohort-advancement-policy.d.ts

@@ -0,0 +1,117 @@
+/** Restricted outcome domain for both `advanceEach` and `advanceAll`. */
+export declare const cohortAdvancementEventTypeValues: readonly ["continue", "block"];
+export type CohortAdvancementEventType = (typeof cohortAdvancementEventTypeValues)[number];
+export type StepSignalsListConditionOperator = "equal" | "notEqual" | "lessThan" | "lessThanInclusive" | "greaterThan" | "greaterThanInclusive" | "in" | "notIn" | "contains" | "doesNotContain";
+export type StepSignalsListTransformOp = {
+    op: "pluck";
+    signalKey: string;
+} | {
+    op: "filter";
+    operator: StepSignalsListConditionOperator;
+    value: unknown;
+} | {
+    op: "sortBy";
+    direction: "asc" | "desc";
+} | {
+    op: "unique";
+};
+export type StepSignalsListReducerOp = {
+    op: "count";
+} | {
+    op: "sum";
+} | {
+    op: "avg";
+} | {
+    op: "min";
+} | {
+    op: "max";
+} | {
+    op: "booleanAll";
+} | {
+    op: "booleanAny";
+} | {
+    op: "join";
+    separator: string;
+} | {
+    op: "first";
+} | {
+    op: "last";
+};
+/** Wire-format `ctx.stepSignalsList`-derived value, hoisted onto the `cohortGate` node. */
+export type SerializedStepSignalsListDefinition = {
+    key: string;
+    ops: StepSignalsListTransformOp[];
+    reducer: StepSignalsListReducerOp;
+};
+/**
+ * An inline `ctx.stepSignalsList`-derived token, embedded in a rule's
+ * condition tree at the position a signal key would normally go. At
+ * serialize time, hoisted into the `cohortGate` node's
+ * `stepSignalsListDefinitions` and replaced by its bare `key` — the same
+ * "author inline, hoist, replace with bare key" discipline
+ * `extractInlineComputedSignals` already runs for `Computed.*`.
+ */
+export type InlineStepSignalsListValue<TKey extends string = string> = {
+    readonly _tag: "step_signals_list";
+    readonly key: TKey;
+    readonly ops: StepSignalsListTransformOp[];
+    readonly reducer: StepSignalsListReducerOp;
+};
+/**
+ * A leaf condition, restricted to the cohort's own fact vocabulary: a bare
+ * fact name (`branchOutcomes.total()`/`.count(outcome)`, or a
+ * `ctx.stepSignalsList`-derived key) or an inline `InlineStepSignalsListValue`
+ * token (hoisted at serialize time). `value` may itself be a dynamic
+ * fact-reference (`{ fact: "branchCount" }`) — the same
+ * json-rules-engine-native mechanism `branchOutcomes.every()` compiles to.
+ */
+export type CohortSignalCondition = {
+    readonly _tag: "signal";
+    signal: string | InlineStepSignalsListValue;
+    operator: StepSignalsListConditionOperator;
+    value: unknown;
+};
+export type CohortAllCondition = {
+    readonly _tag: "all";
+    conditions: CohortRuleCondition[];
+};
+export type CohortAnyCondition = {
+    readonly _tag: "any";
+    conditions: CohortRuleCondition[];
+};
+export type CohortRuleCondition = CohortSignalCondition | CohortAllCondition | CohortAnyCondition;
+export type CohortRule = {
+    readonly _tag: "rule";
+    mode: "all" | "any";
+    conditions: CohortRuleCondition[];
+    outcome: CohortAdvancementEventType;
+    outcomeJson?: Record<string, unknown> | null;
+};
+export type SerializedCohortRule = {
+    conditions: Record<string, unknown>;
+    event: {
+        type: CohortAdvancementEventType;
+        params?: Record<string, unknown>;
+    };
+};
+/** Serialized shape expected by core's `CohortAdvancementPolicyDefinition`. */
+export type SerializedCohortAdvancementPolicy = {
+    rules: SerializedCohortRule[];
+    defaultEventType: CohortAdvancementEventType;
+    defaultEventParamsJson: Record<string, unknown> | null;
+};
+export type CohortAdvancementPolicy = {
+    default: CohortAdvancementEventType;
+    defaultParamsJson?: Record<string, unknown> | null;
+    rules?: CohortRule[];
+};
+/** Serializes an authored `CohortAdvancementPolicy` (`advanceEach`/`advanceAll`) to its wire shape. */
+export declare function serializeCohortAdvancementPolicy(policy: CohortAdvancementPolicy | undefined): SerializedCohortAdvancementPolicy;
+/**
+ * Walks a `CohortAdvancementPolicy`'s rules tree, extracts every inline
+ * `ctx.stepSignalsList`-derived token embedded in a `CohortSignalCondition
+ * .signal` position, dedupes by key, and returns the resulting
+ * `stepSignalsListDefinitions` — the `cohortGate` node's counterpart to
+ * `extractInlineComputedSignals`.
+ */
+export declare function extractInlineStepSignalsListDefinitions(policy: CohortAdvancementPolicy | undefined): SerializedStepSignalsListDefinition[];

package/dist/definitions/advancement-policies/cohort-fluent-rules.d.ts

@@ -0,0 +1,126 @@
+import { type CohortAdvancementEventType, type CohortRule, type CohortRuleCondition, type CohortSignalCondition, type StepSignalsListConditionOperator } from "./cohort-advancement-policy";
+declare const LEAF_BRAND: unique symbol;
+declare const GROUP_BRAND: unique symbol;
+/**
+ * A leaf condition + outcome attacher for the cohort scope
+ * (`advanceEach`/`advanceAll`). Built by `signal(key).<op>(value)`,
+ * `stepSignalsList.pluck(...).<reducer>()`, or `branchOutcomes.total()`/
+ * `.count(...)` chained with a comparator. Nestable inside `all()`/`any()`,
+ * or terminable with `.then(outcome)` — restricted to `continue`/`block`
+ * (AC4: no `route`/`complete`, unlike a regular step's `RuleLeaf`).
+ */
+export interface CohortRuleLeaf {
+    readonly [LEAF_BRAND]: CohortSignalCondition;
+    then(outcome: CohortAdvancementEventType, paramsJson?: Record<string, unknown>): CohortRule;
+}
+/** A grouped condition + outcome attacher. Built by `all(...)` or `any(...)`. */
+export interface CohortRuleGroup {
+    readonly [GROUP_BRAND]: {
+        mode: "all" | "any";
+        conditions: CohortRuleCondition[];
+    };
+    then(outcome: CohortAdvancementEventType, paramsJson?: Record<string, unknown>): CohortRule;
+}
+type CohortNestable = CohortRuleLeaf | CohortRuleGroup;
+/**
+ * A comparator-bound reference into the cohort scope's facts — a branch's
+ * own signal (`advanceEach`), a `branchOutcomes.total()`/`.count(outcome)`
+ * aggregate, or a `stepSignalsList` reducer's result (`advanceAll`).
+ * Calling any comparator produces a `CohortRuleLeaf`.
+ */
+export interface CohortSignalRef<TValue = unknown> {
+    eq(value: TValue): CohortRuleLeaf;
+    ne(value: TValue): CohortRuleLeaf;
+    gt(value: number): CohortRuleLeaf;
+    gte(value: number): CohortRuleLeaf;
+    lt(value: number): CohortRuleLeaf;
+    lte(value: number): CohortRuleLeaf;
+    in(values: ReadonlyArray<TValue>): CohortRuleLeaf;
+    notIn(values: ReadonlyArray<TValue>): CohortRuleLeaf;
+    contains(value: unknown): CohortRuleLeaf;
+    doesNotContain(value: unknown): CohortRuleLeaf;
+}
+type SignalValue<TSignalKeys extends string, TSignalTypeMap extends Partial<Record<string, unknown>>, K extends TSignalKeys> = K extends keyof TSignalTypeMap ? TSignalTypeMap[K] : unknown;
+/**
+ * `advanceEach`'s callback context: one fan-out branch's own step result,
+ * evaluated the same way a regular step's `.advance()` evaluates its own
+ * signals (`evaluateBranchAgainstPolicy` — the same shared rules-engine
+ * pass, just restricted to `continue`/`block`). No `route`/`complete`, and
+ * — unlike `.advance()`'s `AdvanceCtx` — no `avg`/`sum`/`min`/`max`/`count`/
+ * `booleanAny`/`booleanAll` computed-signal factories: core's `fanOut` node
+ * config has no `computedSignalDefinitions` field to hoist them onto and
+ * `evaluateBranchAgainstPolicy` never resolves them, so exposing them here
+ * would silently produce dead wire fields. A later ticket can add that
+ * support to core first, then extend this ctx to match.
+ */
+export interface AdvanceEachCtx<TSignalKeys extends string = string, TSignalTypeMap extends Partial<Record<string, unknown>> = Record<string, unknown>> {
+    signal<K extends TSignalKeys>(key: K): CohortSignalRef<SignalValue<TSignalKeys, TSignalTypeMap, K>>;
+    stepSignals: {
+        [K in TSignalKeys]: CohortSignalRef<SignalValue<TSignalKeys, TSignalTypeMap, K>>;
+    };
+    all(...refs: CohortNestable[]): CohortRuleGroup;
+    any(...refs: CohortNestable[]): CohortRuleGroup;
+}
+export interface AdvanceEachResult {
+    default: CohortAdvancementEventType;
+    rules?: CohortRule[];
+}
+export declare function makeAdvanceEachCtx<TSignalKeys extends string, TSignalTypeMap extends Partial<Record<string, unknown>> = Record<string, unknown>>(): AdvanceEachCtx<TSignalKeys, TSignalTypeMap>;
+/** The 4-value branch outcome classification (mirrors core's `branchOutcomeValues`). */
+export declare const branchOutcomeValues: readonly ["continue", "block", "error", "abandoned"];
+export type BranchOutcome = (typeof branchOutcomeValues)[number];
+/**
+ * A `ctx.stepSignalsList`-derived op-list builder: seeded by `.pluck(key)`,
+ * optionally narrowed/reshaped by `.filter()`/`.sortBy()`/`.unique()`, then
+ * finalized by exactly one reducer into a comparator-bound
+ * `CohortSignalRef` — the same "author fluently, hoist to a serializable
+ * definition" shape `Computed.*` uses, but resolved server-side against a
+ * cohort's real per-branch signals (`resolveStepSignalsListValue`) rather
+ * than a single step's own signals.
+ */
+export interface StepSignalsListValueRef {
+    filter(operator: StepSignalsListConditionOperator, value: unknown): StepSignalsListValueRef;
+    sortBy(direction?: "asc" | "desc"): StepSignalsListValueRef;
+    unique(): StepSignalsListValueRef;
+    count(): CohortSignalRef;
+    sum(): CohortSignalRef;
+    avg(): CohortSignalRef;
+    min(): CohortSignalRef;
+    max(): CohortSignalRef;
+    booleanAll(): CohortSignalRef;
+    booleanAny(): CohortSignalRef;
+    join(separator?: string): CohortSignalRef;
+    first(): CohortSignalRef;
+    last(): CohortSignalRef;
+}
+/**
+ * `advanceAll`'s callback context: the whole cohort's aggregate branch
+ * outcomes (`branchOutcomes`) and any per-branch signal aggregation
+ * (`stepSignalsList`) — evaluated exactly once per cohort
+ * (`evaluateCohortAgainstPolicy`). Restricted to `continue`/`block`, no
+ * `stepSignals`/`route` (this is a whole-cohort decision, not one step's
+ * own).
+ */
+export interface AdvanceAllCtx {
+    branchOutcomes: {
+        /** The cohort's total branch count. Compiles to fact `branchCount`. */
+        total(): CohortSignalRef<number>;
+        /** A single outcome's count across the cohort. Compiles to fact `${outcome}Count`. */
+        count(outcome: BranchOutcome): CohortSignalRef<number>;
+        /** True iff every branch resolved to this outcome. */
+        every(outcome: BranchOutcome): CohortRuleLeaf;
+        /** True iff at least one branch resolved to this outcome. */
+        some(outcome: BranchOutcome): CohortRuleLeaf;
+    };
+    stepSignalsList: {
+        pluck(signalKey: string): StepSignalsListValueRef;
+    };
+    all(...refs: CohortNestable[]): CohortRuleGroup;
+    any(...refs: CohortNestable[]): CohortRuleGroup;
+}
+export interface AdvanceAllResult {
+    default: CohortAdvancementEventType;
+    rules?: CohortRule[];
+}
+export declare function makeAdvanceAllCtx(): AdvanceAllCtx;
+export {};

package/dist/definitions/advancement-policies/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./define-advancement-policy";
 export * from "./fluent-rules";
+export * from "./cohort-advancement-policy";
+export * from "./cohort-fluent-rules";

package/dist/definitions/advancement-policies/index.js

@@ -242,10 +242,252 @@ function makeAdvanceCtx() {
     route: (pipelineKey, inputJson) => inputJson !== undefined ? { outcome: "route", pipelineKey, inputJson } : { outcome: "route", pipelineKey }
   };
 }
+// 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/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
+    };
+    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)
+  };
+}
 export {
+  serializeCohortAdvancementPolicy,
   serializeAdvancementPolicy,
+  makeAdvanceEachCtx,
   makeAdvanceCtx,
+  makeAdvanceAllCtx,
+  extractInlineStepSignalsListDefinitions,
   extractInlineComputedSignals,
+  cohortAdvancementEventTypeValues,
+  branchOutcomeValues,
   Rule,
   Computed
 };