@boboddy/sdk 0.1.13-alpha → 0.1.15-alpha

package/dist/defaults/index.js

@@ -0,0 +1,312 @@
+// @bun
+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/jsonc.ts
+var stripJsoncComments = (content) => {
+  let result = "";
+  let inString = false;
+  let escapeNextCharacter = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const character = content.charAt(index);
+    const nextCharacter = content.charAt(index + 1);
+    if (lineComment) {
+      if (character === `
+`) {
+        lineComment = false;
+        result += character;
+      }
+      continue;
+    }
+    if (blockComment) {
+      if (character === "*" && nextCharacter === "/") {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (inString) {
+      result += character;
+      if (escapeNextCharacter) {
+        escapeNextCharacter = false;
+        continue;
+      }
+      if (character === "\\") {
+        escapeNextCharacter = true;
+        continue;
+      }
+      if (character === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      result += character;
+      continue;
+    }
+    if (character === "/" && nextCharacter === "/") {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (character === "/" && nextCharacter === "*") {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    result += character;
+  }
+  return result;
+};
+var stripTrailingCommas = (content) => {
+  let result = "";
+  let inString = false;
+  let escapeNextCharacter = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const character = content.charAt(index);
+    if (inString) {
+      result += character;
+      if (escapeNextCharacter) {
+        escapeNextCharacter = false;
+        continue;
+      }
+      if (character === "\\") {
+        escapeNextCharacter = true;
+        continue;
+      }
+      if (character === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      result += character;
+      continue;
+    }
+    if (character === ",") {
+      let lookaheadIndex = index + 1;
+      while (lookaheadIndex < content.length) {
+        const lookaheadCharacter2 = content.charAt(lookaheadIndex);
+        if (/\s/u.test(lookaheadCharacter2)) {
+          lookaheadIndex += 1;
+          continue;
+        }
+        if (lookaheadCharacter2 === "}" || lookaheadCharacter2 === "]") {
+          break;
+        }
+        result += character;
+        break;
+      }
+      if (lookaheadIndex >= content.length) {
+        continue;
+      }
+      const lookaheadCharacter = content.charAt(lookaheadIndex);
+      if (lookaheadCharacter === "}" || lookaheadCharacter === "]") {
+        continue;
+      }
+      continue;
+    }
+    result += character;
+  }
+  return result;
+};
+var parseJsonc = (content) => JSON.parse(stripTrailingCommas(stripJsoncComments(content)));
+
+// src/defaults/auth-file.ts
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var LEGACY_AUTH_FILE_PATH = join(homedir(), ".boboddy");
+var AUTH_FILE_PATH = join(homedir(), ".boboddy.json");
+var EMPTY_AUTH_FILE = {
+  profiles: {}
+};
+function isAuthProfile(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  if (typeof obj["accessToken"] !== "string")
+    return false;
+  for (const key of ["userId", "email", "name"]) {
+    const v = obj[key];
+    if (v !== undefined && typeof v !== "string")
+      return false;
+  }
+  return true;
+}
+function isAuthFile(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const profiles = value["profiles"];
+  if (typeof profiles !== "object" || profiles === null)
+    return false;
+  for (const profile of Object.values(profiles)) {
+    if (!isAuthProfile(profile))
+      return false;
+  }
+  return true;
+}
+var ensureFilePermissions = (filePath) => {
+  try {
+    chmodSync(filePath, 384);
+  } catch {}
+};
+var getAuthFilePath = () => AUTH_FILE_PATH;
+var loadAuthFileFromPath = (filePath) => {
+  if (!existsSync(filePath))
+    return EMPTY_AUTH_FILE;
+  if (!lstatSync(filePath).isFile())
+    return EMPTY_AUTH_FILE;
+  const content = readFileSync(filePath, "utf8");
+  if (content.trim().length === 0)
+    return EMPTY_AUTH_FILE;
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return EMPTY_AUTH_FILE;
+  }
+  if (!isAuthFile(parsed))
+    return EMPTY_AUTH_FILE;
+  return parsed;
+};
+var loadAuthFile = () => {
+  if (existsSync(AUTH_FILE_PATH)) {
+    return loadAuthFileFromPath(AUTH_FILE_PATH);
+  }
+  return loadAuthFileFromPath(LEGACY_AUTH_FILE_PATH);
+};
+var writeAuthFile = (data) => {
+  const parentDirectory = dirname(AUTH_FILE_PATH);
+  if (!existsSync(parentDirectory)) {
+    mkdirSync(parentDirectory, { recursive: true });
+  }
+  const temporaryPath = `${AUTH_FILE_PATH}.${String(process.pid)}.${String(Date.now())}.tmp`;
+  writeFileSync(temporaryPath, `${JSON.stringify(data, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  ensureFilePermissions(temporaryPath);
+  renameSync(temporaryPath, AUTH_FILE_PATH);
+  ensureFilePermissions(AUTH_FILE_PATH);
+};
+var loadAuthProfile = (baseUrl) => {
+  const authFile = loadAuthFile();
+  return authFile.profiles[baseUrl] ?? null;
+};
+var saveAuthProfile = (baseUrl, profile) => {
+  const authFile = loadAuthFile();
+  authFile.profiles[baseUrl] = profile;
+  writeAuthFile(authFile);
+};
+var deleteAuthProfile = (baseUrl) => {
+  const authFile = loadAuthFile();
+  if (!(baseUrl in authFile.profiles))
+    return;
+  const remainingProfiles = Object.fromEntries(Object.entries(authFile.profiles).filter(([profileBaseUrl]) => profileBaseUrl !== baseUrl));
+  if (Object.keys(remainingProfiles).length === 0) {
+    rmSync(AUTH_FILE_PATH, { force: true });
+    if (existsSync(LEGACY_AUTH_FILE_PATH) && lstatSync(LEGACY_AUTH_FILE_PATH).isFile()) {
+      rmSync(LEGACY_AUTH_FILE_PATH, { force: true });
+    }
+    return;
+  }
+  writeAuthFile({ profiles: remainingProfiles });
+};
+// src/defaults/base-url.ts
+var DEFAULT_BASE_URL = "https://app.boboddy.dev";
+var trimTrailingSlashes = (value) => {
+  let endIndex = value.length;
+  while (endIndex > 0 && value.charAt(endIndex - 1) === "/") {
+    endIndex -= 1;
+  }
+  return value.slice(0, endIndex);
+};
+var resolveBoboddyBaseUrl = (value) => {
+  const trimmedValue = value?.trim();
+  if (trimmedValue)
+    return trimTrailingSlashes(trimmedValue);
+  const envValue = process.env["BOBODDY_BASE_URL"]?.trim();
+  if (envValue)
+    return trimTrailingSlashes(envValue);
+  return DEFAULT_BASE_URL;
+};
+// src/defaults/project-config.ts
+import { readFile } from "fs/promises";
+import path from "path";
+var BOBODDY_DIR = ".boboddy";
+var CONFIG_FILENAME = "boboddy.jsonc";
+var PROJECT_CONFIG_RELATIVE_PATH = path.join(BOBODDY_DIR, CONFIG_FILENAME);
+function getConfigPath(rootDir) {
+  return path.join(rootDir, PROJECT_CONFIG_RELATIVE_PATH);
+}
+function isProjectConfig(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  return typeof value["projectId"] === "string";
+}
+async function loadProjectConfig(rootDir = process.cwd()) {
+  try {
+    const content = await readFile(getConfigPath(rootDir), "utf8");
+    const parsed = parseJsonc(content);
+    return isProjectConfig(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+// src/defaults/load-push-defaults.ts
+import path2 from "path";
+async function findProjectConfigUpwards(startDir) {
+  let current = path2.resolve(startDir);
+  while (true) {
+    const found = await loadProjectConfig(current);
+    if (found)
+      return found;
+    const parent = path2.dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+async function loadPushDefaults(opts) {
+  const baseUrl = resolveBoboddyBaseUrl();
+  const envProjectId = process.env["BOBODDY_PROJECT_ID"]?.trim();
+  const projectId = envProjectId && envProjectId.length > 0 ? envProjectId : (await findProjectConfigUpwards(opts.dir))?.projectId;
+  const envAccessToken = process.env["BOBODDY_ACCESS_TOKEN"]?.trim();
+  const accessToken = envAccessToken && envAccessToken.length > 0 ? envAccessToken : loadAuthProfile(baseUrl)?.accessToken;
+  return { baseUrl, projectId, accessToken };
+}
+export {
+  saveAuthProfile,
+  resolveBoboddyBaseUrl,
+  loadPushDefaults,
+  loadProjectConfig,
+  loadAuthProfile,
+  loadAuthFile,
+  getAuthFilePath,
+  deleteAuthProfile,
+  PROJECT_CONFIG_RELATIVE_PATH
+};

package/dist/defaults/load-push-defaults.d.ts

@@ -0,0 +1,21 @@
+export interface PushDefaults {
+    baseUrl: string;
+    projectId: string | undefined;
+    accessToken: string | undefined;
+}
+export interface LoadPushDefaultsOptions {
+    /**
+     * Directory the script is running from. The project config (`.boboddy/boboddy.jsonc`)
+     * is searched for in this directory and each ancestor directory.
+     */
+    dir: string;
+}
+/**
+ * Reads the conventional defaults for a `boboddy pipelines push` run:
+ * - `baseUrl`: from `BOBODDY_BASE_URL` env var or the built-in default.
+ * - `projectId`: from `BOBODDY_PROJECT_ID` env var or the nearest ancestor
+ *   `.boboddy/boboddy.jsonc` of `opts.dir`.
+ * - `accessToken`: from `BOBODDY_ACCESS_TOKEN` env var or the saved auth
+ *   profile for the resolved `baseUrl`.
+ */
+export declare function loadPushDefaults(opts: LoadPushDefaultsOptions): Promise<PushDefaults>;

package/dist/defaults/project-config.d.ts

@@ -0,0 +1,5 @@
+export interface ProjectConfig {
+    projectId: string;
+}
+export declare const PROJECT_CONFIG_RELATIVE_PATH: string;
+export declare function loadProjectConfig(rootDir?: string): Promise<ProjectConfig | null>;

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

@@ -34,6 +34,10 @@ type ComputedOptions = {
  * @example
  * Rule.when(Computed.sum(["success"]), "greaterThan", 1, "continue")
  * Rule.signal(Computed.average(["score"]), "greaterThanInclusive", 80)
+ *
+ * For new code, prefer the equivalent factories on the `.advance()` callback
+ * context of the `pipeline()` builder (`avg`, `sum`, `min`, `max`, …) — they
+ * return chainable `SignalRef`s and infer signal keys from the current step.
  */
 export declare const Computed: {
     readonly average: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`average_${Join<TInputs, "_">}`, TInputs[number]>;

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

@@ -0,0 +1,82 @@
+import { type AdvancementOutcome, type Rule, type RuleCondition, type RouteOutcome, type SignalCondition } from "./define-advancement-policy";
+declare const LEAF_BRAND: unique symbol;
+declare const GROUP_BRAND: unique symbol;
+declare const SIGNAL_KEY: unique symbol;
+/**
+ * A leaf condition + outcome attacher. Built by `signal(key).<op>(value)` or
+ * any computed factory chained with a comparator. Nestable inside `all()` /
+ * `any()`, or terminable with `.then(outcome)`.
+ */
+export interface RuleLeaf<TSignalKeys extends string = string> {
+    readonly [LEAF_BRAND]: SignalCondition<TSignalKeys>;
+    then(outcome: AdvancementOutcome): Rule<TSignalKeys>;
+}
+/**
+ * A grouped condition + outcome attacher. Built by `all(...)` or `any(...)`.
+ * Nestable inside another group, or terminable with `.then(outcome)`.
+ */
+export interface RuleGroup<TSignalKeys extends string = string> {
+    readonly [GROUP_BRAND]: {
+        mode: "all" | "any";
+        conditions: RuleCondition<TSignalKeys>[];
+    };
+    then(outcome: AdvancementOutcome): Rule<TSignalKeys>;
+}
+type Nestable<K extends string> = RuleLeaf<K> | RuleGroup<K>;
+/**
+ * A comparator-bound signal reference. Returned by `signal(key)` and by every
+ * computed factory (`avg`, `sum`, etc.). Calling any comparator (`gte`, `eq`,
+ * …) produces a `RuleLeaf`.
+ *
+ * `TValue` is the TypeScript type of the signal's value, enabling type-safe
+ * comparisons (e.g. `eq(true)` errors when the signal is a string).
+ */
+export interface SignalRef<TSignalKeys extends string = string, TValue = unknown> {
+    eq(value: TValue): RuleLeaf<TSignalKeys>;
+    ne(value: TValue): RuleLeaf<TSignalKeys>;
+    gt(value: number): RuleLeaf<TSignalKeys>;
+    gte(value: number): RuleLeaf<TSignalKeys>;
+    lt(value: number): RuleLeaf<TSignalKeys>;
+    lte(value: number): RuleLeaf<TSignalKeys>;
+    in(values: ReadonlyArray<TValue>): RuleLeaf<TSignalKeys>;
+    notIn(values: ReadonlyArray<TValue>): RuleLeaf<TSignalKeys>;
+    contains(value: unknown): RuleLeaf<TSignalKeys>;
+    doesNotContain(value: unknown): RuleLeaf<TSignalKeys>;
+}
+/**
+ * A `SignalRef` backed by a plain signal key (not a computed token). The
+ * embedded `SIGNAL_KEY` brand lets computed factories extract the key at
+ * runtime so callers can pass `stepSignals.foo` instead of the string `"foo"`.
+ */
+export interface KeyedSignalRef<TSignalKeys extends string = string, TValue = unknown> extends SignalRef<TSignalKeys, TValue> {
+    readonly [SIGNAL_KEY]: TSignalKeys;
+}
+type ComputedTuple<K extends string, TValue = unknown> = [
+    KeyedSignalRef<K, TValue>,
+    KeyedSignalRef<K, TValue>,
+    ...KeyedSignalRef<K, TValue>[]
+];
+type SignalValue<TSignalKeys extends string, TSignalTypeMap extends Partial<Record<string, unknown>>, K extends TSignalKeys> = K extends keyof TSignalTypeMap ? TSignalTypeMap[K] : unknown;
+export interface AdvanceCtx<TSignalKeys extends string = string, TSignalTypeMap extends Partial<Record<string, unknown>> = Record<string, unknown>> {
+    signal<K extends TSignalKeys>(key: K): KeyedSignalRef<TSignalKeys, SignalValue<TSignalKeys, TSignalTypeMap, K>>;
+    stepSignals: {
+        [K in TSignalKeys]: KeyedSignalRef<TSignalKeys, SignalValue<TSignalKeys, TSignalTypeMap, K>>;
+    };
+    avg(...args: ComputedTuple<TSignalKeys, number>): SignalRef<TSignalKeys>;
+    weightedAvg(...args: ComputedTuple<TSignalKeys, number>): SignalRef<TSignalKeys>;
+    sum(...args: ComputedTuple<TSignalKeys, number>): SignalRef<TSignalKeys>;
+    min(...args: ComputedTuple<TSignalKeys, number>): SignalRef<TSignalKeys>;
+    max(...args: ComputedTuple<TSignalKeys, number>): SignalRef<TSignalKeys>;
+    count(...args: ComputedTuple<TSignalKeys>): SignalRef<TSignalKeys>;
+    booleanAny(...args: ComputedTuple<TSignalKeys, boolean>): SignalRef<TSignalKeys>;
+    booleanAll(...args: ComputedTuple<TSignalKeys, boolean>): SignalRef<TSignalKeys>;
+    all(...refs: Nestable<TSignalKeys>[]): RuleGroup<TSignalKeys>;
+    any(...refs: Nestable<TSignalKeys>[]): RuleGroup<TSignalKeys>;
+    route(pipelineKey: string, inputJson?: Record<string, unknown>): RouteOutcome;
+}
+export interface AdvanceResult<TSignalKeys extends string = string> {
+    default: AdvancementOutcome;
+    rules?: Rule<TSignalKeys>[];
+}
+export declare function makeAdvanceCtx<TSignalKeys extends string, TSignalTypeMap extends Partial<Record<string, unknown>> = Record<string, unknown>>(): AdvanceCtx<TSignalKeys, TSignalTypeMap>;
+export {};

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

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

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

@@ -1,3 +1,4 @@
+// @bun
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -156,8 +157,94 @@ function extractInlineComputedSignals(policy) {
   }
   return [...byKey.values()];
 }
+// 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) {
+  const leaf = (operator, value) => {
+    const condition = {
+      _tag: "signal",
+      signal: signal2,
+      operator,
+      value
+    };
+    return {
+      [LEAF_BRAND]: condition,
+      then(outcome) {
+        return {
+          _tag: "rule",
+          mode: "all",
+          conditions: [condition],
+          outcome
+        };
+      }
+    };
+  };
+  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 extractCondition(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);
+  return {
+    [GROUP_BRAND]: { mode, conditions },
+    then(outcome) {
+      return { _tag: "rule", mode, conditions, outcome };
+    }
+  };
+}
+function resolveComputedArg(arg) {
+  return arg[SIGNAL_KEY];
+}
+function makeKeyedSignalRef(key) {
+  const ref = createSignalRef(key);
+  return Object.assign(ref, {
+    [SIGNAL_KEY]: key
+  });
+}
+function makeAdvanceCtx() {
+  const wrapComputed = (token) => createSignalRef(token);
+  return {
+    signal: (key) => makeKeyedSignalRef(key),
+    stepSignals: new Proxy({}, {
+      get(_, key) {
+        if (typeof key === "string")
+          return makeKeyedSignalRef(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 }
+  };
+}
 export {
   serializeAdvancementPolicy,
+  makeAdvanceCtx,
   extractInlineComputedSignals,
   Rule,
   Computed

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

@@ -0,0 +1,85 @@
+import { z, type ZodType } from "zod";
+import type { TypedStepDefinitionSpec } from "../steps/define-step";
+import { type AdvanceCtx, type AdvanceResult } from "../advancement-policies/fluent-rules";
+import { type AnyBinding, type PipelineDefinitionSpec, type PipelineStepConfig, type StepOutputBinding, type StepSignalBinding, type WorkItemBinding } from "./define-pipeline";
+import { type InputAccessor } from "./input-accessor";
+type AnyTypedStep = TypedStepDefinitionSpec<any, any, any, any>;
+export type StepConfig = {
+    timeout?: number | null;
+};
+type ElementOf<T extends ReadonlyArray<unknown>> = T extends ReadonlyArray<infer U> ? U : never;
+type LastStep<T extends ReadonlyArray<AnyTypedStep>> = T extends readonly [
+    ...AnyTypedStep[],
+    infer L
+] ? L extends AnyTypedStep ? L : never : never;
+type LastSignalKeys<T extends ReadonlyArray<AnyTypedStep>> = LastStep<T> extends AnyTypedStep ? LastStep<T>["__signalKeys"] : never;
+type LastSignalTypeMap<T extends ReadonlyArray<AnyTypedStep>> = LastStep<T> extends AnyTypedStep ? LastStep<T>["__signalTypeMap"] : Record<string, unknown>;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type RequiredInputKeys<T extends object> = {
+    [K in keyof T & string]-?: undefined extends T[K] ? never : K;
+}[keyof T & string];
+type OptionalInputKeys<T extends object> = {
+    [K in keyof T & string]-?: undefined extends T[K] ? K : never;
+}[keyof T & string];
+type StepInputMapping<S extends AnyTypedStep> = IsAny<S["__inputType"]> extends true ? Partial<Record<string, AnyBinding>> : S["__inputType"] extends object ? {
+    [K in RequiredInputKeys<S["__inputType"]>]: AnyBinding;
+} & {
+    [K in OptionalInputKeys<S["__inputType"]>]?: AnyBinding;
+} : Partial<Record<string, AnyBinding>>;
+export type WorkItemAccessor = {
+    readonly title: WorkItemBinding;
+    readonly description: WorkItemBinding;
+};
+export type StepInputCtx<TInput extends ZodType, TSteps extends ReadonlyArray<AnyTypedStep>> = {
+    input: InputAccessor<TInput["_output"]>;
+    workItem: WorkItemAccessor;
+    signal: <S extends ElementOf<TSteps>>(step: S, key: S["__signalKeys"]) => StepSignalBinding;
+    output: <S extends ElementOf<TSteps>>(step: S) => StepOutputBinding;
+};
+export type PipelineMeta<TInput extends ZodType = z.ZodUnknown> = {
+    key: string;
+    name: string;
+    description?: string;
+    version?: number;
+    status?: "draft" | "active";
+    input?: TInput;
+};
+/**
+ * Returned by `.step()`. Requires `.advance()` before the pipeline can
+ * continue. Also accepts `.timeout()` before `.advance()`.
+ */
+export declare class PipelineStepAdvancementBuilder<TInput extends ZodType, TSteps extends ReadonlyArray<AnyTypedStep>> {
+    protected readonly inputSchema: TInput;
+    protected readonly meta: Omit<PipelineMeta<TInput>, "input">;
+    protected readonly steps: PipelineStepConfig[];
+    readonly __steps: TSteps;
+    constructor(inputSchema: TInput, meta: Omit<PipelineMeta<TInput>, "input">, steps: PipelineStepConfig[]);
+    advance(callback: (ctx: AdvanceCtx<LastSignalKeys<TSteps>, LastSignalTypeMap<TSteps>>) => AdvanceResult<LastSignalKeys<TSteps>>): PipelineStepBuilder<TInput, TSteps>;
+}
+/**
+ * Returned by `.advance()`. Provides `.step()` to chain additional steps,
+ * `.timeout()` to set timeout after advancing, and `.build()` to finalize.
+ */
+export declare class PipelineStepBuilder<TInput extends ZodType, TSteps extends ReadonlyArray<AnyTypedStep>> {
+    protected readonly inputSchema: TInput;
+    protected readonly meta: Omit<PipelineMeta<TInput>, "input">;
+    protected readonly steps: PipelineStepConfig[];
+    readonly __steps: TSteps;
+    constructor(inputSchema: TInput, meta: Omit<PipelineMeta<TInput>, "input">, steps: PipelineStepConfig[]);
+    step<S extends AnyTypedStep>(step: S, mapper: (ctx: StepInputCtx<TInput, TSteps>) => StepInputMapping<S>, configFn?: (config: StepConfig) => void): PipelineStepAdvancementBuilder<TInput, [...TSteps, S]>;
+    build(): PipelineDefinitionSpec;
+}
+/**
+ * Entry-point builder returned by `pipeline()`. Only exposes `.step()` —
+ * call that to receive a `PipelineStepAdvancementBuilder` which requires
+ * `.advance()` before the pipeline can proceed.
+ */
+export declare class PipelineBuilder<TInput extends ZodType> {
+    private readonly inputSchema;
+    private readonly meta;
+    private readonly steps;
+    constructor(meta: PipelineMeta<TInput>);
+    step<S extends AnyTypedStep>(step: S, mapper: (ctx: StepInputCtx<TInput, []>) => StepInputMapping<S>, configFn?: (config: StepConfig) => void): PipelineStepAdvancementBuilder<TInput, [S]>;
+}
+export declare function pipeline<TInput extends ZodType = z.ZodUnknown>(meta: PipelineMeta<TInput>): PipelineBuilder<TInput>;
+export {};