@reaatech/media-pipeline-mcp-core 0.3.0

package/dist/index.js

@@ -0,0 +1,2157 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/types/index.ts
+import { z } from "zod";
+var ArtifactTypeSchema = z.enum(["image", "video", "audio", "text", "document"]);
+var ArtifactSchema = z.object({
+  id: z.string(),
+  type: ArtifactTypeSchema,
+  uri: z.string(),
+  mimeType: z.string(),
+  metadata: z.record(z.unknown()).default({}),
+  sourceStep: z.string().optional(),
+  createdAt: z.string().datetime().optional()
+});
+var QualityGateActionSchema = z.enum(["fail", "retry", "warn"]);
+var QualityGateSchema = z.object({
+  type: z.enum(["llm-judge", "threshold", "dimension-check", "custom"]),
+  config: z.record(z.unknown()),
+  action: QualityGateActionSchema,
+  maxRetries: z.number().int().min(0).optional()
+});
+var BudgetConfigSchema = z.object({
+  maxUsd: z.number().nonnegative(),
+  onExceed: z.enum(["abort", "suspend"]),
+  warnAtPct: z.number().min(0).max(1).optional()
+});
+var CacheConfigSchema = z.object({
+  mode: z.enum(["use", "refresh", "skip"]).optional(),
+  ttlSeconds: z.number().int().positive().optional(),
+  scope: z.enum(["global", "tenant"]).optional()
+});
+var RouteCandidateSchema = z.object({
+  provider: z.string(),
+  model: z.string(),
+  maxQueueMs: z.number().int().positive().optional(),
+  maxUsd: z.number().nonnegative().optional(),
+  inputOverrides: z.record(z.unknown()).optional(),
+  weight: z.number().nonnegative().optional()
+});
+var RouteConfigSchema = z.object({
+  strategy: z.enum(["first-success", "cheapest-acceptable", "fastest"]),
+  candidates: z.array(RouteCandidateSchema).min(1),
+  timeoutMs: z.number().int().positive().optional(),
+  healthTtlMs: z.number().int().positive().optional()
+});
+var JudgeRubricSchema = z.object({
+  dimensions: z.array(
+    z.object({
+      name: z.string(),
+      weight: z.number().min(0).max(1),
+      description: z.string()
+    })
+  )
+});
+var JudgeConfigSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("llm-judge"),
+    criteria: z.string(),
+    model: z.string().optional(),
+    provider: z.string().optional(),
+    rubric: JudgeRubricSchema.optional()
+  }),
+  z.object({
+    type: z.literal("image-judge"),
+    criteria: z.enum(["clip-score", "aesthetic"]),
+    reference: z.string().optional()
+  }),
+  z.object({ type: z.literal("rule"), expression: z.string() }),
+  z.object({ type: z.literal("custom"), toolName: z.string() })
+]);
+var VariantsConfigSchema = z.object({
+  n: z.number().int().min(2).max(16),
+  seedStrategy: z.enum(["random", "sequential", "fixed-list"]).optional(),
+  seeds: z.array(z.number().int()).optional(),
+  judge: JudgeConfigSchema,
+  loserAction: z.enum(["archive", "discard"]).optional(),
+  perVariantCandidate: z.boolean().optional(),
+  minScore: z.number().min(0).max(1).optional()
+});
+var VoiceRefSchema = z.object({
+  provider: z.enum(["elevenlabs", "openai", "google", "deepgram-tts"]),
+  voiceId: z.string(),
+  settings: z.record(z.unknown()).optional()
+});
+var StyleRefSchema = z.object({
+  description: z.string(),
+  negative: z.string().optional(),
+  perProvider: z.record(z.object({ description: z.string().optional(), negative: z.string().optional() })).optional()
+});
+var BrandKitSchema = z.object({
+  primaryColor: z.string().optional(),
+  secondaryColor: z.string().optional(),
+  fontFamily: z.string().optional(),
+  logoArtifactId: z.string().optional(),
+  extras: z.record(z.unknown()).optional()
+});
+var ContextRefSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("voice"), name: z.string() }),
+  z.object({ kind: z.literal("style"), name: z.string() }),
+  z.object({ kind: z.literal("brand"), key: z.string() })
+]);
+var RunContextSchema = z.object({
+  voices: z.record(VoiceRefSchema).optional(),
+  styles: z.record(StyleRefSchema).optional(),
+  brandKit: BrandKitSchema.optional(),
+  vars: z.record(z.unknown()).optional()
+});
+var PipelineStepSchema = z.object({
+  id: z.string(),
+  operation: z.string(),
+  inputs: z.record(z.string()),
+  config: z.record(z.unknown()).default({}),
+  qualityGate: QualityGateSchema.optional(),
+  variants: VariantsConfigSchema.optional(),
+  gates: z.array(QualityGateSchema).optional(),
+  cache: CacheConfigSchema.optional(),
+  route: RouteConfigSchema.optional()
+});
+var PipelineStatusSchema = z.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "gated",
+  "cancelled"
+]);
+var PipelineSchema = z.object({
+  id: z.string(),
+  steps: z.array(PipelineStepSchema),
+  status: PipelineStatusSchema.default("pending"),
+  artifacts: z.map(z.string(), ArtifactSchema).default(/* @__PURE__ */ new Map()),
+  failedStep: z.string().optional(),
+  gatedStep: z.string().optional(),
+  currentStep: z.string().optional(),
+  completedSteps: z.array(z.string()).default([]),
+  startedAt: z.string().datetime().optional(),
+  completedAt: z.string().datetime().optional()
+});
+var PipelineDefinitionSchema = z.object({
+  id: z.string(),
+  steps: z.array(
+    z.object({
+      id: z.string(),
+      operation: z.string(),
+      inputs: z.record(z.string()),
+      config: z.record(z.unknown()).default({}),
+      qualityGate: QualityGateSchema.optional(),
+      variants: VariantsConfigSchema.optional(),
+      gates: z.array(QualityGateSchema).optional(),
+      cache: CacheConfigSchema.optional(),
+      route: RouteConfigSchema.optional()
+    })
+  ),
+  resumable: z.boolean().default(true).optional(),
+  budget: BudgetConfigSchema.optional(),
+  context: RunContextSchema.optional()
+});
+var ProviderInputSchema = z.object({
+  operation: z.string(),
+  inputs: z.record(z.unknown()),
+  config: z.record(z.unknown()).optional()
+});
+var ProviderOutputSchema = z.object({
+  artifact: ArtifactSchema,
+  cost_usd: z.number().optional(),
+  duration_ms: z.number().optional(),
+  metadata: z.record(z.unknown()).optional()
+});
+var QualityGateResultSchema = z.object({
+  passed: z.boolean(),
+  reasoning: z.string().optional(),
+  score: z.number().optional(),
+  action: QualityGateActionSchema
+});
+var PipelineEventTypeSchema = z.enum([
+  // Legacy
+  "pipeline:start",
+  "pipeline:complete",
+  "pipeline:failed",
+  "pipeline:gated",
+  "step:start",
+  "step:complete",
+  "step:failed",
+  "step:gated",
+  "step:retry",
+  // Spec-canonical (§0.1)
+  "run-created",
+  "run-started",
+  "run-completed",
+  "run-failed",
+  "run-suspended",
+  "run-resumed",
+  "step-started",
+  "step-progress",
+  "step-completed",
+  "step-failed",
+  "step-cached",
+  "step-gated"
+]);
+var PipelineEventSchema = z.object({
+  type: PipelineEventTypeSchema,
+  pipelineId: z.string(),
+  stepId: z.string().optional(),
+  artifactId: z.string().optional(),
+  timestamp: z.string().datetime(),
+  data: z.record(z.unknown()).optional()
+});
+var CostRecordSchema = z.object({
+  operation: z.string(),
+  provider: z.string(),
+  model: z.string().optional(),
+  cost_usd: z.number(),
+  artifactId: z.string().optional(),
+  pipelineId: z.string().optional(),
+  timestamp: z.string().datetime()
+});
+var CostSummarySchema = z.object({
+  total_usd: z.number(),
+  by_operation: z.map(z.string(), z.number()).default(/* @__PURE__ */ new Map()),
+  by_provider: z.map(z.string(), z.number()).default(/* @__PURE__ */ new Map()),
+  by_pipeline: z.map(z.string(), z.number()).default(/* @__PURE__ */ new Map())
+});
+var ArtifactMetaSchema = z.object({
+  id: z.string(),
+  type: ArtifactTypeSchema,
+  mimeType: z.string(),
+  size: z.number().optional(),
+  metadata: z.record(z.unknown()).optional(),
+  createdAt: z.string().datetime().optional(),
+  sourceStep: z.string().optional()
+});
+var StorageResultSchema = z.object({
+  data: z.instanceof(ReadableStream).or(z.instanceof(Buffer)),
+  meta: ArtifactMetaSchema
+});
+var ValidationResultSchema = z.object({
+  valid: z.boolean(),
+  errors: z.array(z.string()).default([]),
+  warnings: z.array(z.string()).default([]),
+  estimated_cost_usd: z.number().optional(),
+  estimated_duration_ms: z.number().optional()
+});
+
+// src/artifact-registry.ts
+import { v4 as uuidv4 } from "uuid";
+var ArtifactRegistry = class {
+  artifacts = /* @__PURE__ */ new Map();
+  register(artifact) {
+    return this.registerWithId(uuidv4(), artifact);
+  }
+  registerWithId(id, artifact) {
+    const fullArtifact = {
+      ...artifact,
+      id,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.artifacts.set(id, fullArtifact);
+    return fullArtifact;
+  }
+  get(id) {
+    return this.artifacts.get(id);
+  }
+  delete(id) {
+    return this.artifacts.delete(id);
+  }
+  list() {
+    return Array.from(this.artifacts.values());
+  }
+  findBySourceStep(stepId) {
+    let latest;
+    for (const artifact of this.artifacts.values()) {
+      if (artifact.sourceStep === stepId) {
+        if (!latest || artifact.createdAt && latest.createdAt && artifact.createdAt > latest.createdAt) {
+          latest = artifact;
+        }
+      }
+    }
+    return latest;
+  }
+  deleteBySourceStep(stepId) {
+    let deleted = 0;
+    for (const [id, artifact] of this.artifacts.entries()) {
+      if (artifact.sourceStep === stepId) {
+        this.artifacts.delete(id);
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  clear() {
+    this.artifacts.clear();
+  }
+  size() {
+    return this.artifacts.size;
+  }
+};
+
+// src/quality-gates/evaluator.ts
+var ThresholdEvaluator = class {
+  async evaluate(gate, artifact) {
+    const checks = gate.config.checks;
+    if (!Array.isArray(checks)) {
+      return {
+        passed: false,
+        reasoning: "Invalid threshold configuration: checks must be an array",
+        action: gate.action
+      };
+    }
+    const failures = [];
+    for (const check of checks) {
+      const { field, operator, value } = check;
+      const actual = field.startsWith("metadata.") ? this.getNestedValue({ metadata: artifact.metadata }, field) : this.getNestedValue(artifact.metadata, field);
+      if (actual === void 0) {
+        failures.push(`Field '${field}' not found in artifact metadata`);
+        continue;
+      }
+      const numActual = Number(actual);
+      if (Number.isNaN(numActual)) {
+        failures.push(`Field '${field}' is not numeric: ${actual}`);
+        continue;
+      }
+      const passed = this.compare(numActual, operator, value);
+      if (!passed) {
+        failures.push(`${field} (${numActual}) ${operator} ${value} failed`);
+      }
+    }
+    return {
+      passed: failures.length === 0,
+      reasoning: failures.length > 0 ? failures.join("; ") : "All checks passed",
+      action: gate.action
+    };
+  }
+  getNestedValue(obj, path) {
+    return path.split(".").reduce((current, key) => {
+      if (current === null || current === void 0) return void 0;
+      if (key === "__proto__" || key === "constructor" || key === "prototype") return void 0;
+      if (typeof current === "object") {
+        return current[key];
+      }
+      return void 0;
+    }, obj);
+  }
+  compare(actual, operator, expected) {
+    switch (operator) {
+      case ">=":
+        return actual >= expected;
+      case "<=":
+        return actual <= expected;
+      case ">":
+        return actual > expected;
+      case "<":
+        return actual < expected;
+      case "==":
+      case "===":
+        return actual === expected;
+      case "!=":
+        return actual !== expected;
+      default:
+        throw new Error(`Unknown operator: ${operator}`);
+    }
+  }
+};
+var DimensionCheckEvaluator = class {
+  async evaluate(gate, artifact) {
+    const { expectedWidth, expectedHeight, tolerance = 0 } = gate.config;
+    const width = expectedWidth;
+    const height = expectedHeight;
+    const tol = tolerance;
+    if (typeof width !== "number" || typeof height !== "number") {
+      return {
+        passed: false,
+        reasoning: "Invalid dimension-check configuration: expectedWidth and expectedHeight must be numbers",
+        action: gate.action
+      };
+    }
+    const actualWidth = artifact.metadata.width;
+    const actualHeight = artifact.metadata.height;
+    if (actualWidth === void 0 || actualHeight === void 0) {
+      return {
+        passed: false,
+        reasoning: "Artifact missing width or height metadata",
+        action: gate.action
+      };
+    }
+    const widthDiff = Math.abs(actualWidth - width);
+    const heightDiff = Math.abs(actualHeight - height);
+    const widthTolerance = width * tol;
+    const heightTolerance = height * tol;
+    const widthOk = widthDiff <= widthTolerance;
+    const heightOk = heightDiff <= heightTolerance;
+    if (widthOk && heightOk) {
+      return {
+        passed: true,
+        reasoning: `Dimensions ${actualWidth}x${actualHeight} match expected ${width}x${height} within ${tol * 100}% tolerance`,
+        action: gate.action
+      };
+    }
+    return {
+      passed: false,
+      reasoning: `Dimensions ${actualWidth}x${actualHeight} do not match expected ${width}x${height} within ${tol * 100}% tolerance`,
+      action: gate.action
+    };
+  }
+};
+var LLMJudgeEvaluator = class {
+  evaluateFn;
+  constructor(evaluateFn) {
+    this.evaluateFn = evaluateFn;
+  }
+  async evaluate(gate, artifact) {
+    const { prompt, timeout } = gate.config;
+    if (typeof prompt !== "string") {
+      return {
+        passed: false,
+        reasoning: "Invalid LLM-judge configuration: prompt must be a string",
+        action: gate.action
+      };
+    }
+    const timeoutMs = typeof timeout === "number" ? timeout : 3e4;
+    try {
+      let timeoutId;
+      const result = await Promise.race([
+        this.evaluateFn(prompt, artifact),
+        new Promise((_, reject) => {
+          timeoutId = setTimeout(
+            () => reject(new Error(`LLM-judge timeout after ${timeoutMs}ms`)),
+            timeoutMs
+          );
+        })
+      ]);
+      if (timeoutId) clearTimeout(timeoutId);
+      return {
+        passed: result.pass,
+        reasoning: result.reasoning,
+        score: result.score,
+        action: gate.action
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        reasoning: `LLM-judge evaluation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        action: gate.action
+      };
+    }
+  }
+};
+var CustomEvaluator = class {
+  checkFn;
+  constructor(checkFn) {
+    this.checkFn = checkFn;
+  }
+  async evaluate(gate, artifact) {
+    try {
+      const passed = await this.checkFn(artifact, gate.config);
+      return {
+        passed,
+        reasoning: passed ? "Custom check passed" : "Custom check failed",
+        action: gate.action
+      };
+    } catch (error) {
+      return {
+        passed: false,
+        reasoning: `Custom check error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        action: gate.action
+      };
+    }
+  }
+};
+function createQualityGateEvaluator(gate, llmJudgeFn, customCheckFn) {
+  switch (gate.type) {
+    case "threshold":
+      return new ThresholdEvaluator();
+    case "dimension-check":
+      return new DimensionCheckEvaluator();
+    case "llm-judge":
+      if (!llmJudgeFn) {
+        throw new Error("LLM-judge evaluator requires an evaluate function");
+      }
+      return new LLMJudgeEvaluator(llmJudgeFn);
+    case "custom":
+      if (!customCheckFn) {
+        throw new Error("Custom evaluator requires a check function to be provided");
+      }
+      return new CustomEvaluator(customCheckFn);
+    default:
+      throw new Error(`Unknown quality gate type: ${gate.type}`);
+  }
+}
+
+// src/pipeline-validator.ts
+var PipelineValidator = class {
+  providerAvailability;
+  constructor(providerAvailability) {
+    this.providerAvailability = providerAvailability;
+  }
+  validate(definition) {
+    const errors = [];
+    const warnings = [];
+    const schemaResult = PipelineDefinitionSchema.safeParse(definition);
+    if (!schemaResult.success) {
+      errors.push("Pipeline definition schema validation failed");
+      for (const issue of schemaResult.error.issues) {
+        errors.push(`  - ${issue.path.join(".")}: ${issue.message}`);
+      }
+      return { valid: false, errors, warnings };
+    }
+    const stepIds = /* @__PURE__ */ new Set();
+    for (const step of definition.steps) {
+      if (stepIds.has(step.id)) {
+        errors.push(`Duplicate step ID: ${step.id}`);
+      }
+      if (step.id.includes("..") || step.id.includes("/") || step.id.includes("\\")) {
+        errors.push(`Invalid step ID '${step.id}': contains path traversal characters`);
+      }
+      stepIds.add(step.id);
+    }
+    const referenceErrors = this.validateReferences(definition);
+    errors.push(...referenceErrors);
+    const providerErrors = this.validateProviders(definition);
+    errors.push(...providerErrors);
+    const gateWarnings = this.validateQualityGates(definition);
+    warnings.push(...gateWarnings);
+    let estimatedCost = 0;
+    let estimatedDuration = 0;
+    for (const step of definition.steps) {
+      if (this.providerAvailability.isAvailable(step.operation)) {
+        estimatedCost += this.providerAvailability.getEstimatedCost(step.operation, step.config);
+        estimatedDuration += this.providerAvailability.getEstimatedDuration(
+          step.operation,
+          step.config
+        );
+      } else {
+        warnings.push(`Provider not available for operation: ${step.operation}`);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      estimated_cost_usd: estimatedCost,
+      estimated_duration_ms: estimatedDuration
+    };
+  }
+  validateReferences(definition) {
+    const errors = [];
+    const definedStepIds = new Set(definition.steps.map((s) => s.id));
+    const outputReferences = /* @__PURE__ */ new Map();
+    for (const step of definition.steps) {
+      for (const [paramName, inputValue] of Object.entries(step.inputs)) {
+        const match = inputValue.match(/^\{\{(\w+)\.output\}\}$/);
+        if (match) {
+          const referencedStepId = match[1];
+          if (!definedStepIds.has(referencedStepId)) {
+            errors.push(
+              `Step '${step.id}' references non-existent step '${referencedStepId}' in input '${paramName}'`
+            );
+            continue;
+          }
+          const referencedIndex = definition.steps.findIndex((s) => s.id === referencedStepId);
+          const currentIndex = definition.steps.findIndex((s) => s.id === step.id);
+          if (referencedIndex >= currentIndex) {
+            errors.push(
+              `Step '${step.id}' references future step '${referencedStepId}' (circular/forward reference not allowed)`
+            );
+          }
+          if (!outputReferences.has(referencedStepId)) {
+            outputReferences.set(referencedStepId, step.id);
+          }
+        }
+      }
+    }
+    return errors;
+  }
+  validateProviders(definition) {
+    const errors = [];
+    for (const step of definition.steps) {
+      if (!this.providerAvailability.isAvailable(step.operation)) {
+        errors.push(`No provider available for operation '${step.operation}' in step '${step.id}'`);
+      }
+    }
+    return errors;
+  }
+  validateQualityGates(definition) {
+    const warnings = [];
+    for (const step of definition.steps) {
+      if (step.qualityGate) {
+        const gate = step.qualityGate;
+        if (gate.action === "retry" && gate.maxRetries === void 0) {
+          warnings.push(
+            `Step '${step.id}' has retry action but no maxRetries specified (defaulting to 1)`
+          );
+        }
+        if (gate.type === "llm-judge" && !gate.config.prompt) {
+          warnings.push(`Step '${step.id}' has llm-judge gate without a prompt`);
+        }
+        if (gate.type === "threshold" && !Array.isArray(gate.config.checks)) {
+          warnings.push(`Step '${step.id}' has threshold gate without checks configured`);
+        }
+        if (gate.type === "dimension-check" && (gate.config.expectedWidth === void 0 || gate.config.expectedHeight === void 0)) {
+          warnings.push(`Step '${step.id}' has dimension-check gate without expected dimensions`);
+        }
+      }
+      const stepExt = step;
+      if (stepExt.gates && Array.isArray(stepExt.gates)) {
+        for (let gi = 0; gi < stepExt.gates.length; gi++) {
+          const gate = stepExt.gates[gi];
+          if (gate.action === "retry" && gate.maxRetries === void 0) {
+            warnings.push(
+              `Step '${step.id}' gate[${gi}] has retry action but no maxRetries specified`
+            );
+          }
+        }
+      }
+    }
+    this.validateBudgetConfig(definition, warnings);
+    this.validateVariantsConfig(definition, warnings);
+    this.validateRunContext(definition, warnings);
+    return warnings;
+  }
+  validateBudgetConfig(definition, warnings) {
+    const budget = definition.budget;
+    if (budget) {
+      if (budget.maxUsd !== void 0 && budget.maxUsd <= 0) {
+        warnings.push("Budget maxUsd must be greater than 0");
+      }
+      if (budget.onExceed && !["abort", "suspend"].includes(budget.onExceed)) {
+        warnings.push(`Budget onExceed must be 'abort' or 'suspend', got '${budget.onExceed}'`);
+      }
+    }
+  }
+  validateVariantsConfig(definition, warnings) {
+    for (const step of definition.steps) {
+      const variants = step.variants;
+      if (variants) {
+        if (variants.n !== void 0 && (variants.n < 2 || variants.n > 16)) {
+          warnings.push(`Step '${step.id}' variants.n must be between 2 and 16, got ${variants.n}`);
+        }
+        if (variants.seedStrategy !== void 0 && !["random", "sequential", "fixed-list"].includes(variants.seedStrategy)) {
+          warnings.push(
+            `Step '${step.id}' variants.seedStrategy must be one of random, sequential, fixed-list`
+          );
+        }
+        if (!variants.judge) {
+          warnings.push(`Step '${step.id}' has variants without a judge configuration`);
+        }
+      }
+    }
+  }
+  validateRunContext(definition, warnings) {
+    const context = definition.context;
+    if (context) {
+      if (context.voices) {
+        for (const [name, ref] of Object.entries(context.voices)) {
+          const voiceRef = ref;
+          if (voiceRef.provider && !["elevenlabs", "openai", "google", "deepgram-tts"].includes(voiceRef.provider)) {
+            warnings.push(`Context voice '${name}' has unknown provider '${voiceRef.provider}'`);
+          }
+        }
+      }
+      if (context.styles) {
+        for (const [name] of Object.entries(context.styles)) {
+          if (name.includes("..") || name.includes("/")) {
+            warnings.push(`Context style name '${name}' contains invalid characters`);
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/pipeline-executor.ts
+import { randomUUID } from "crypto";
+
+// src/errors.ts
+var A2AError = class extends Error {
+  code;
+  retryable;
+  constructor(message) {
+    super(message);
+    this.name = "A2AError";
+    this.code = "A2A_ERROR";
+    this.retryable = false;
+  }
+};
+var IdempotencyConflictError = class extends A2AError {
+  constructor(reason, existingRunId) {
+    super(
+      `Idempotency conflict: ${reason}${existingRunId ? ` (existing run: ${existingRunId})` : ""}`
+    );
+    this.reason = reason;
+    this.existingRunId = existingRunId;
+  }
+  reason;
+  existingRunId;
+  code = "IDEMPOTENCY_CONFLICT";
+  retryable = false;
+};
+var BudgetExceededError = class extends A2AError {
+  constructor(spentUsd, capUsd, scope) {
+    super(`Budget exceeded: $${spentUsd} spent, $${capUsd} cap (${scope})`);
+    this.spentUsd = spentUsd;
+    this.capUsd = capUsd;
+    this.scope = scope;
+  }
+  spentUsd;
+  capUsd;
+  scope;
+  code = "BUDGET_EXCEEDED";
+  retryable = false;
+};
+var RunNotFoundError = class extends A2AError {
+  code = "RUN_NOT_FOUND";
+  retryable = false;
+  constructor() {
+    super("Run not found");
+  }
+};
+var RunInProgressError = class extends A2AError {
+  code = "RUN_IN_PROGRESS";
+  retryable = true;
+  constructor() {
+    super("Run is already in progress");
+  }
+};
+var RunNotResumableError = class extends A2AError {
+  code = "RUN_NOT_RESUMABLE";
+  retryable = false;
+  constructor() {
+    super("Run is not resumable");
+  }
+};
+var WebhookSignatureInvalidError = class extends A2AError {
+  code = "WEBHOOK_SIGNATURE_INVALID";
+  retryable = false;
+  constructor() {
+    super("Webhook signature is invalid");
+  }
+};
+var WebhookProviderUnknownError = class extends A2AError {
+  code = "WEBHOOK_PROVIDER_UNKNOWN";
+  retryable = false;
+  constructor() {
+    super("Webhook provider is unknown");
+  }
+};
+var StateStoreUnavailableError = class extends A2AError {
+  code = "STATE_STORE_UNAVAILABLE";
+  retryable = true;
+  constructor() {
+    super("State store is unavailable");
+  }
+};
+var EstimateUnsupportedError = class extends A2AError {
+  code = "ESTIMATE_UNSUPPORTED";
+  retryable = false;
+  constructor() {
+    super("Cost estimation is not supported for this operation");
+  }
+};
+var ArtifactNotFoundError = class extends A2AError {
+  code = "ARTIFACT_NOT_FOUND";
+  retryable = false;
+  constructor() {
+    super("Artifact not found");
+  }
+};
+var RouterAllCandidatesFailedError = class extends A2AError {
+  constructor(attemptedCandidates, lastError) {
+    super(`All router candidates failed: ${attemptedCandidates.join(", ")}`);
+    this.attemptedCandidates = attemptedCandidates;
+    this.lastError = lastError;
+  }
+  attemptedCandidates;
+  lastError;
+  code = "ROUTER_ALL_CANDIDATES_FAILED";
+  retryable = false;
+};
+var RouterNoCandidatesError = class extends A2AError {
+  code = "ROUTER_NO_CANDIDATES";
+  retryable = false;
+  constructor() {
+    super("No eligible router candidates found");
+  }
+};
+var RouterFastestIneligibleError = class extends A2AError {
+  code = "ROUTER_FASTEST_INELIGIBLE";
+  retryable = false;
+  constructor() {
+    super("Fastest router candidate is ineligible");
+  }
+};
+var SafetyGateRejectedError = class extends A2AError {
+  constructor(category, score) {
+    super(`Safety gate rejected: ${category} (score: ${score})`);
+    this.category = category;
+    this.score = score;
+  }
+  category;
+  score;
+  code = "SAFETY_GATE_REJECTED";
+  retryable = false;
+};
+var TenantNotFoundError = class extends A2AError {
+  code = "TENANT_NOT_FOUND";
+  retryable = false;
+  constructor() {
+    super("Tenant not found");
+  }
+};
+var KeyVaultUnavailableError = class extends A2AError {
+  code = "KEY_VAULT_UNAVAILABLE";
+  retryable = true;
+  constructor() {
+    super("Key vault is unavailable");
+  }
+};
+var FfmpegUnavailableError = class extends A2AError {
+  code = "FFMPEG_UNAVAILABLE";
+  retryable = false;
+};
+var VariantsAllRejectedError = class extends A2AError {
+  constructor(reason) {
+    super();
+    this.reason = reason;
+  }
+  reason;
+  code = "VARIANTS_ALL_REJECTED";
+  retryable = false;
+};
+var JudgeUnavailableError = class extends A2AError {
+  code = "JUDGE_UNAVAILABLE";
+  retryable = true;
+};
+var WorkflowNotFoundError = class extends A2AError {
+  constructor(workflowName) {
+    super(workflowName ? `Workflow not found: ${workflowName}` : "Workflow not found");
+    this.workflowName = workflowName;
+  }
+  workflowName;
+  code = "WORKFLOW_NOT_FOUND";
+  retryable = false;
+};
+var WorkflowExpiredError = class extends A2AError {
+  constructor(detail) {
+    super(
+      `Workflow expired${detail ? `: ${detail}` : " \u2014 did not complete within retention period"}`
+    );
+    this.detail = detail;
+  }
+  detail;
+  code = "WORKFLOW_EXPIRED";
+  retryable = false;
+};
+var ContextRefUnknownError = class extends A2AError {
+  constructor(kind, name) {
+    super();
+    this.kind = kind;
+    this.name = name;
+  }
+  kind;
+  name;
+  code = "CONTEXT_REF_UNKNOWN";
+  retryable = false;
+};
+var ContextRefTypeError = class extends A2AError {
+  constructor(stepOp, refKind) {
+    super();
+    this.stepOp = stepOp;
+    this.refKind = refKind;
+  }
+  stepOp;
+  refKind;
+  code = "CONTEXT_REF_TYPE_MISMATCH";
+  retryable = false;
+};
+var LoudnessGateFailedError = class extends A2AError {
+  code = "LOUDNESS_GATE_FAILED";
+  retryable = false;
+};
+var TenantPolicyViolationError = class extends A2AError {
+  code = "TENANT_POLICY_VIOLATION";
+  retryable = false;
+};
+var ProvenanceSigningFailedError = class extends A2AError {
+  code = "PROVENANCE_SIGNING_FAILED";
+  retryable = false;
+};
+var SafetyProviderUnavailableError = class extends A2AError {
+  code = "SAFETY_PROVIDER_UNAVAILABLE";
+  retryable = true;
+};
+var RatioUnsupportedError = class extends A2AError {
+  constructor(ratio, provider) {
+    super(`Ratio ${ratio} not natively supported by provider ${provider}`);
+    this.ratio = ratio;
+    this.provider = provider;
+  }
+  ratio;
+  provider;
+  code = "RATIO_UNSUPPORTED";
+  retryable = false;
+};
+var InvalidInputError = class extends A2AError {
+  constructor(reason) {
+    super(`Invalid input: ${reason}`);
+    this.reason = reason;
+  }
+  reason;
+  code = "INVALID_INPUT";
+  retryable = false;
+};
+var FormatUnsupportedError = class extends A2AError {
+  constructor(format, operation) {
+    super(`Format unsupported: ${format} for ${operation}`);
+    this.format = format;
+    this.operation = operation;
+  }
+  format;
+  operation;
+  code = "FORMAT_UNSUPPORTED";
+  retryable = false;
+};
+var ArtifactAccessDeniedError = class extends A2AError {
+  code = "ARTIFACT_ACCESS_DENIED";
+  retryable = false;
+};
+var InvalidResourceUriError = class extends A2AError {
+  constructor(uri) {
+    super(uri ? `Invalid resource URI: ${uri}` : "Invalid resource URI");
+    this.uri = uri;
+  }
+  uri;
+  code = "INVALID_RESOURCE_URI";
+  retryable = false;
+};
+
+// src/pipeline-executor.ts
+var LEGACY_TO_SPEC_EVENT = {
+  "pipeline:start": "run-started",
+  "pipeline:complete": "run-completed",
+  "pipeline:failed": "run-failed",
+  "pipeline:gated": "run-suspended",
+  "step:start": "step-started",
+  "step:complete": "step-completed",
+  "step:failed": "step-failed",
+  "step:gated": "step-gated"
+};
+function createStepStateRecord(stepId, status) {
+  return { stepId, status: status ?? "pending", attempts: 0 };
+}
+var PipelineExecutor = class {
+  registry;
+  providers = /* @__PURE__ */ new Map();
+  defaultPipelineTimeoutMs;
+  llmJudgeFn;
+  customCheckFn;
+  prepareInputs;
+  persistArtifact;
+  onEvent;
+  onCost;
+  persistence;
+  ledger;
+  routeStepFn;
+  variantsStepFn;
+  ratiosStepFn;
+  context;
+  contextResolveFn;
+  gateEvalFn;
+  tenantPolicyEnforceFn;
+  signProvenance;
+  constructor(options) {
+    this.registry = new ArtifactRegistry();
+    this.defaultPipelineTimeoutMs = options.defaultPipelineTimeoutMs ?? 3e5;
+    this.llmJudgeFn = options.llmJudgeFn;
+    this.customCheckFn = options.customCheckFn;
+    this.prepareInputs = options.prepareInputs;
+    this.persistArtifact = options.persistArtifact;
+    for (const provider of options.providers) {
+      for (const op of provider.supportedOperations) {
+        this.providers.set(op, provider);
+      }
+    }
+    this.onEvent = options.onEvent;
+    this.onCost = options.onCost;
+    this.persistence = options.persistence;
+    this.ledger = options.ledger;
+    this.routeStepFn = options.routeStepFn;
+    this.variantsStepFn = options.variantsStepFn;
+    this.ratiosStepFn = options.ratiosStepFn;
+    this.context = options.context;
+    this.contextResolveFn = options.contextResolveFn;
+    this.gateEvalFn = options.gateEvalFn;
+    this.tenantPolicyEnforceFn = options.tenantPolicyEnforceFn;
+    this.signProvenance = options.signProvenance;
+  }
+  async execute(definition, options) {
+    const pipeline = {
+      id: definition.id,
+      steps: definition.steps,
+      status: "running",
+      artifacts: /* @__PURE__ */ new Map(),
+      completedSteps: [],
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const stepStates = definition.steps.map(
+      (s) => createStepStateRecord(s.id, "pending")
+    );
+    const runId = options?.runId ?? randomUUID();
+    this.currentPipelineDefHash = this.hashPipelineDefinition(definition);
+    const budget = definition.budget;
+    let runCost = 0;
+    if (this.persistence) {
+      const runRecord = {
+        runId,
+        pipelineId: definition.id,
+        status: "running",
+        definition,
+        stepStates,
+        artifacts: {},
+        totalCostUsd: 0,
+        startedAt: pipeline.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        resumable: definition.resumable ?? true
+      };
+      await this.persistence.createRun(runRecord);
+    }
+    this.emitEvent({
+      type: "pipeline:start",
+      pipelineId: pipeline.id,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data: { runId }
+    });
+    const pipelineTimeout = setTimeout(() => {
+      if (pipeline.status === "running") {
+        pipeline.status = "failed";
+        pipeline.failedStep = pipeline.currentStep;
+        this.emitEvent({
+          type: "pipeline:failed",
+          pipelineId: pipeline.id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { reason: "Pipeline timeout exceeded" }
+        });
+      }
+    }, this.defaultPipelineTimeoutMs);
+    try {
+      for (let stepIndex = 0; stepIndex < pipeline.steps.length; stepIndex++) {
+        const step = pipeline.steps[stepIndex];
+        pipeline.currentStep = step.id;
+        if (budget) {
+          stepStates[stepIndex].status = "running";
+          await this.updateRunState(runId, stepStates);
+          const estimate = await this.quickEstimateStep(step, budget);
+          if (runCost + estimate.usdHigh > budget.maxUsd) {
+            if (budget.onExceed === "abort") {
+              throw new BudgetExceededError(runCost + estimate.usdHigh, budget.maxUsd, "run");
+            }
+            pipeline.status = "gated";
+            pipeline.gatedStep = step.id;
+            stepStates[stepIndex].status = "gated";
+            await this.updateRunState(runId, stepStates, runCost);
+            this.emitEvent({
+              type: "pipeline:gated",
+              pipelineId: pipeline.id,
+              stepId: step.id,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              data: {
+                reason: `Budget preflight: $${estimate.usdHigh} would exceed $${budget.maxUsd}`
+              }
+            });
+            break;
+          }
+        }
+        const result = await this.executeStep(step, pipeline);
+        if (pipeline.status === "failed") {
+          stepStates[stepIndex].status = "failed";
+          await this.updateRunState(runId, stepStates, runCost);
+          break;
+        }
+        if (result.status === "failed") {
+          pipeline.status = "failed";
+          pipeline.failedStep = step.id;
+          stepStates[stepIndex].status = "failed";
+          await this.updateRunState(runId, stepStates, runCost);
+          this.emitEvent({
+            type: "pipeline:failed",
+            pipelineId: pipeline.id,
+            stepId: step.id,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          break;
+        }
+        if (result.status === "gated") {
+          pipeline.status = "gated";
+          pipeline.gatedStep = step.id;
+          stepStates[stepIndex].status = "gated";
+          await this.updateRunState(runId, stepStates, runCost);
+          this.emitEvent({
+            type: "pipeline:gated",
+            pipelineId: pipeline.id,
+            stepId: step.id,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          break;
+        }
+        if (result.artifact) {
+          pipeline.artifacts.set(result.artifact.id, result.artifact);
+        }
+        stepStates[stepIndex].status = "completed";
+        stepStates[stepIndex].artifactId = result.artifact?.id;
+        pipeline.completedSteps.push(step.id);
+        const stepCost = result.costUsd ?? 0;
+        if (stepCost > 0) {
+          const prior = runCost;
+          runCost += stepCost;
+          if (budget) {
+            const warnAtPct = budget.warnAtPct ?? 0.8;
+            const threshold = warnAtPct * budget.maxUsd;
+            if (prior < threshold && runCost >= threshold) {
+              this.emitEvent({
+                type: "step-progress",
+                pipelineId: pipeline.id,
+                stepId: step.id,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                data: {
+                  budgetWarning: true,
+                  costUsdAccrued: runCost,
+                  warnAtPct,
+                  maxUsd: budget.maxUsd
+                }
+              });
+            }
+          }
+        }
+      }
+      if (pipeline.status === "running") {
+        pipeline.status = "completed";
+        await this.updateRunState(runId, stepStates, runCost, "completed");
+        this.emitEvent({
+          type: "pipeline:complete",
+          pipelineId: pipeline.id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    } catch (error) {
+      pipeline.status = "failed";
+      pipeline.failedStep = pipeline.currentStep;
+      await this.updateRunState(runId, stepStates, runCost, "failed", error);
+      this.emitEvent({
+        type: "pipeline:failed",
+        pipelineId: pipeline.id,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: { error: error instanceof Error ? error.message : "Unknown error" }
+      });
+    } finally {
+      clearTimeout(pipelineTimeout);
+      pipeline.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      pipeline.currentStep = void 0;
+    }
+    return pipeline;
+  }
+  async resume(first, second) {
+    if (typeof first === "string") {
+      return this.resumeByRunId(first, second);
+    }
+    return this.resumeLegacy(first, second);
+  }
+  async resumeByRunId(runId, fromStepId) {
+    if (!this.persistence) {
+      throw new Error("Persistence store required for resume");
+    }
+    const acquired = await this.persistence.acquireLock(runId);
+    if (!acquired) {
+      throw new RunInProgressError();
+    }
+    try {
+      const run = await this.persistence.getRun(runId);
+      if (!run) {
+        throw new Error(`Run not found: ${runId}`);
+      }
+      if (run.status === "completed" || run.status === "cancelled") {
+        throw new RunNotResumableError();
+      }
+      if (run.resumable === false) {
+        throw new RunNotResumableError();
+      }
+      const pipeline = {
+        id: run.pipelineId,
+        steps: run.definition.steps,
+        status: "running",
+        artifacts: /* @__PURE__ */ new Map(),
+        completedSteps: [],
+        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const stepStates = [...run.stepStates];
+      const runCost = run.totalCostUsd;
+      const budget = run.definition.budget;
+      this.currentPipelineDefHash = this.hashPipelineDefinition(run.definition);
+      for (const [stepId, artifactId] of Object.entries(run.artifacts)) {
+        const step = run.definition.steps.find((s) => s.id === stepId);
+        if (step) {
+          const art = {
+            id: artifactId,
+            type: "image",
+            uri: `run://${runId}/${artifactId}`,
+            mimeType: "application/octet-stream",
+            metadata: {},
+            sourceStep: stepId,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          this.registry.registerWithId(artifactId, art);
+          pipeline.artifacts.set(artifactId, art);
+        }
+      }
+      const startStepIndex = fromStepId ? run.definition.steps.findIndex((s) => s.id === fromStepId) : run.stepStates.findIndex(
+        (s) => s.status !== "completed" && s.status !== "skipped" && s.status !== "cached"
+      );
+      if (startStepIndex === -1) {
+        pipeline.status = "completed";
+        return pipeline;
+      }
+      for (let i = 0; i < startStepIndex; i++) {
+        if (stepStates[i].status !== "completed") {
+          stepStates[i].status = "skipped";
+        }
+        if (stepStates[i].artifactId) {
+          pipeline.completedSteps.push(run.definition.steps[i].id);
+        }
+      }
+      for (let i = startStepIndex; i < stepStates.length; i++) {
+        stepStates[i].attempts = 0;
+      }
+      await this.persistence.updateRun(runId, {
+        status: "running",
+        stepStates
+      });
+      for (let i = startStepIndex; i < run.definition.steps.length; i++) {
+        const step = run.definition.steps[i];
+        pipeline.currentStep = step.id;
+        if (stepStates[i].status === "completed" || stepStates[i].status === "cached") {
+          pipeline.completedSteps.push(step.id);
+          continue;
+        }
+        if (budget) {
+          stepStates[i].status = "running";
+          await this.persistence.updateRun(runId, { stepStates });
+          const estimate = await this.quickEstimateStep(step, budget);
+          if (runCost + estimate.usdHigh > budget.maxUsd) {
+            if (budget.onExceed === "abort") {
+              throw new BudgetExceededError(runCost + estimate.usdHigh, budget.maxUsd, "run");
+            }
+            pipeline.status = "gated";
+            pipeline.gatedStep = step.id;
+            stepStates[i].status = "gated";
+            await this.persistence.updateRun(runId, {
+              status: "gated",
+              stepStates,
+              totalCostUsd: runCost
+            });
+            break;
+          }
+        }
+        const result = await this.executeStep(step, pipeline);
+        if (result.status === "failed") {
+          pipeline.status = "failed";
+          pipeline.failedStep = step.id;
+          stepStates[i].status = "failed";
+          await this.persistence.updateRun(runId, {
+            status: "failed",
+            stepStates,
+            totalCostUsd: runCost
+          });
+          break;
+        }
+        if (result.status === "gated") {
+          pipeline.status = "gated";
+          pipeline.gatedStep = step.id;
+          stepStates[i].status = "gated";
+          await this.persistence.updateRun(runId, {
+            status: "gated",
+            stepStates,
+            totalCostUsd: runCost
+          });
+          break;
+        }
+        if (result.artifact) {
+          pipeline.artifacts.set(result.artifact.id, result.artifact);
+        }
+        stepStates[i].status = "completed";
+        stepStates[i].artifactId = result.artifact?.id;
+        pipeline.completedSteps.push(step.id);
+      }
+      if (pipeline.status === "running") {
+        pipeline.status = "completed";
+        await this.persistence.updateRun(runId, {
+          status: "completed",
+          stepStates,
+          totalCostUsd: runCost,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          error: void 0
+        });
+      }
+      pipeline.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      pipeline.currentStep = void 0;
+      return pipeline;
+    } finally {
+      await this.persistence.releaseLock(runId);
+    }
+  }
+  async resumeLegacy(pipeline, action) {
+    if (pipeline.status !== "gated" && pipeline.status !== "failed") {
+      throw new Error(`Cannot resume pipeline with status: ${pipeline.status}`);
+    }
+    if (action === "abort") {
+      pipeline.status = "failed";
+      pipeline.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return pipeline;
+    }
+    const resumeStepId = pipeline.status === "gated" ? pipeline.gatedStep : pipeline.failedStep;
+    const resumeStepLabel = pipeline.status === "gated" ? "gated" : "failed";
+    const resumeStepIndex = pipeline.steps.findIndex((s) => s.id === resumeStepId);
+    if (!resumeStepId || resumeStepIndex === -1) {
+      throw new Error(
+        `${resumeStepLabel[0].toUpperCase() + resumeStepLabel.slice(1)} step not found`
+      );
+    }
+    if (action === "skip") {
+      const resumeStep = pipeline.steps[resumeStepIndex];
+      if (!pipeline.completedSteps.includes(resumeStep.id)) {
+        pipeline.completedSteps.push(resumeStep.id);
+      }
+      pipeline.status = "running";
+      pipeline.gatedStep = void 0;
+      pipeline.failedStep = void 0;
+      for (let i = resumeStepIndex + 1; i < pipeline.steps.length; i++) {
+        const step = pipeline.steps[i];
+        pipeline.currentStep = step.id;
+        const result = await this.executeStep(step, pipeline);
+        if (result.status === "failed") {
+          pipeline.status = "failed";
+          pipeline.failedStep = step.id;
+          break;
+        }
+        if (result.status === "gated") {
+          pipeline.status = "gated";
+          pipeline.gatedStep = step.id;
+          break;
+        }
+        if (result.artifact) {
+          pipeline.artifacts.set(result.artifact.id, result.artifact);
+        }
+        pipeline.completedSteps.push(step.id);
+      }
+      if (pipeline.status === "running") {
+        pipeline.status = "completed";
+      }
+    } else if (action === "retry") {
+      const step = pipeline.steps[resumeStepIndex];
+      const existingArtifact = this.registry.findBySourceStep(step.id);
+      if (existingArtifact) {
+        this.registry.delete(existingArtifact.id);
+        pipeline.artifacts.delete(existingArtifact.id);
+      }
+      const stepsAfterGate = pipeline.completedSteps.filter((s) => {
+        const index = pipeline.steps.findIndex((ps) => ps.id === s);
+        return index >= resumeStepIndex;
+      });
+      pipeline.completedSteps = pipeline.completedSteps.filter((s) => !stepsAfterGate.includes(s));
+      pipeline.status = "running";
+      pipeline.gatedStep = void 0;
+      pipeline.failedStep = void 0;
+      for (let i = resumeStepIndex; i < pipeline.steps.length; i++) {
+        const currentStep = pipeline.steps[i];
+        pipeline.currentStep = currentStep.id;
+        const result = await this.executeStep(currentStep, pipeline);
+        if (result.status === "failed") {
+          pipeline.status = "failed";
+          pipeline.failedStep = currentStep.id;
+          break;
+        }
+        if (result.status === "gated") {
+          pipeline.status = "gated";
+          pipeline.gatedStep = currentStep.id;
+          break;
+        }
+        if (result.artifact) {
+          pipeline.artifacts.set(result.artifact.id, result.artifact);
+        }
+        if (!pipeline.completedSteps.includes(currentStep.id)) {
+          pipeline.completedSteps.push(currentStep.id);
+        }
+      }
+      if (pipeline.status === "running") {
+        pipeline.status = "completed";
+      }
+    }
+    pipeline.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    pipeline.currentStep = void 0;
+    return pipeline;
+  }
+  async estimate(definition) {
+    const perStep = [];
+    const warnings = [];
+    for (const step of definition.steps) {
+      const provider = this.providers.get(step.operation);
+      if (!provider) {
+        warnings.push({
+          stepId: step.id,
+          code: "no-estimator",
+          message: `No provider available for operation '${step.operation}'`
+        });
+        perStep.push({
+          stepId: step.id,
+          operation: step.operation,
+          provider: "unknown",
+          modelId: step.config?.model ?? "default",
+          usdLow: 0,
+          usdHigh: 0.01,
+          estimable: false,
+          fallbackUsed: "default-bound"
+        });
+        continue;
+      }
+      const estimate = await this.quickEstimateStep(step);
+      const stepEntry = {
+        stepId: step.id,
+        operation: step.operation,
+        provider: provider.name,
+        modelId: step.config?.model ?? "default",
+        usdLow: estimate.usdLow,
+        usdHigh: estimate.usdHigh,
+        estimable: estimate.estimable
+      };
+      if (!estimate.estimable) {
+        stepEntry.fallbackUsed = "default-bound";
+        warnings.push({
+          stepId: step.id,
+          code: "no-estimator",
+          message: `Provider '${provider.name}' did not return an estimate for '${step.operation}'`
+        });
+      }
+      const maxTokens = step.inputs?.max_tokens;
+      if (typeof maxTokens === "number" && maxTokens > 0) {
+        warnings.push({
+          stepId: step.id,
+          code: "variable-output",
+          message: `Step '${step.id}' has variable output (max_tokens=${maxTokens}); usdLow uses ~30% of cap, usdHigh uses 100%`
+        });
+      }
+      perStep.push(stepEntry);
+      const stepRoute = step.route;
+      if (stepRoute?.candidates && stepRoute.candidates.length > 1) {
+        warnings.push({
+          stepId: step.id,
+          code: "router-spread",
+          message: `Step '${step.id}' routes across ${stepRoute.candidates.length} candidates, estimates may vary`
+        });
+      }
+      for (const inputVal of Object.values(step.inputs)) {
+        if (inputVal.includes("{{") && inputVal.includes(".output}}")) {
+          warnings.push({
+            stepId: step.id,
+            code: "depends-on-prior-step",
+            message: `Step '${step.id}' cost depends on variable output from prior step`
+          });
+          break;
+        }
+      }
+    }
+    const totalUsdLow = perStep.reduce((s, e) => s + e.usdLow, 0);
+    const totalUsdHigh = perStep.reduce((s, e) => s + e.usdHigh, 0);
+    return { totalUsdLow, totalUsdHigh, perStep, warnings };
+  }
+  // ─── Private Methods ──────────────────────────────────────────────────────
+  async updateRunState(runId, stepStates, totalCostUsd, status, error) {
+    if (!this.persistence) return;
+    const patch = { stepStates };
+    if (totalCostUsd !== void 0) patch.totalCostUsd = totalCostUsd;
+    if (status) patch.status = status;
+    if (error) patch.error = error instanceof Error ? error.message : "Unknown error";
+    await this.persistence.updateRun(
+      runId,
+      patch
+    );
+  }
+  /**
+   * Estimate the per-step cost band for budget preflight (F4) and dry-run (F5).
+   *
+   * Calls `provider.estimateCost` when available — that's what the spec wants, and
+   * what makes preflight actually enforce caps against real pricing.
+   *
+   * When the provider doesn't implement estimateCost (legacy mocks, certain test fakes),
+   * falls back to a tiny default band so preflight doesn't catastrophically block.
+   * Variable-output ops widen the high band: when max_tokens is present, treat low as
+   * ~30% of max and high as 100% per plan §F5.
+   */
+  async quickEstimateStep(step, _budget) {
+    const provider = this.providers.get(step.operation);
+    if (!provider) {
+      return { usdLow: 0, usdHigh: 0.01, estimable: false };
+    }
+    if (typeof provider.estimateCost !== "function") {
+      return { usdLow: 1e-3, usdHigh: 0.01, estimable: false };
+    }
+    try {
+      const est = await provider.estimateCost({
+        operation: step.operation,
+        params: step.inputs,
+        config: step.config ?? {}
+      });
+      const baseHigh = est.costUsd;
+      const maxTokens = step.inputs?.max_tokens;
+      const isVariableOutput = typeof maxTokens === "number" && maxTokens > 0;
+      return {
+        usdLow: isVariableOutput ? baseHigh * 0.3 : baseHigh,
+        usdHigh: baseHigh,
+        estimable: true,
+        estimatedDurationMs: est.estimatedDurationMs
+      };
+    } catch {
+      return { usdLow: 1e-3, usdHigh: 0.01, estimable: false };
+    }
+  }
+  async executeStep(step, pipeline) {
+    const maxRetries = step.qualityGate?.action === "retry" ? step.qualityGate.maxRetries ?? 1 : 0;
+    let lastResult = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (attempt > 0) {
+        this.registry.deleteBySourceStep(step.id);
+        this.emitEvent({
+          type: "step:retry",
+          pipelineId: pipeline.id,
+          stepId: step.id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { attempt: attempt + 1, maxRetries }
+        });
+      }
+      this.emitEvent({
+        type: "step:start",
+        pipelineId: pipeline.id,
+        stepId: step.id,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: { attempt: attempt + 1 }
+      });
+      try {
+        const result = await this.executeStepOnce(step, pipeline);
+        if (!result) {
+          return { status: "failed" };
+        }
+        if (step.qualityGate) {
+          const gateResult = await this.evaluateQualityGate(step.qualityGate, result.artifact);
+          if (!gateResult.passed) {
+            if (gateResult.action === "fail") {
+              this.emitEvent({
+                type: "step:failed",
+                pipelineId: pipeline.id,
+                stepId: step.id,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                data: { reason: gateResult.reasoning }
+              });
+              return { status: "failed", artifact: result.artifact };
+            }
+            if (gateResult.action === "retry" && attempt < maxRetries) {
+              this.emitEvent({
+                type: "step:gated",
+                pipelineId: pipeline.id,
+                stepId: step.id,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                data: { reason: gateResult.reasoning, willRetry: true }
+              });
+              lastResult = { status: "completed", artifact: result.artifact };
+              continue;
+            }
+            if (gateResult.action === "retry" && attempt >= maxRetries) {
+              this.emitEvent({
+                type: "step:gated",
+                pipelineId: pipeline.id,
+                stepId: step.id,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                data: { reason: gateResult.reasoning, maxRetriesExceeded: true }
+              });
+              return { status: "gated", artifact: result.artifact };
+            }
+            if (gateResult.action === "warn") {
+              console.warn(`Quality gate warning for step ${step.id}: ${gateResult.reasoning}`);
+            }
+          }
+        }
+        const gates = step.gates;
+        if (gates && gates.length > 0) {
+          for (const gate of gates) {
+            if (gate.type === "safety" && this.gateEvalFn) {
+              const gateResult2 = await this.gateEvalFn({
+                gate,
+                artifact: result.artifact,
+                artifactUri: result.artifact.uri,
+                stepId: step.id
+              });
+              if (gateResult2) {
+                if (!gateResult2.passed) {
+                  const safetyResult = gateResult2;
+                  if (gateResult2.action === "fail") {
+                    throw new SafetyGateRejectedError(
+                      safetyResult.reasoning ?? "csam",
+                      safetyResult.score ?? 0
+                    );
+                  }
+                  this.emitEvent({
+                    type: "step:gated",
+                    pipelineId: pipeline.id,
+                    stepId: step.id,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                    data: { reason: `Safety gate rejected: ${safetyResult.reasoning}` }
+                  });
+                  return { status: "gated", artifact: result.artifact };
+                }
+                continue;
+              }
+            }
+            if (gate.type === "loudness" && this.gateEvalFn) {
+              const gateResult2 = await this.gateEvalFn({
+                gate,
+                artifact: result.artifact,
+                artifactUri: result.artifact.uri,
+                stepId: step.id
+              });
+              if (gateResult2) {
+                if (!gateResult2.passed) {
+                  if (gateResult2.action === "fail") {
+                    throw new LoudnessGateFailedError();
+                  }
+                  this.emitEvent({
+                    type: "step:gated",
+                    pipelineId: pipeline.id,
+                    stepId: step.id,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                    data: { reason: "Loudness gate failed" }
+                  });
+                  return { status: "gated", artifact: result.artifact };
+                }
+                if (gateResult2.resultArtifact) {
+                  return { status: "completed", artifact: gateResult2.resultArtifact };
+                }
+                continue;
+              }
+            }
+            const gateResult = await this.evaluateQualityGate(
+              gate,
+              result.artifact
+            );
+            if (!gateResult.passed) {
+              this.emitEvent({
+                type: "step:gated",
+                pipelineId: pipeline.id,
+                stepId: step.id,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                data: { reason: `Additional gate failed: ${gateResult.reasoning}` }
+              });
+              return { status: "gated", artifact: result.artifact };
+            }
+          }
+        }
+        this.emitEvent({
+          type: "step:complete",
+          pipelineId: pipeline.id,
+          stepId: step.id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { artifactId: result.artifact.id }
+        });
+        return { status: "completed", artifact: result.artifact, costUsd: result.costUsd };
+      } catch (error) {
+        this.emitEvent({
+          type: "step:failed",
+          pipelineId: pipeline.id,
+          stepId: step.id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { error: error instanceof Error ? error.message : "Unknown error" }
+        });
+        if (attempt < maxRetries) {
+          continue;
+        }
+        return { status: "failed" };
+      }
+    }
+    return lastResult ?? { status: "failed" };
+  }
+  async executeStepOnce(step, pipeline) {
+    let resolvedInputs = await this.resolveInputs(step.inputs);
+    const stepExt = step;
+    if (this.contextResolveFn && this.context && stepExt.contextRefs) {
+      const providerName = this.providers.get(step.operation)?.name ?? "unknown";
+      resolvedInputs = this.contextResolveFn({
+        inputs: resolvedInputs,
+        context: this.context,
+        providerName
+      });
+    }
+    const route = stepExt.route;
+    if (route && this.routeStepFn) {
+      const routeResult = await this.routeStepFn({
+        route,
+        operation: step.operation,
+        resolvedInputs,
+        stepConfig: step.config,
+        pipelineId: pipeline.id,
+        stepId: step.id,
+        getProviderByName: (name) => this.providers.get(name) ?? this.findProviderByName(name)
+      });
+      if (routeResult) {
+        return { artifact: routeResult.artifact };
+      }
+    }
+    const variants = stepExt.variants;
+    if (variants && this.variantsStepFn) {
+      const variantsResult = await this.variantsStepFn({
+        variants,
+        step,
+        resolvedInputs,
+        pipelineId: pipeline.id,
+        stepId: step.id
+      });
+      if (variantsResult) {
+        return { artifact: variantsResult.artifact };
+      }
+    }
+    const ratios = stepExt.ratios;
+    if (ratios && this.ratiosStepFn) {
+      const ratiosResult = await this.ratiosStepFn({
+        ratios,
+        operation: step.operation,
+        resolvedInputs,
+        stepConfig: step.config,
+        stepId: step.id
+      });
+      if (ratiosResult) {
+        return { artifact: ratiosResult.artifact };
+      }
+    }
+    const provider = this.providers.get(step.operation);
+    if (!provider) {
+      throw new Error(`No provider available for operation: ${step.operation}`);
+    }
+    if (this.tenantPolicyEnforceFn) {
+      this.tenantPolicyEnforceFn(provider.name, step.config.model);
+    }
+    const providerInputs = this.prepareInputs ? await this.prepareInputs(step.operation, resolvedInputs) : resolvedInputs;
+    const cacheConfig = stepExt.cache;
+    const providerWithCache = provider;
+    const result = cacheConfig && typeof providerWithCache.executeWithCache === "function" ? await providerWithCache.executeWithCache(
+      { operation: step.operation, params: providerInputs, config: step.config },
+      cacheConfig.mode ? { mode: cacheConfig.mode, ttlSeconds: cacheConfig.ttlSeconds } : void 0
+    ) : await provider.execute(step.operation, providerInputs, step.config);
+    const artifactId = randomUUID();
+    const persisted = this.persistArtifact ? await this.persistArtifact({
+      artifactId,
+      operation: step.operation,
+      data: result.data,
+      artifact: {
+        ...result.artifact,
+        sourceStep: step.id
+      },
+      pipelineId: pipeline.id,
+      stepId: step.id
+    }) : void 0;
+    const artifact = this.registry.registerWithId(artifactId, {
+      ...result.artifact,
+      uri: persisted?.uri ?? result.artifact.uri,
+      sourceStep: step.id
+    });
+    if (result.cost_usd !== void 0) {
+      this.onCost?.({
+        operation: step.operation,
+        provider: provider.name,
+        model: step.config.model,
+        cost_usd: result.cost_usd,
+        artifactId: artifact.id,
+        pipelineId: pipeline.id,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (this.ledger) {
+        await this.ledger.charge({
+          runId: pipeline.id,
+          stepId: step.id,
+          operation: step.operation,
+          provider: provider.name,
+          costUsd: result.cost_usd
+        });
+      }
+    }
+    if (this.signProvenance) {
+      const ingredientArtifactIds = [];
+      for (const value of Object.values(step.inputs ?? {})) {
+        const m = value.match?.(/^\{\{(\w+)\.output\}\}$/);
+        if (m) {
+          const upstream = this.registry.findBySourceStep(m[1]);
+          if (upstream) ingredientArtifactIds.push(upstream.id);
+        }
+      }
+      await this.signProvenance({
+        artifactId: artifact.id,
+        runId: pipeline.id,
+        // executor's Pipeline.id is the runId for in-tree runs
+        pipelineDefHash: this.currentPipelineDefHash ?? "",
+        stepId: step.id,
+        operation: step.operation,
+        providerId: provider.name,
+        modelId: step.config?.model,
+        ingredientArtifactIds
+      });
+    }
+    return { artifact, costUsd: result.cost_usd };
+  }
+  /** Hash the normalized pipeline definition for provenance manifests (F17) and for
+   *  PipelineRunRecord auditing. Same canonical-json rule as F2 cache keys. */
+  hashPipelineDefinition(def) {
+    const normalized = { id: def.id, steps: def.steps };
+    const canonical = JSON.stringify(normalized, Object.keys(normalized).sort());
+    const { createHash } = __require("crypto");
+    return createHash("sha256").update(canonical).digest("hex");
+  }
+  /** Set inside execute()/resume() before stepping through steps; read by signProvenance. */
+  currentPipelineDefHash;
+  findProviderByName(name) {
+    for (const provider of this.providers.values()) {
+      if (provider.name === name) return provider;
+    }
+    return void 0;
+  }
+  async resolveInputs(inputSpec) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(inputSpec)) {
+      const match = value.match(/^\{\{(\w+)\.output\}\}$/);
+      if (match) {
+        const stepId = match[1];
+        const artifact = this.registry.findBySourceStep(stepId);
+        if (!artifact) {
+          throw new ArtifactNotFoundError();
+        }
+        resolved[key] = artifact.id;
+      } else {
+        resolved[key] = value;
+      }
+    }
+    return resolved;
+  }
+  async evaluateQualityGate(_gate, artifact) {
+    const evaluator = createQualityGateEvaluator(_gate, this.llmJudgeFn, this.customCheckFn);
+    return await evaluator.evaluate(_gate, artifact);
+  }
+  emitEvent(event) {
+    this.onEvent?.(event);
+    const specType = LEGACY_TO_SPEC_EVENT[event.type];
+    if (specType && specType !== event.type) {
+      this.onEvent?.({ ...event, type: specType });
+    }
+  }
+  getRegistry() {
+    return this.registry;
+  }
+};
+
+// src/pipeline-estimator.ts
+var PipelineEstimator = class {
+  ledger;
+  estimateOperation;
+  constructor(options = {}) {
+    this.ledger = options.ledger;
+    this.estimateOperation = options.estimateOperation;
+  }
+  async estimate(pipeline) {
+    const perStep = [];
+    const warnings = [];
+    for (const step of pipeline.steps) {
+      let usdLow = 1e-3;
+      let usdHigh = 0.01;
+      let estimable = true;
+      let fallbackUsed;
+      const provider = "unknown";
+      const modelId = step.config.model ?? "default";
+      if (this.estimateOperation) {
+        const opEst = await this.estimateOperation(step.operation, step.config);
+        if (opEst !== null) {
+          usdLow = opEst.usdLow;
+          usdHigh = opEst.usdHigh;
+        } else {
+          estimable = false;
+          fallbackUsed = "default-bound";
+          warnings.push({
+            stepId: step.id,
+            code: "no-estimator",
+            message: `No estimator available for operation '${step.operation}'`
+          });
+        }
+      } else {
+        estimable = false;
+        fallbackUsed = "default-bound";
+      }
+      if (!estimable && this.ledger) {
+        try {
+          const historical = await this.ledger.getTotalCost();
+          if (historical > 0) {
+            fallbackUsed = "cached-stats";
+          }
+        } catch {
+        }
+      }
+      const route = step.route;
+      if (route?.candidates && route.candidates.length > 1) {
+        warnings.push({
+          stepId: step.id,
+          code: "router-spread",
+          message: `Step '${step.id}' routes across ${route.candidates.length} candidates, estimates may vary`
+        });
+      }
+      for (const inputVal of Object.values(step.inputs)) {
+        if (typeof inputVal === "string" && inputVal.includes("{{") && inputVal.includes(".output}}")) {
+          warnings.push({
+            stepId: step.id,
+            code: "depends-on-prior-step",
+            message: `Step '${step.id}' cost depends on variable output from prior step`
+          });
+          break;
+        }
+      }
+      perStep.push({
+        stepId: step.id,
+        operation: step.operation,
+        provider,
+        modelId,
+        usdLow,
+        usdHigh,
+        estimable,
+        ...fallbackUsed ? { fallbackUsed } : {}
+      });
+    }
+    const totalUsdLow = perStep.reduce((s, e) => s + e.usdLow, 0);
+    const totalUsdHigh = perStep.reduce((s, e) => s + e.usdHigh, 0);
+    return { totalUsdLow, totalUsdHigh, perStep, warnings };
+  }
+};
+
+// src/mock-provider.ts
+var MockProvider = class {
+  name;
+  supportedOperations;
+  delay;
+  failureRate;
+  baseCost;
+  alwaysPass;
+  constructor(config = {}) {
+    this.name = config.name ?? "mock";
+    this.supportedOperations = config.operations ?? [
+      "mock.generate",
+      "mock.transform",
+      "mock.extract"
+    ];
+    this.delay = config.delay ?? 100;
+    this.failureRate = config.failureRate ?? 0;
+    this.baseCost = config.baseCost ?? 1e-3;
+    this.alwaysPass = config.alwaysPass ?? false;
+  }
+  async execute(operation, _inputs, config) {
+    await new Promise((resolve) => setTimeout(resolve, this.delay));
+    if (Math.random() < this.failureRate) {
+      throw new Error("Mock provider simulated failure");
+    }
+    let type = "image";
+    let mimeType = "image/png";
+    if (operation.includes("audio")) {
+      type = "audio";
+      mimeType = "audio/mpeg";
+    } else if (operation.includes("video")) {
+      type = "video";
+      mimeType = "video/mp4";
+    } else if (operation.includes("text") || operation.includes("extract")) {
+      type = "text";
+      mimeType = "text/plain";
+    } else if (operation.includes("document")) {
+      type = "document";
+      mimeType = "application/pdf";
+    }
+    const metadata = {
+      width: 1024,
+      height: 1024,
+      quality: this.alwaysPass ? 0.99 : 0.9,
+      ...config
+    };
+    if (type === "audio") {
+      metadata.duration = 30;
+      metadata.sampleRate = 44100;
+    } else if (type === "video") {
+      metadata.duration = 10;
+      metadata.fps = 30;
+    }
+    const uri = `mock://${operation}/${Date.now()}.${mimeType.split("/")[1]}`;
+    return {
+      data: Buffer.from(JSON.stringify({ operation, metadata })),
+      artifact: {
+        type,
+        uri,
+        mimeType,
+        metadata,
+        sourceStep: void 0
+      },
+      cost_usd: this.baseCost,
+      duration_ms: this.delay
+    };
+  }
+  async healthCheck() {
+    return Math.random() > this.failureRate;
+  }
+};
+var mockOperations = {
+  generate: "mock.generate",
+  transform: "mock.transform",
+  extract: "mock.extract",
+  imageGenerate: "image.generate",
+  imageUpscale: "image.upscale",
+  imageRemoveBackground: "image.remove_background",
+  audioTts: "audio.tts",
+  audioStt: "audio.stt"
+};
+
+// src/event-bus.ts
+function createEventBus() {
+  const handlers = /* @__PURE__ */ new Map();
+  function on(kind, handler) {
+    if (!handlers.has(kind)) {
+      handlers.set(kind, /* @__PURE__ */ new Set());
+    }
+    handlers.get(kind)?.add(handler);
+    return () => {
+      handlers.get(kind)?.delete(handler);
+    };
+  }
+  function emit(event) {
+    const kindHandlers = handlers.get(event.kind);
+    if (kindHandlers) {
+      for (const handler of kindHandlers) {
+        const result = handler(event);
+        if (result instanceof Promise) {
+          result.catch((err) => {
+            console.error(`EventBus handler error for ${event.kind}:`, err);
+          });
+        }
+      }
+    }
+  }
+  function awaitEvent(kind, predicate, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      let disposer = () => {
+      };
+      const timer = timeoutMs !== void 0 && timeoutMs > 0 ? setTimeout(() => {
+        disposer();
+        reject(new Error(`await(${kind}) timed out after ${timeoutMs}ms`));
+      }, timeoutMs) : void 0;
+      const removeHandler = on(kind, (event) => {
+        const match = predicate ? predicate(event) : true;
+        if (match) {
+          if (timer) clearTimeout(timer);
+          removeHandler();
+          resolve(event);
+        }
+      });
+      disposer = () => {
+        if (timer) clearTimeout(timer);
+        removeHandler();
+      };
+    });
+  }
+  return {
+    on,
+    emit,
+    await: awaitEvent
+  };
+}
+export {
+  A2AError,
+  ArtifactAccessDeniedError,
+  ArtifactMetaSchema,
+  ArtifactNotFoundError,
+  ArtifactRegistry,
+  ArtifactSchema,
+  ArtifactTypeSchema,
+  BrandKitSchema,
+  BudgetConfigSchema,
+  BudgetExceededError,
+  CacheConfigSchema,
+  ContextRefSchema,
+  ContextRefTypeError,
+  ContextRefUnknownError,
+  CostRecordSchema,
+  CostSummarySchema,
+  CustomEvaluator,
+  DimensionCheckEvaluator,
+  EstimateUnsupportedError,
+  FfmpegUnavailableError,
+  FormatUnsupportedError,
+  IdempotencyConflictError,
+  InvalidInputError,
+  InvalidResourceUriError,
+  JudgeConfigSchema,
+  JudgeRubricSchema,
+  JudgeUnavailableError,
+  KeyVaultUnavailableError,
+  LLMJudgeEvaluator,
+  LoudnessGateFailedError,
+  MockProvider,
+  PipelineDefinitionSchema,
+  PipelineEstimator,
+  PipelineEventSchema,
+  PipelineEventTypeSchema,
+  PipelineExecutor,
+  PipelineSchema,
+  PipelineStatusSchema,
+  PipelineStepSchema,
+  PipelineValidator,
+  ProvenanceSigningFailedError,
+  ProviderInputSchema,
+  ProviderOutputSchema,
+  QualityGateActionSchema,
+  QualityGateResultSchema,
+  QualityGateSchema,
+  RatioUnsupportedError,
+  RouteCandidateSchema,
+  RouteConfigSchema,
+  RouterAllCandidatesFailedError,
+  RouterFastestIneligibleError,
+  RouterNoCandidatesError,
+  RunContextSchema,
+  RunInProgressError,
+  RunNotFoundError,
+  RunNotResumableError,
+  SafetyGateRejectedError,
+  SafetyProviderUnavailableError,
+  StateStoreUnavailableError,
+  StorageResultSchema,
+  StyleRefSchema,
+  TenantNotFoundError,
+  TenantPolicyViolationError,
+  ThresholdEvaluator,
+  ValidationResultSchema,
+  VariantsAllRejectedError,
+  VariantsConfigSchema,
+  VoiceRefSchema,
+  WebhookProviderUnknownError,
+  WebhookSignatureInvalidError,
+  WorkflowExpiredError,
+  WorkflowNotFoundError,
+  createEventBus,
+  createQualityGateEvaluator,
+  createStepStateRecord,
+  mockOperations
+};