@usearazzo/runner 1.0.1-alpha.19 → 1.0.1-alpha.21

package/src/executor/StepExecutor.mjs

@@ -37,6 +37,12 @@ export const STEP_TARGET_FIELDS = ['operationId', 'operationPath', 'workflowId']
  * @public
  */
 
+/**
+ * The outcome of one criterion a step evaluated: one of its `successCriteria`,
+ * or one of the `criteria` of an action it considered.
+ * @public
+ */
+
 /**
  * The outcome of executing a single step.
  * @public
@@ -183,16 +189,22 @@ class StepExecutor {
     // evaluate criteria, outputs, and the next action against the post-request
     // context (with $request / $url / $method and $response / $statusCode).
     const postContext = state.toContext(this.#requestContext(response), this.#responseContext(response));
-    const successful = this.evaluateCriteria(step, postContext);
+    const successCriteria = this.evaluateCriteria(step, postContext);
+    const successful = successCriteria.every(criterion => criterion.met);
     const outputs = this.#outputResolver.resolve(step.outputs, expression => this.#evaluate(postContext, expression), scope);
-    const matchedActions = this.selectActions(step, successful, postContext);
+    const {
+      matchedActions,
+      actionCriteria
+    } = this.selectActions(step, successful, postContext);
     return {
       stepId,
       response,
       successful,
       outputs,
       action: matchedActions[0],
-      matchedActions
+      matchedActions,
+      successCriteria,
+      actionCriteria
     };
   }
 
@@ -265,9 +277,12 @@ class StepExecutor {
   }
 
   /**
-   * Evaluates the step's `successCriteria`; all criteria must pass. A step with
-   * no criteria succeeds on a received response. An unreadable
-   * `successCriteria` throws, see {@link StepExecutor.assertSuccessCriteria}.
+   * Evaluates the step's `successCriteria`, returning one record per criterion
+   * in list order; the step succeeds when every record is met. Every criterion
+   * is evaluated, so the records explain each unmet one, not only the first. A
+   * step with no criteria returns no records and succeeds on a received
+   * response. An unreadable `successCriteria` throws, see
+   * {@link StepExecutor.assertSuccessCriteria}.
    *
    * Public for the same reason as {@link StepExecutor.selectActions}: a step
    * targeting a `workflowId` is run by the workflow executor and never reaches
@@ -277,15 +292,16 @@ class StepExecutor {
   evaluateCriteria(step, context) {
     this.assertSuccessCriteria(step);
     const criteria = step.successCriteria;
-    if (criteria === undefined) return true;
+    if (criteria === undefined) return [];
 
     // assertSuccessCriteria above guarantees every entry is a Criterion Object
-    return [...criteria].every(criterion => this.#criterionEvaluator.evaluate(criterion, expression => this.#evaluate(context, expression)));
+    return [...criteria].map(criterion => this.#evaluateCriterion(criterion, context));
   }
 
   /**
    * Selects every matching `onSuccess` / `onFailure` action for the outcome, in
-   * list order, gating each action's criteria against the context.
+   * list order, gating each action's criteria against the context, and records
+   * the outcome of every action criterion evaluated.
    *
    * The step's own list is the whole story here: a step that declares none of
    * its own already carries the workflow-level defaults, inherited by
@@ -304,25 +320,65 @@ class StepExecutor {
    * the expression context through this one method rather than wiring their own.
    */
   selectActions(step, successful, context) {
-    const isCriterionMet = criterion => {
-      try {
-        return this.#criterionEvaluator.evaluate(criterion, expression => this.#evaluate(context, expression));
-      } catch (error) {
-        // an action's criteria decide whether it applies to this outcome, and
-        // actions are shared — inherited from the workflow, reused from
-        // components. A condition on an HTTP exchange cannot apply to a step
-        // that calls a workflow, so the action does not match; the run does not
-        // abort over a default written for the operation steps.
-        if (error instanceof RuntimeExpressionError && error.reason === 'unavailable-expression') {
-          return false;
-        }
-        throw error;
-      }
+    const actionCriteria = [];
+    const isCriterionMet = (criterion, action) => {
+      const record = {
+        ...this.#evaluateCriterion(criterion, context),
+        actionName: toValue(action.name)
+      };
+      actionCriteria.push(record);
+      return record.met;
     };
     const scope = {
       stepId: toValue(step.stepId)
     };
-    return successful ? this.#actionResolver.resolveOnSuccess(step.onSuccess, isCriterionMet, scope) : this.#actionResolver.resolveOnFailure(step.onFailure, isCriterionMet, scope);
+    const matchedActions = successful ? this.#actionResolver.resolveOnSuccess(step.onSuccess, isCriterionMet, scope) : this.#actionResolver.resolveOnFailure(step.onFailure, isCriterionMet, scope);
+    return {
+      matchedActions,
+      actionCriteria
+    };
+  }
+
+  /**
+   * Evaluates one criterion into a {@link CriterionEvaluationRecord}. A
+   * condition that cannot be evaluated is unmet and records why; any other
+   * error propagates.
+   */
+  #evaluateCriterion(criterion, context) {
+    const condition = toValue(criterion.condition);
+    try {
+      const {
+        met,
+        error
+      } = this.#criterionEvaluator.evaluate(criterion, expression => this.#evaluate(context, expression));
+      if (error === undefined) return {
+        condition,
+        met
+      };
+      return {
+        condition,
+        met,
+        diagnostic: {
+          code: error.reason,
+          message: error.message
+        }
+      };
+    } catch (error) {
+      // a step that calls a workflow made no HTTP call, so a condition on one
+      // fails like any unevaluable condition; the diagnostic keeps the
+      // authoring mistake visible.
+      if (error instanceof RuntimeExpressionError && error.reason === 'unavailable-expression') {
+        return {
+          condition,
+          met: false,
+          diagnostic: {
+            code: error.reason,
+            message: error.message
+          }
+        };
+      }
+      throw error;
+    }
   }
 
   /**

package/src/executor/WorkflowExecutor.cjs

@@ -359,6 +359,8 @@ class WorkflowExecutor {
         action,
         attempts,
         durationMs: this.#now() - stepStartedAt,
+        successCriteria: outcome.successCriteria,
+        actionCriteria: outcome.actionCriteria,
         ...(subWorkflows.length > 0 ? {
           subWorkflows
         } : {}),
@@ -889,19 +891,26 @@ class WorkflowExecutor {
       // apply on top — they are the author's assertion about this step, and
       // dropping them because the step happens to target a workflow would
       // silently discard it. They see the sub-run's own outputs (`{}` when it
-      // transferred) through `$outputs` and `$workflows`.
+      // transferred) through `$outputs` and `$workflows`, and are evaluated
+      // even when the sub-run failed, so the record explains them either way.
       // the criteria and actions are the *calling* step's, so they are
       // evaluated by the parent document's step executor — only the sub-run
       // itself switched documents.
       const stepExecutor = this.#stepExecutor.forDocument(document);
-      const successful = !this.#settledFailed(result) && stepExecutor.evaluateCriteria(step, context);
-      const matchedActions = stepExecutor.selectActions(step, successful, context);
+      const successCriteria = stepExecutor.evaluateCriteria(step, context);
+      const successful = !this.#settledFailed(result) && successCriteria.every(criterion => criterion.met);
+      const {
+        matchedActions,
+        actionCriteria
+      } = stepExecutor.selectActions(step, successful, context);
       return {
         stepId,
         successful,
         outputs,
         action: matchedActions[0],
-        matchedActions
+        matchedActions,
+        successCriteria,
+        actionCriteria
       };
     };
   }

package/src/executor/WorkflowExecutor.mjs

@@ -345,6 +345,8 @@ class WorkflowExecutor {
         action,
         attempts,
         durationMs: this.#now() - stepStartedAt,
+        successCriteria: outcome.successCriteria,
+        actionCriteria: outcome.actionCriteria,
         ...(subWorkflows.length > 0 ? {
           subWorkflows
         } : {}),
@@ -875,19 +877,26 @@ class WorkflowExecutor {
       // apply on top — they are the author's assertion about this step, and
       // dropping them because the step happens to target a workflow would
       // silently discard it. They see the sub-run's own outputs (`{}` when it
-      // transferred) through `$outputs` and `$workflows`.
+      // transferred) through `$outputs` and `$workflows`, and are evaluated
+      // even when the sub-run failed, so the record explains them either way.
       // the criteria and actions are the *calling* step's, so they are
       // evaluated by the parent document's step executor — only the sub-run
       // itself switched documents.
       const stepExecutor = this.#stepExecutor.forDocument(document);
-      const successful = !this.#settledFailed(result) && stepExecutor.evaluateCriteria(step, context);
-      const matchedActions = stepExecutor.selectActions(step, successful, context);
+      const successCriteria = stepExecutor.evaluateCriteria(step, context);
+      const successful = !this.#settledFailed(result) && successCriteria.every(criterion => criterion.met);
+      const {
+        matchedActions,
+        actionCriteria
+      } = stepExecutor.selectActions(step, successful, context);
       return {
         stepId,
         successful,
         outputs,
         action: matchedActions[0],
-        matchedActions
+        matchedActions,
+        successCriteria,
+        actionCriteria
       };
     };
   }

package/src/index.cjs

@@ -113,6 +113,18 @@ Object.defineProperty(exports, "CriterionError", {
     return _CriterionError.default;
   }
 });
+Object.defineProperty(exports, "CriterionErrorReason", {
+  enumerable: true,
+  get: function () {
+    return _CriterionErrorReason.default;
+  }
+});
+Object.defineProperty(exports, "CriterionEvaluationError", {
+  enumerable: true,
+  get: function () {
+    return _CriterionEvaluationError.default;
+  }
+});
 Object.defineProperty(exports, "CriterionEvaluator", {
   enumerable: true,
   get: function () {
@@ -405,6 +417,7 @@ var _SimpleCriterionEvaluator = _interopRequireDefault(require("./criterion/Simp
 var _RegexCriterionEvaluator = _interopRequireDefault(require("./criterion/RegexCriterionEvaluator.cjs"));
 var _JSONPathCriterionEvaluator = _interopRequireDefault(require("./criterion/JSONPathCriterionEvaluator.cjs"));
 var _XPathCriterionEvaluator = _interopRequireDefault(require("./criterion/XPathCriterionEvaluator.cjs"));
+var _CriterionErrorReason = _interopRequireDefault(require("./criterion/CriterionErrorReason.cjs"));
 var _WorkflowExecutionState = _interopRequireDefault(require("./state/WorkflowExecutionState.cjs"));
 var _ArazzoValueResolver = _interopRequireDefault(require("./resolver/ArazzoValueResolver.cjs"));
 var _StepParameterResolver = _interopRequireDefault(require("./resolver/StepParameterResolver.cjs"));
@@ -429,5 +442,6 @@ var _UnmatchedProviderError = _interopRequireDefault(require("./errors/Unmatched
 var _DocumentLoadError = _interopRequireDefault(require("./errors/DocumentLoadError.cjs"));
 var _RuntimeExpressionError = _interopRequireDefault(require("./errors/RuntimeExpressionError.cjs"));
 var _CriterionError = _interopRequireDefault(require("./errors/CriterionError.cjs"));
+var _CriterionEvaluationError = _interopRequireDefault(require("./errors/CriterionEvaluationError.cjs"));
 var _ResolverError = _interopRequireDefault(require("./errors/ResolverError.cjs"));
 var _ExecutionError = _interopRequireDefault(require("./errors/ExecutionError.cjs"));

package/src/index.mjs

@@ -43,6 +43,7 @@ export { default as SimpleCriterionEvaluator } from "./criterion/SimpleCriterion
 export { default as RegexCriterionEvaluator } from "./criterion/RegexCriterionEvaluator.mjs";
 export { default as JSONPathCriterionEvaluator } from "./criterion/JSONPathCriterionEvaluator.mjs";
 export { default as XPathCriterionEvaluator } from "./criterion/XPathCriterionEvaluator.mjs";
+export { default as CriterionErrorReason } from "./criterion/CriterionErrorReason.mjs";
 /* Execution State */
 export { default as WorkflowExecutionState } from "./state/WorkflowExecutionState.mjs";
 /* Resolvers */
@@ -72,5 +73,6 @@ export { default as UnmatchedProviderError } from "./errors/UnmatchedProviderErr
 export { default as DocumentLoadError } from "./errors/DocumentLoadError.mjs";
 export { default as RuntimeExpressionError } from "./errors/RuntimeExpressionError.mjs";
 export { default as CriterionError } from "./errors/CriterionError.mjs";
+export { default as CriterionEvaluationError } from "./errors/CriterionEvaluationError.mjs";
 export { default as ResolverError } from "./errors/ResolverError.mjs";
 export { default as ExecutionError } from "./errors/ExecutionError.mjs";

package/types/runner.d.ts

@@ -473,11 +473,106 @@ export declare type CriterionContextResolver = (expression: string) => unknown;
 export declare class CriterionError extends ArazzoRunnerError {
     readonly condition?: string;
     readonly type?: string;
-    readonly reason?: string;
+    readonly reason?: CriterionErrorReason;
+}
+
+/**
+ * The `reason` a {@link CriterionError} carries.
+ *
+ * Structural reasons mark a criterion that is malformed as written; they are
+ * thrown as a plain `CriterionError`. Evaluation reasons (`InvalidSimple`,
+ * `InvalidRegex`, `InvalidJSONPath`, `InvalidXPath`, `InvalidXPathContext`) mark
+ * a condition that cannot be evaluated; they are thrown as a
+ * {@link CriterionEvaluationError}, which `CriterionEvaluator` turns into an
+ * unmet criterion.
+ * @public
+ */
+export declare const CriterionErrorReason: {
+    /** The element is not a Criterion Object. */
+    readonly InvalidCriterion: "invalid-criterion";
+    /** The `condition` is missing or empty. */
+    readonly MissingCondition: "missing-condition";
+    /** The `type` is present but unreadable. */
+    readonly InvalidType: "invalid-type";
+    /** The `type` names no known criterion type. */
+    readonly UnknownType: "unknown-type";
+    /** The expression type `version` is present but not a string. */
+    readonly InvalidVersion: "invalid-version";
+    /** The expression type `version` is not the one this runner supports. */
+    readonly UnsupportedVersion: "unsupported-version";
+    /** The `context` is not a runtime expression. */
+    readonly InvalidContext: "invalid-context";
+    /** A `regex`, `jsonpath` or `xpath` criterion has no `context`. */
+    readonly MissingContext: "missing-context";
+    /** The `simple` condition cannot be parsed. */
+    readonly InvalidSimple: "invalid-simple";
+    /** The `regex` condition is not a valid regular expression. */
+    readonly InvalidRegex: "invalid-regex";
+    /** The `jsonpath` condition is not a valid JSONPath query. */
+    readonly InvalidJSONPath: "invalid-jsonpath";
+    /** The `xpath` condition is invalid or fails to evaluate. */
+    readonly InvalidXPath: "invalid-xpath";
+    /** The resolved `xpath` context is not XML. */
+    readonly InvalidXPathContext: "invalid-xpath-context";
+};
+
+/**
+ * One of the `CriterionErrorReason` values.
+ * @public
+ */
+export declare type CriterionErrorReason = (typeof CriterionErrorReason)[keyof typeof CriterionErrorReason];
+
+/**
+ * A criterion condition that cannot be evaluated: a syntax error in the
+ * condition, a context the condition cannot apply to, or an error raised while
+ * evaluating it. The type-specific criterion evaluators throw it;
+ * `CriterionEvaluator` turns it into an unmet criterion, as Arazzo 1.1.0
+ * requires.
+ * @public
+ */
+export declare class CriterionEvaluationError extends CriterionError {
 }
 
 /**
- * Evaluates an Arazzo Criterion Object to a boolean.
+ * The outcome of one criterion a step evaluated: one of its `successCriteria`,
+ * or one of the `criteria` of an action it considered.
+ * @public
+ */
+export declare interface CriterionEvaluationRecord {
+    /**
+     * The criterion's `condition`, as written.
+     */
+    readonly condition: string;
+    /**
+     * Whether the condition is met.
+     */
+    readonly met: boolean;
+    /**
+     * The `name` of the action declaring the criterion — present only on an
+     * action criterion.
+     */
+    readonly actionName?: string;
+    /**
+     * Why the condition could not be evaluated — present only then, with `met`
+     * `false`.
+     */
+    readonly diagnostic?: {
+        /**
+         * Machine-readable: the `reason` of the error that failed the criterion, a
+         * `CriterionErrorReason` value or `'unavailable-expression'` for an
+         * HTTP-exchange expression in a step that calls a workflow.
+         */
+        readonly code?: CriterionErrorReason | 'unavailable-expression';
+        /**
+         * Human-readable: names the condition or expression and, for a syntax
+         * error, what is wrong with it; never request or response data.
+         */
+        readonly message: string;
+    };
+}
+
+/**
+ * Evaluates an Arazzo Criterion Object to a {@link CriterionOutcome}.
  *
  * Dispatches on the criterion's `type` (defaulting to `simple` when omitted):
  * - `simple` — evaluates the condition directly, resolving the runtime
@@ -486,12 +581,27 @@ export declare class CriterionError extends ArazzoRunnerError {
  *   pattern to the resolved value.
  * - `jsonpath` — resolves the `context` runtime expression, then applies the
  *   JSONPath query to the resolved value (met when the query matches). Only the
- *   `rfc9535` version is supported (the spec default); an explicit other version
- *   throws.
+ *   `rfc9535` version is supported; an explicit other version throws.
  * - `xpath` — resolves the `context` runtime expression, then applies the XPath
  *   3.1 query to the resolved XML value (met by the Effective Boolean Value).
- *   Only the `xpath-31` version is supported (the spec default); an explicit
- *   other version throws.
+ *   Only the `xpath-31` version is supported; an explicit other version throws.
+ *
+ * Versions follow Arazzo 1.1.0's Expression Type Object: `rfc9535` and
+ * `xpath-31` are allowed values, and an omitted `version` defaults to them.
+ * Arazzo 1.0.x lists neither and requires `version`; this evaluator applies
+ * the 1.1.0 rule to every document, which accepts more but never evaluates a
+ * query under the wrong dialect.
+ *
+ * A condition that cannot be evaluated fails the criterion (`met: false`), as
+ * Arazzo 1.1.0 requires: a syntax error in the condition, a context the
+ * condition cannot apply to (non-XML data for `xpath`), or an XPath evaluation
+ * error. The type-specific evaluators report these as a
+ * {@link CriterionEvaluationError}, which this facade returns as the
+ * outcome's `error` so the caller can report it; any other error they raise
+ * propagates. A criterion that is malformed as written still throws: a
+ * missing `condition`, an unknown or unreadable `type`, an unsupported
+ * expression `version`, or a `context` that is missing or not a runtime
+ * expression.
  *
  * The evaluator is agnostic about how runtime expressions are resolved: the
  * caller supplies a {@link CriterionContextResolver} per evaluation, keeping
@@ -503,17 +613,22 @@ export declare class CriterionEvaluator {
     #private;
     constructor(options?: CriterionEvaluatorOptions);
     /**
-     * Evaluates a criterion element, returning whether the condition is met.
+     * Evaluates a criterion element, returning whether the condition is met and,
+     * when it cannot be evaluated, why.
      *
      * `resolve` turns a runtime expression into a value: for `simple` it resolves
      * the expressions embedded in the condition; for the other types it resolves
      * the criterion's `context` expression that the condition is applied to.
      */
-    evaluate(criterion: CriterionElement, resolve: CriterionContextResolver): boolean;
+    evaluate(criterion: CriterionElement, resolve: CriterionContextResolver): CriterionOutcome;
 }
 
 /**
  * Options for the CriterionEvaluator.
+ *
+ * An injected evaluator signals a condition it cannot evaluate by throwing a
+ * {@link CriterionEvaluationError}, which fails the criterion; any other error
+ * it throws, a plain {@link CriterionError} included, propagates.
  * @public
  */
 export declare interface CriterionEvaluatorOptions {
@@ -536,14 +651,32 @@ export declare interface CriterionEvaluatorOptions {
 }
 
 /**
- * Determines whether a single criterion is met.
+ * The outcome of evaluating one criterion.
+ * @public
+ */
+export declare interface CriterionOutcome {
+    /**
+     * Whether the condition is met. `false` when it evaluates to false or cannot
+     * be evaluated; only in the latter case is {@link CriterionOutcome.error}
+     * present, saying why.
+     */
+    readonly met: boolean;
+    /**
+     * Why the condition could not be evaluated: present only when it was not.
+     */
+    readonly error?: CriterionEvaluationError;
+}
+
+/**
+ * Determines whether a single criterion of an action is met. Receives the
+ * action declaring the criterion, so a caller can attribute the outcome to it.
  *
  * Bridged to a criterion evaluator
- * (`(criterion) => criterionEvaluator.evaluate(criterion, resolve)`); an
+ * (`(criterion) => criterionEvaluator.evaluate(criterion, resolve).met`); an
  * unresolvable/failing criterion is `false`, not an error.
  * @public
  */
-export declare type CriterionPredicate = (criterion: CriterionElement) => boolean;
+export declare type CriterionPredicate = (criterion: CriterionElement, action: SelectedAction) => boolean;
 
 /** @public */
 export declare class DocumentLoadError extends ArazzoRunnerError {
@@ -701,7 +834,7 @@ export declare class JSONPathCriterionEvaluator {
      * whether it matched anything.
      *
      * Returns `false` when the context is `null` or `undefined`. Throws
-     * {@link CriterionError} when the condition is not a valid JSONPath query.
+     * {@link CriterionEvaluationError} when the condition is not a valid JSONPath query.
      */
     evaluate(condition: string, context: unknown): boolean;
 }
@@ -1420,7 +1553,7 @@ export declare class RegexCriterionEvaluator {
      * Tests the resolved context value against the regular expression `condition`.
      *
      * The context is coerced to a string before matching. Returns `false` when the
-     * context is `null` or `undefined`. Throws {@link CriterionError} when the
+     * context is `null` or `undefined`. Throws {@link CriterionEvaluationError} when the
      * condition is not a valid regular expression.
      */
     evaluate(condition: string, context: unknown): boolean;
@@ -1780,7 +1913,7 @@ export declare function settledResult(result: WorkflowExecutionResult): Workflow
  * compared per the library's rules (e.g. `undefined == x` and relational
  * comparisons are false, matching the spec's "null equals only null"), so a
  * negated or disjunctive condition may still pass. A malformed condition throws
- * {@link CriterionError}.
+ * {@link CriterionEvaluationError}.
  * @public
  */
 export declare class SimpleCriterionEvaluator {
@@ -1854,6 +1987,16 @@ export declare interface StepExecutionResult {
      * matching action. Empty when none matched.
      */
     readonly matchedActions: readonly SelectedAction[];
+    /**
+     * The outcome of each of the step's `successCriteria`, in list order.
+     */
+    readonly successCriteria: readonly CriterionEvaluationRecord[];
+    /**
+     * The outcome of each criterion of the actions the step considered — its
+     * `onSuccess` actions when it succeeded, its `onFailure` actions otherwise —
+     * in list order.
+     */
+    readonly actionCriteria: readonly CriterionEvaluationRecord[];
 }
 
 /**
@@ -1921,19 +2064,23 @@ export declare class StepExecutor {
      */
     assertSuccessCriteria(step: StepElement, workflowId?: string): void;
     /**
-     * Evaluates the step's `successCriteria`; all criteria must pass. A step with
-     * no criteria succeeds on a received response. An unreadable
-     * `successCriteria` throws, see {@link StepExecutor.assertSuccessCriteria}.
+     * Evaluates the step's `successCriteria`, returning one record per criterion
+     * in list order; the step succeeds when every record is met. Every criterion
+     * is evaluated, so the records explain each unmet one, not only the first. A
+     * step with no criteria returns no records and succeeds on a received
+     * response. An unreadable `successCriteria` throws, see
+     * {@link StepExecutor.assertSuccessCriteria}.
      *
      * Public for the same reason as {@link StepExecutor.selectActions}: a step
      * targeting a `workflowId` is run by the workflow executor and never reaches
      * {@link StepExecutor.execute}, but its criteria are still the author's
      * assertion about the step and must be evaluated somewhere.
      */
-    evaluateCriteria(step: StepElement, context: RuntimeExpressionContext): boolean;
+    evaluateCriteria(step: StepElement, context: RuntimeExpressionContext): CriterionEvaluationRecord[];
     /**
      * Selects every matching `onSuccess` / `onFailure` action for the outcome, in
-     * list order, gating each action's criteria against the context.
+     * list order, gating each action's criteria against the context, and records
+     * the outcome of every action criterion evaluated.
      *
      * The step's own list is the whole story here: a step that declares none of
      * its own already carries the workflow-level defaults, inherited by
@@ -1951,7 +2098,7 @@ export declare class StepExecutor {
      * {@link StepExecutor.execute}. Both callers reach the criteria evaluator and
      * the expression context through this one method rather than wiring their own.
      */
-    selectActions(step: StepElement, successful: boolean, context: RuntimeExpressionContext): SelectedAction[];
+    selectActions(step: StepElement, successful: boolean, context: RuntimeExpressionContext): Pick<StepExecutionResult, 'matchedActions' | 'actionCriteria'>;
 }
 
 /**
@@ -2029,6 +2176,17 @@ export declare interface StepRunRecord {
      * fractional and is unaffected by system clock changes.
      */
     readonly durationMs: number;
+    /**
+     * The outcome of each of the step's `successCriteria` in its last attempt, in
+     * list order — why the step succeeded or failed.
+     */
+    readonly successCriteria: readonly CriterionEvaluationRecord[];
+    /**
+     * The outcome of each criterion of the actions the last attempt considered —
+     * its `onSuccess` actions when it succeeded, its `onFailure` actions
+     * otherwise — in list order: why an action matched or did not.
+     */
+    readonly actionCriteria: readonly CriterionEvaluationRecord[];
     /**
      * The sub-workflow runs this step produced, in attempt order — present only on
      * a step targeting a `workflowId`.
@@ -2455,7 +2613,7 @@ export declare interface WorkflowReferenceContext {
  *
  * Only XPath 3.1 is supported (`fontoxpath`'s engine); version gating happens in
  * the facade. Per Arazzo 1.1.0, a `null` or `undefined` context fails the
- * condition. An invalid query throws {@link CriterionError}.
+ * condition. An invalid query throws {@link CriterionEvaluationError}.
  * @public
  */
 export declare class XPathCriterionEvaluator {
@@ -2465,7 +2623,7 @@ export declare class XPathCriterionEvaluator {
      * its Effective Boolean Value.
      *
      * Returns `false` when the context is `null` or `undefined`. Throws
-     * {@link CriterionError} when the context is not XML or the query is invalid.
+     * {@link CriterionEvaluationError} when the context is not XML or the query is invalid.
      */
     evaluate(condition: string, context: unknown): boolean;
 }