@boboddy/sdk 0.0.16-alpha → 0.1.0-alpha

package/dist/client.js

@@ -890,66 +890,6 @@ class Projects extends HeyApiClient {
   }
 }
 
-class RuntimeSessions extends HeyApiClient {
-  listRuntimeSessions(options) {
-    return (options.client ?? this.client).get({ url: "/api/projects/{projectId}/runtime-sessions", ...options });
-  }
-  createRuntimeSession(options) {
-    return (options.client ?? this.client).post({
-      url: "/api/projects/{projectId}/runtime-sessions",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  getRuntimeSession(options) {
-    return (options.client ?? this.client).get({ url: "/api/projects/{projectId}/runtime-sessions/{runtimeSessionId}", ...options });
-  }
-  stopRuntimeSession(options) {
-    return (options.client ?? this.client).post({ url: "/api/projects/{projectId}/runtime-sessions/{runtimeSessionId}/stop", ...options });
-  }
-}
-
-class RuntimeServices extends HeyApiClient {
-  createRuntimeService(options) {
-    return (options.client ?? this.client).post({
-      url: "/api/projects/{projectId}/runtime-sessions/{runtimeSessionId}/services",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  getRuntimeService(options) {
-    return (options.client ?? this.client).get({ url: "/api/projects/{projectId}/runtime-sessions/{runtimeSessionId}/services/{runtimeServiceId}", ...options });
-  }
-  startRuntimeService(options) {
-    return (options.client ?? this.client).post({ url: "/api/projects/{projectId}/runtime-sessions/{runtimeSessionId}/services/{runtimeServiceId}/start", ...options });
-  }
-  stopRuntimeService(options) {
-    return (options.client ?? this.client).post({ url: "/api/projects/{projectId}/runtime-sessions/{runtimeSessionId}/services/{runtimeServiceId}/stop", ...options });
-  }
-}
-
-class RuntimeCommands extends HeyApiClient {
-  createRuntimeCommand(options) {
-    return (options.client ?? this.client).post({
-      url: "/api/projects/{projectId}/runtime-sessions/{runtimeSessionId}/commands",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  runRuntimeCommand(options) {
-    return (options.client ?? this.client).post({ url: "/api/projects/{projectId}/runtime-sessions/{runtimeSessionId}/commands/{runtimeCommandId}/run", ...options });
-  }
-}
-
 class StepDefinitions extends HeyApiClient {
   listStepDefinitions(options) {
     return (options.client ?? this.client).get({ url: "/api/step-definitions", ...options });
@@ -1284,18 +1224,6 @@ class BoboddyClient extends HeyApiClient {
   get projects() {
     return this._projects ??= new Projects({ client: this.client });
   }
-  _runtimeSessions;
-  get runtimeSessions() {
-    return this._runtimeSessions ??= new RuntimeSessions({ client: this.client });
-  }
-  _runtimeServices;
-  get runtimeServices() {
-    return this._runtimeServices ??= new RuntimeServices({ client: this.client });
-  }
-  _runtimeCommands;
-  get runtimeCommands() {
-    return this._runtimeCommands ??= new RuntimeCommands({ client: this.client });
-  }
   _stepDefinitions;
   get stepDefinitions() {
     return this._stepDefinitions ??= new StepDefinitions({ client: this.client });
@@ -1406,9 +1334,6 @@ export {
   StepExecutions,
   StepDefinitions,
   StepDefinitionTemplates,
-  RuntimeSessions,
-  RuntimeServices,
-  RuntimeCommands,
   Projects,
   ProjectContext,
   PipelineExecutions,

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

@@ -0,0 +1,218 @@
+/**
+ * Comparison operators supported by json-rules-engine.
+ * These map directly to the operator names the runtime evaluates against signal values.
+ */
+export type ConditionOperator = "equal" | "notEqual" | "lessThan" | "lessThanInclusive" | "greaterThan" | "greaterThanInclusive" | "in" | "notIn" | "contains" | "doesNotContain";
+/** All possible outcomes a step can resolve to after policy evaluation. */
+export type AdvancementEventType = "continue" | "block" | "needs_review" | "complete";
+/**
+ * The outcome emitted when a rule fires (or when no rules match and
+ * `defaultOutcome` is used).
+ *
+ * Shorthand — use when no extra params are needed:
+ *   "continue"
+ *
+ * Object form — use when the outcome carries additional context the runtime
+ * or downstream steps should receive:
+ *   { outcome: "needs_review", outcomeJson: { reason: "low confidence" } }
+ */
+export type AdvancementOutcome = AdvancementEventType | {
+    outcome: AdvancementEventType;
+    outcomeJson?: Record<string, unknown> | null;
+};
+/**
+ * A leaf condition that checks a single signal value against a given operator
+ * and value. Used directly inside `Rule.all()` / `Rule.any()`, or implicitly
+ * by `Rule.when()`.
+ *
+ * `TSignalKeys` is constrained to the declaring step's signal keys, so the
+ * `signal` field is validated at compile time.
+ */
+export type SignalCondition<TSignalKeys extends string = string> = {
+    readonly _tag: "signal";
+    signal: TSignalKeys;
+    operator: ConditionOperator;
+    value: unknown;
+};
+/**
+ * A condition group where ALL nested conditions must match.
+ * Created by calling `Rule.all()` without an outcome argument.
+ * Can itself be nested inside another `Rule.all()` or `Rule.any()`.
+ */
+export type AllCondition<TSignalKeys extends string = string> = {
+    readonly _tag: "all";
+    conditions: RuleCondition<TSignalKeys>[];
+};
+/**
+ * A condition group where ANY nested condition must match.
+ * Created by calling `Rule.any()` without an outcome argument.
+ * Can itself be nested inside another `Rule.all()` or `Rule.any()`.
+ */
+export type AnyCondition<TSignalKeys extends string = string> = {
+    readonly _tag: "any";
+    conditions: RuleCondition<TSignalKeys>[];
+};
+/**
+ * Anything that can appear inside `Rule.all()` or `Rule.any()` — either a leaf
+ * signal condition or a nested all/any group.
+ */
+export type RuleCondition<TSignalKeys extends string = string> = SignalCondition<TSignalKeys> | AllCondition<TSignalKeys> | AnyCondition<TSignalKeys>;
+/**
+ * A complete advancement rule: one or more conditions evaluated in `all` or
+ * `any` mode, plus the outcome emitted when the rule fires.
+ *
+ * Rules are created via the `Rule` namespace — `Rule.when()`, `Rule.all()`,
+ * `Rule.any()`. They are not constructed directly.
+ */
+export type Rule<TSignalKeys extends string = string> = {
+    readonly _tag: "rule";
+    mode: "all" | "any";
+    conditions: RuleCondition<TSignalKeys>[];
+    outcome: AdvancementOutcome;
+};
+/**
+ * Creates a leaf signal condition for use inside `Rule.all()` or `Rule.any()`.
+ * Not a rule itself — no outcome is attached.
+ *
+ * @example
+ * Rule.all([
+ *   Rule.signal("score", "greaterThanInclusive", 80),
+ *   Rule.signal("flagged", "equal", false),
+ * ], "continue")
+ */
+declare function signal<TSignalKeys extends string>(signal: TSignalKeys, operator: ConditionOperator, value: unknown): SignalCondition<TSignalKeys>;
+/**
+ * When called with only `conditions`: returns a nested `AllCondition` group
+ * for use inside another `Rule.all()` or `Rule.any()`.
+ *
+ * When called with `conditions` and `outcome`: returns a top-level `Rule` that
+ * fires when ALL conditions match.
+ *
+ * @example
+ * // Top-level rule
+ * Rule.all([Rule.signal("passed", "equal", true)], "continue")
+ *
+ * // Nested inside Rule.any
+ * Rule.any([
+ *   Rule.all([
+ *     Rule.signal("score", "greaterThan", 90),
+ *     Rule.signal("flagged", "equal", false),
+ *   ]),
+ *   Rule.signal("override", "equal", true),
+ * ], "continue")
+ */
+declare function all<TSignalKeys extends string>(conditions: RuleCondition<TSignalKeys>[]): AllCondition<TSignalKeys>;
+declare function all<TSignalKeys extends string>(conditions: RuleCondition<TSignalKeys>[], outcome: AdvancementOutcome): Rule<TSignalKeys>;
+/**
+ * When called with only `conditions`: returns a nested `AnyCondition` group
+ * for use inside another `Rule.all()` or `Rule.any()`.
+ *
+ * When called with `conditions` and `outcome`: returns a top-level `Rule` that
+ * fires when ANY condition matches.
+ *
+ * @example
+ * // Top-level rule
+ * Rule.any([
+ *   Rule.signal("score", "greaterThan", 90),
+ *   Rule.signal("override", "equal", true),
+ * ], "continue")
+ *
+ * // Nested inside Rule.all
+ * Rule.all([
+ *   Rule.signal("score", "greaterThanInclusive", 80),
+ *   Rule.any([
+ *     Rule.signal("reviewerApproved", "equal", true),
+ *     Rule.signal("autoApproved", "equal", true),
+ *   ]),
+ * ], "continue")
+ */
+declare function any<TSignalKeys extends string>(conditions: RuleCondition<TSignalKeys>[]): AnyCondition<TSignalKeys>;
+declare function any<TSignalKeys extends string>(conditions: RuleCondition<TSignalKeys>[], outcome: AdvancementOutcome): Rule<TSignalKeys>;
+/**
+ * Shorthand for a single-condition rule. Equivalent to
+ * `Rule.all([Rule.signal(signal, operator, value)], outcome)`.
+ *
+ * @example
+ * Rule.when("passed", "equal", true, "continue")
+ * Rule.when("score", "greaterThanInclusive", 80, { outcome: "continue", outcomeJson: { via: "score" } })
+ */
+declare function when<TSignalKeys extends string>(signal: TSignalKeys, operator: ConditionOperator, value: unknown, outcome: AdvancementOutcome): Rule<TSignalKeys>;
+/**
+ * All factories for building advancement rules.
+ *
+ * - `Rule.signal` — leaf condition (used inside `all` / `any`)
+ * - `Rule.all`    — all conditions must match; nestable
+ * - `Rule.any`    — any condition must match; nestable
+ * - `Rule.when`   — shorthand for a single-signal rule
+ */
+export declare const Rule: {
+    readonly signal: typeof signal;
+    readonly all: typeof all;
+    readonly any: typeof any;
+    readonly when: typeof when;
+};
+/**
+ * Controls when and how a pipeline step advances.
+ *
+ * Rules are evaluated in order; the first match wins. If no rule fires,
+ * the step resolves to `defaultOutcome`.
+ *
+ * `TSignalKeys` is inferred from the step's declared signals, which constrains
+ * all `Rule.signal()` / `Rule.when()` calls to only valid signal keys.
+ *
+ * @example
+ * {
+ *   defaultOutcome: "block",
+ *   rules: [
+ *     Rule.when("passed", "equal", true, "continue"),
+ *     Rule.all([
+ *       Rule.signal("score", "greaterThanInclusive", 80),
+ *       Rule.any([
+ *         Rule.signal("reviewerApproved", "equal", true),
+ *         Rule.signal("autoApproved", "equal", true),
+ *       ]),
+ *     ], "continue"),
+ *   ],
+ * }
+ */
+export type AdvancementPolicy<TSignalKeys extends string = string> = {
+    /**
+     * The outcome emitted when no rule matches.
+     * "continue" — step advances automatically.
+     * "block"    — step waits for human intervention.
+     */
+    defaultOutcome: AdvancementOutcome;
+    /**
+     * Ordered list of rules evaluated against the step's signal values.
+     * First match wins; unmatched falls through to `defaultOutcome`.
+     */
+    rules?: Rule<TSignalKeys>[];
+};
+type SerializedLeafCondition = {
+    fact: string;
+    operator: string;
+    value: unknown;
+};
+type SerializedConditionGroup = {
+    all?: SerializedCondition[];
+    any?: SerializedCondition[];
+};
+type SerializedCondition = SerializedLeafCondition | SerializedConditionGroup;
+type SerializedRule = {
+    conditions: SerializedConditionGroup;
+    event: {
+        type: string;
+        params?: Record<string, unknown>;
+    };
+};
+/** Serialized shape expected by the boboddy runtime API. */
+export type SerializedAdvancementPolicy = {
+    rulesJson: {
+        rules: SerializedRule[];
+    };
+    defaultEventType: AdvancementEventType;
+    defaultEventParamsJson: Record<string, unknown> | null;
+    allowedEventTypes: AdvancementEventType[];
+};
+export declare function serializeAdvancementPolicy(policy: AdvancementPolicy | undefined): SerializedAdvancementPolicy;
+export {};

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

@@ -0,0 +1 @@
+export * from "./define-advancement-policy";

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

@@ -0,0 +1,95 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/definitions/advancement-policies/define-advancement-policy.ts
+function signal(signal2, operator, value) {
+  return { _tag: "signal", signal: signal2, operator, value };
+}
+function all(conditions, outcome) {
+  if (outcome === undefined) {
+    return { _tag: "all", conditions };
+  }
+  return { _tag: "rule", mode: "all", conditions, outcome };
+}
+function any(conditions, outcome) {
+  if (outcome === undefined) {
+    return { _tag: "any", conditions };
+  }
+  return { _tag: "rule", mode: "any", conditions, outcome };
+}
+function when(signal2, operator, value, outcome) {
+  return {
+    _tag: "rule",
+    mode: "all",
+    conditions: [{ _tag: "signal", signal: signal2, operator, value }],
+    outcome
+  };
+}
+var Rule = { signal, all, any, when };
+function resolveOutcome(outcome) {
+  if (typeof outcome === "string") {
+    return { type: outcome, params: null };
+  }
+  return { type: outcome.outcome, params: outcome.outcomeJson ?? null };
+}
+function serializeCondition(condition) {
+  if (condition._tag === "signal") {
+    return {
+      fact: condition.signal,
+      operator: condition.operator,
+      value: condition.value
+    };
+  }
+  if (condition._tag === "all") {
+    return { all: condition.conditions.map(serializeCondition) };
+  }
+  return { any: condition.conditions.map(serializeCondition) };
+}
+function serializeRule(rule) {
+  const resolved = resolveOutcome(rule.outcome);
+  return {
+    conditions: { [rule.mode]: rule.conditions.map(serializeCondition) },
+    event: {
+      type: resolved.type,
+      ...resolved.params ? { params: resolved.params } : {}
+    }
+  };
+}
+function serializeAdvancementPolicy(policy) {
+  if (!policy) {
+    return {
+      rulesJson: { rules: [] },
+      defaultEventType: "continue",
+      defaultEventParamsJson: null,
+      allowedEventTypes: ["continue"]
+    };
+  }
+  const defaultResolved = resolveOutcome(policy.defaultOutcome);
+  const outcomeSet = new Set([defaultResolved.type]);
+  const serializedRules = (policy.rules ?? []).map((rule) => {
+    outcomeSet.add(resolveOutcome(rule.outcome).type);
+    return serializeRule(rule);
+  });
+  return {
+    rulesJson: { rules: serializedRules },
+    defaultEventType: defaultResolved.type,
+    defaultEventParamsJson: defaultResolved.params,
+    allowedEventTypes: [...outcomeSet]
+  };
+}
+export {
+  serializeAdvancementPolicy,
+  Rule
+};

package/dist/definitions/pipelines/define-pipeline.d.ts

@@ -0,0 +1,112 @@
+import type { ZodType } from "zod";
+import type { DotPaths, TypedStepDefinitionSpec } from "../steps/define-step";
+import { type AdvancementPolicy, type SerializedAdvancementPolicy } from "../advancement-policies/define-advancement-policy";
+export type { AdvancementPolicy } from "../advancement-policies/define-advancement-policy";
+export { Rule } from "../advancement-policies/define-advancement-policy";
+type AnyTypedStep = TypedStepDefinitionSpec<any, any, any>;
+export type PipelineInputBinding = {
+    source: "pipeline_input";
+    path: string;
+};
+export type StepSignalBinding = {
+    source: "step_signal";
+    step: AnyTypedStep;
+    signalKey: string;
+};
+export type StepOutputBinding = {
+    source: "step_output";
+    step: AnyTypedStep;
+};
+export type AnyBinding = PipelineInputBinding | StepSignalBinding | StepOutputBinding;
+/**
+ * Binds a step input field to a field of the pipeline's top-level input.
+ * The `path` is validated against the pipeline input schema at compile time.
+ */
+export declare function fromPipelineInput<T extends ZodType>(_schema: T, path: DotPaths<T["_output"]>): PipelineInputBinding;
+/**
+ * Binds a step input field to a named signal from a prior step.
+ * `signalKey` is validated against the prior step's declared signal keys.
+ */
+export declare function fromSignal<TStep extends AnyTypedStep>(step: TStep, signalKey: TStep["__signalKeys"]): StepSignalBinding;
+/**
+ * Binds a step input field to the entire agent output of a prior step.
+ * Use this when your consumer handles the full output object directly.
+ * For a stable contract, prefer fromSignal() instead.
+ */
+export declare function stepOutput(step: AnyTypedStep): StepOutputBinding;
+export type PipelineStepConfig<TStep extends AnyTypedStep = AnyTypedStep> = {
+    step: TStep;
+    /** Maps each step input field to an input source. Extra keys are ignored at runtime. */
+    input?: Partial<{
+        [K in keyof NonNullable<TStep["__inputType"]> & string]: AnyBinding;
+    }>;
+    timeout?: number | null;
+    /**
+     * Controls when and how this step advances in the pipeline.
+     * Signal keys in `whenSignal()` rules are type-checked against this step's declared signals.
+     * Defaults to `{ defaultOutcome: "continue" }` when omitted.
+     */
+    advancement?: AdvancementPolicy<TStep["__signalKeys"]>;
+};
+type SerializedBinding = {
+    source: "pipeline_input";
+    path: string;
+} | {
+    source: "step_signal";
+    stepKey: string;
+    signalKey: string;
+} | {
+    source: "step_output";
+    stepKey: string;
+};
+export type PipelineDefinitionSpec = {
+    key: string;
+    name: string;
+    description: string | null;
+    version: number;
+    status: "draft" | "active" | "archived";
+    steps: Array<{
+        stepKey: string;
+        stepName: string;
+        stepDescription: string | null;
+        position: number;
+        inputBindingsJson: Record<string, SerializedBinding>;
+        timeoutSeconds: number | null;
+        advancementPolicyDefinition: SerializedAdvancementPolicy;
+    }>;
+};
+/**
+ * Untyped input shape used for documentation and as the internal implementation
+ * target. Call sites use the generic overload below which provides per-step
+ * signal key validation.
+ */
+export type DefinePipelineInput = {
+    key: string;
+    name: string;
+    description?: string | null;
+    version?: number;
+    status?: "draft" | "active";
+    steps: Array<PipelineStepConfig>;
+};
+/**
+ * Defines a pipeline from an ordered list of step configs.
+ *
+ * Each step's `advancement` policy is typed against that step's declared signal
+ * keys — passing an unknown signal key to `whenSignal()` is a compile-time error.
+ *
+ * TypeScript achieves per-element signal key checking by constraining `TSteps`
+ * to a tuple of step instances (`AnyTypedStep[]`), not step configs. Each element
+ * of `steps` is then typed as `PipelineStepConfig<TSteps[K]>`, giving TypeScript
+ * a direct inference site: `step: TSteps[K]` matches the concrete step instance,
+ * which carries the signal key union via `__signalKeys`.
+ */
+export declare function definePipeline<const TSteps extends ReadonlyArray<AnyTypedStep>>(config: {
+    key: string;
+    name: string;
+    description?: string | null;
+    version?: number;
+    status?: "draft" | "active";
+    steps: {
+        [K in keyof TSteps]: PipelineStepConfig<TSteps[K]>;
+    };
+}): PipelineDefinitionSpec;

package/dist/definitions/pipelines/index.d.ts

@@ -0,0 +1 @@
+export * from "./define-pipeline";

package/dist/definitions/pipelines/index.js

@@ -0,0 +1,141 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/definitions/advancement-policies/define-advancement-policy.ts
+function signal(signal2, operator, value) {
+  return { _tag: "signal", signal: signal2, operator, value };
+}
+function all(conditions, outcome) {
+  if (outcome === undefined) {
+    return { _tag: "all", conditions };
+  }
+  return { _tag: "rule", mode: "all", conditions, outcome };
+}
+function any(conditions, outcome) {
+  if (outcome === undefined) {
+    return { _tag: "any", conditions };
+  }
+  return { _tag: "rule", mode: "any", conditions, outcome };
+}
+function when(signal2, operator, value, outcome) {
+  return {
+    _tag: "rule",
+    mode: "all",
+    conditions: [{ _tag: "signal", signal: signal2, operator, value }],
+    outcome
+  };
+}
+var Rule = { signal, all, any, when };
+function resolveOutcome(outcome) {
+  if (typeof outcome === "string") {
+    return { type: outcome, params: null };
+  }
+  return { type: outcome.outcome, params: outcome.outcomeJson ?? null };
+}
+function serializeCondition(condition) {
+  if (condition._tag === "signal") {
+    return {
+      fact: condition.signal,
+      operator: condition.operator,
+      value: condition.value
+    };
+  }
+  if (condition._tag === "all") {
+    return { all: condition.conditions.map(serializeCondition) };
+  }
+  return { any: condition.conditions.map(serializeCondition) };
+}
+function serializeRule(rule) {
+  const resolved = resolveOutcome(rule.outcome);
+  return {
+    conditions: { [rule.mode]: rule.conditions.map(serializeCondition) },
+    event: {
+      type: resolved.type,
+      ...resolved.params ? { params: resolved.params } : {}
+    }
+  };
+}
+function serializeAdvancementPolicy(policy) {
+  if (!policy) {
+    return {
+      rulesJson: { rules: [] },
+      defaultEventType: "continue",
+      defaultEventParamsJson: null,
+      allowedEventTypes: ["continue"]
+    };
+  }
+  const defaultResolved = resolveOutcome(policy.defaultOutcome);
+  const outcomeSet = new Set([defaultResolved.type]);
+  const serializedRules = (policy.rules ?? []).map((rule) => {
+    outcomeSet.add(resolveOutcome(rule.outcome).type);
+    return serializeRule(rule);
+  });
+  return {
+    rulesJson: { rules: serializedRules },
+    defaultEventType: defaultResolved.type,
+    defaultEventParamsJson: defaultResolved.params,
+    allowedEventTypes: [...outcomeSet]
+  };
+}
+
+// src/definitions/pipelines/define-pipeline.ts
+function fromPipelineInput(_schema, path) {
+  return { source: "pipeline_input", path };
+}
+function fromSignal(step, signalKey) {
+  return { source: "step_signal", step, signalKey };
+}
+function stepOutput(step) {
+  return { source: "step_output", step };
+}
+function serializeBinding(binding) {
+  if (binding.source === "pipeline_input") {
+    return { source: "pipeline_input", path: binding.path };
+  }
+  if (binding.source === "step_signal") {
+    return {
+      source: "step_signal",
+      stepKey: binding.step.key,
+      signalKey: binding.signalKey
+    };
+  }
+  return { source: "step_output", stepKey: binding.step.key };
+}
+function definePipeline(config) {
+  const steps = config.steps;
+  return {
+    key: config.key,
+    name: config.name,
+    description: config.description ?? null,
+    version: config.version ?? 1,
+    status: config.status ?? "active",
+    steps: steps.map((stepConfig, index) => ({
+      stepKey: stepConfig.step.key,
+      stepName: stepConfig.step.name,
+      stepDescription: stepConfig.step.description,
+      position: index + 1,
+      inputBindingsJson: Object.fromEntries(Object.entries(stepConfig.input ?? {}).filter((entry) => entry[1] !== undefined).map(([key, binding]) => [key, serializeBinding(binding)])),
+      timeoutSeconds: stepConfig.timeout ?? null,
+      advancementPolicyDefinition: serializeAdvancementPolicy(stepConfig.advancement)
+    }))
+  };
+}
+export {
+  stepOutput,
+  fromSignal,
+  fromPipelineInput,
+  definePipeline,
+  Rule
+};