@usearazzo/runner 0.0.0-stage → 1.0.1-alpha.11

package/src/executor/StepRetryRunner.mjs

@@ -0,0 +1,215 @@
+import { toValue } from '@speclynx/apidom-core';
+import { isNumberElement, isStringElement } from '@speclynx/apidom-datamodel';
+import { isFailureActionElement } from '@speclynx/apidom-ns-arazzo-1';
+import ExecutionError from "../errors/ExecutionError.mjs";
+/**
+ * What one attempt at a step produced.
+ *
+ * Both kinds of step reduce to this — an operation step (whose richer
+ * `StepExecutionResult` satisfies this shape) and a sub-workflow step
+ * (synthesized from the sub-run's outcome) — so the retry loop drives them
+ * identically and knows nothing about either.
+ * @internal
+ */
+/**
+ * The terminal outcome of a step once its retries are settled.
+ * @internal
+ */
+/**
+ * Options for the StepRetryRunner.
+ * @internal
+ */
+/**
+ * Which step is being run — carried for diagnostics, plus the run's cancellation
+ * so the wait between attempts can be cut short.
+ * @internal
+ */
+/**
+ * Runs a step until its `retry` failure actions are settled.
+ *
+ * On success, or an immediate non-retry failure, the step runs once. On a failure
+ * whose first matching action is a `retry`, the step is re-run up to that
+ * action's `retryLimit` (default 1), waiting `retryAfter` seconds between
+ * attempts. Per Arazzo 1.0.1 — "retryLimit MUST be exhausted prior to executing
+ * subsequent failure actions" — an exhausted retry falls through to the *next*
+ * matching failure action of the latest attempt, which may itself be another
+ * `retry` with its own independent budget, or a terminal `end` / `goto`. Each
+ * attempt re-runs the step and re-selects against the fresh outcome, so an action
+ * whose criteria stop matching stops being chosen.
+ *
+ * It is agnostic about what a step *is*: the caller supplies a thunk that runs one
+ * attempt and returns its {@link StepAttemptOutcome}, which is what lets an
+ * operation step and a sub-workflow step retry through identical machinery. That
+ * thunk is also where a caller puts anything it wants done per attempt — charging
+ * a run budget, say — so this class needs no notion of one; a thunk that throws
+ * ends the step there, without further attempts. One consequence is worth
+ * knowing: a `retryAfter` delay is awaited before the next attempt begins, so a
+ * caller whose per-attempt check is about to fail (a spent budget, say) still
+ * pays that delay before its error surfaces. Keeping the seam this narrow is
+ * worth one bounded wait on a run that was already doomed.
+ *
+ * A `retry` action's `stepId` / `workflowId` reference works the same way: this
+ * class only decides *when* one fires (once per firing, after the `retryAfter`
+ * wait, before the step is re-run) — it hands the action to
+ * {@link StepRetryRunContext.runReference} and knows nothing about *what* the
+ * reference is or how it runs. A caller that omits that callback gets the
+ * standalone rejection instead of a silently ignored reference.
+ *
+ * Cancellation is the one thing it will not wait out: the run's `AbortSignal`
+ * reaches the timer, which returns early, and the next attempt then trips the
+ * caller's own check. Turning an abort into an error stays the caller's job, as
+ * with the budget; the signal is here only because a wait already in progress
+ * cannot be cut short from inside the thunk.
+ * @internal
+ */
+class StepRetryRunner {
+  static #DEFAULT_RETRY_LIMIT = 1;
+  /**
+   * A real timer that stops waiting as soon as the run is cancelled, and leaves
+   * no pending timeout behind either way — a `retryAfter` of minutes would
+   * otherwise hold the event loop open long after the caller walked away.
+   *
+   * It resolves on abort rather than rejecting: turning a cancellation into an
+   * error is the caller's per-attempt check, which reports it uniformly for a
+   * run cancelled mid-wait and one cancelled mid-request.
+   */
+  static #DEFAULT_SLEEP = (ms, signal) => new Promise(resolve => {
+    if (signal?.aborted === true) {
+      resolve();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    // unsubscribed when the wait ends normally, so a signal outliving many
+    // retries does not accumulate a listener per wait.
+    const timer = setTimeout(() => {
+      signal?.removeEventListener('abort', onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener('abort', onAbort, {
+      once: true
+    });
+  });
+  #sleep;
+  constructor(options = {}) {
+    this.#sleep = options.sleep ?? StepRetryRunner.#DEFAULT_SLEEP;
+  }
+
+  /**
+   * Runs `attempt` until the step succeeds, a terminal failure action is reached,
+   * or its retries are exhausted.
+   */
+  async run(attempt, context) {
+    // attempts already spent on each retry action, keyed by the action element.
+    // The element is the correct identity here: re-running the step returns the
+    // same element instances (the workflow is normalized once and `onFailure`'s
+    // getter returns its stored children — nothing re-refracts per call), and
+    // keying by the element survives the criteria re-filtering that varies
+    // `matchedActions` between attempts (position within that filtered list is
+    // NOT stable when a response change drops an earlier action). So each retry
+    // in a chain keeps its own independent budget across re-runs.
+    const retriesSpent = new Map();
+    let attempts = 0;
+    for (;;) {
+      const outcome = await attempt();
+      attempts += 1;
+      if (outcome.successful) {
+        return {
+          outcome,
+          action: outcome.action,
+          attempts
+        };
+      }
+
+      // walk the matching failure actions: fire the first retry that still has
+      // budget, else fall through to the first terminal (non-retry) action.
+      let fired = false;
+      let terminal;
+      for (const action of outcome.matchedActions) {
+        if (!this.#isRetry(action)) {
+          terminal = action;
+          break;
+        }
+        const spent = retriesSpent.get(action) ?? 0;
+        if (spent >= this.#retryLimit(action)) continue; // exhausted — try the next action
+
+        const carriesReference = this.#carriesReference(action);
+        // narrowed once here rather than asserted at the call site below: by
+        // the time `runReference` is invoked, its absence would already have
+        // thrown on the line above, so the type reflects that instead of
+        // relying on a non-null assertion to say so.
+        const runReference = carriesReference ? context.runReference : undefined;
+        if (carriesReference && runReference === undefined) this.#rejectReference(context);
+        retriesSpent.set(action, spent + 1);
+        // only sleep for a real, positive delay — skip the event-loop yield of
+        // sleep(0) for immediate retries, and never hand a custom sleep a
+        // zero/negative/NaN value.
+        const delayMs = this.#retryAfterMs(action);
+        if (delayMs > 0) await this.#sleep(delayMs, context.signal);
+        if (runReference !== undefined) await runReference(action);
+        fired = true;
+        break;
+      }
+      if (fired) continue; // re-run the step
+      return {
+        outcome,
+        action: terminal,
+        attempts
+      };
+    }
+  }
+
+  /**
+   * Whether a matched action is a `retry` failure action (narrowing it to
+   * {@link FailureActionElement} so `retryLimit` / `retryAfter` are accessible).
+   */
+  #isRetry(action) {
+    return isFailureActionElement(action) && toValue(action.type) === 'retry';
+  }
+
+  /**
+   * A `retry` action's attempt budget — its `retryLimit`, or the default of 1
+   * when unset or non-numeric.
+   */
+  #retryLimit(action) {
+    return isNumberElement(action.retryLimit) ? toValue(action.retryLimit) : StepRetryRunner.#DEFAULT_RETRY_LIMIT;
+  }
+
+  /**
+   * The delay before a retry, in milliseconds — the action's `retryAfter`
+   * (seconds) converted. `0` when unset, non-numeric, or not a finite positive
+   * value (a negative or `NaN` `retryAfter` means "no wait", never a bad value
+   * handed to `sleep`).
+   */
+  #retryAfterMs(action) {
+    if (!isNumberElement(action.retryAfter)) return 0;
+    const ms = toValue(action.retryAfter) * 1000;
+    return Number.isFinite(ms) && ms > 0 ? ms : 0;
+  }
+
+  /**
+   * Whether a `retry` action carries a `stepId` / `workflowId` reference to
+   * execute before retrying ("the reference is executed and the context is
+   * returned, after which the current step is retried").
+   */
+  #carriesReference(action) {
+    return isStringElement(action.stepId) || isStringElement(action.workflowId);
+  }
+
+  /**
+   * Rejects a referenced `retry` action when the caller supplied no
+   * {@link StepRetryRunContext.runReference}, so an unsupported caller
+   * (or a step retried directly against this runner in isolation) fails
+   * loudly rather than silently ignoring the reference.
+   */
+  #rejectReference(context) {
+    throw new ExecutionError(`retry action on step "${context.stepId}" in workflow "${context.workflowId}" carries a stepId/workflowId reference, but no runReference was given to run it`, {
+      stepId: context.stepId,
+      workflowId: context.workflowId,
+      reason: 'retry-reference-unsupported'
+    });
+  }
+}
+export default StepRetryRunner;

package/src/executor/StepTransitionInterpreter.cjs

@@ -0,0 +1,159 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.actionTargets = actionTargets;
+exports.default = void 0;
+var _apidomCore = require("@speclynx/apidom-core");
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _ExecutionError = _interopRequireDefault(require("../errors/ExecutionError.cjs"));
+/**
+ * Which of an action's mutually exclusive `stepId` / `workflowId` fields are
+ * present, ahead of a caller deciding what that means.
+ *
+ * Shared rather than duplicated by `goto`'s own check here and a `retry`
+ * action's reference check in `WorkflowExecutor` — both Success/Failure
+ * Action Object fields carry the identical "mutually exclusive" constraint,
+ * so both need the identical two `isStringElement` reads before diverging on
+ * their own wording and branch handling.
+ * @internal
+ */
+function actionTargets(action) {
+  return {
+    hasStepId: (0, _apidomDatamodel.isStringElement)(action.stepId),
+    hasWorkflowId: (0, _apidomDatamodel.isStringElement)(action.workflowId)
+  };
+}
+
+/**
+ * What a workflow does after a step, once the step's action has been
+ * interpreted.
+ *
+ * `next` runs the following step (the success default, or a matched `goto` that
+ * targets the next step); `goto` jumps to a step by id within the current
+ * workflow; `transfer` hands control one-way to another workflow, which the
+ * caller's run then ends on; `end` stops the run with `status: ended`; `break`
+ * stops with `status: failed` (the failure default).
+ * @internal
+ */
+
+/**
+ * Which step's outcome is being interpreted — carried for diagnostics only.
+ * @internal
+ */
+
+/**
+ * Turns the action a step resolved to into what the workflow does next.
+ *
+ * This is the Arazzo 1.0.1 Success/Failure Action Object semantics in one place,
+ * and nothing else: it holds no state, performs no I/O, and does not act on the
+ * transition it returns — moving through the step list stays the workflow
+ * executor's business.
+ *
+ * - **no matching action** — the path default: "the next sequential step shall be
+ *   executed" on success, "break and return" on failure.
+ * - **`end`** — "the workflow ends, and context returns to the caller with
+ *   applicable outputs".
+ * - **`goto` a `stepId`** — jumps within the current workflow, which is where the
+ *   specification requires the target to be.
+ * - **`goto` a `workflowId`** — a one-way transfer of control to another
+ *   workflow: the `stepId`/`workflowId` field descriptions condition "context
+ *   transfers back upon completion" on `retry` specifically, so for `goto` it
+ *   does not — the current run ends here, and running the target is the
+ *   executor's job, since running workflows is orchestration rather than
+ *   policy. A `goto` naming both `stepId` and `workflowId` is malformed — the
+ *   spec marks them mutually exclusive — and is rejected before either is
+ *   read.
+ * - **anything else** — malformed input rather than a defined control flow.
+ *   `retry` is the one action that never arrives here: it is settled by
+ *   {@link StepRetryRunner}, which yields only the terminal action a retry chain
+ *   resolves to.
+ * @internal
+ */
+class StepTransitionInterpreter {
+  /**
+   * Interprets a step's terminal action into the workflow's next transition.
+   */
+  interpret(action, successful, context) {
+    if (action === undefined) {
+      // path default: next step on success, break-and-return on failure.
+      return successful ? {
+        kind: 'next'
+      } : {
+        kind: 'break'
+      };
+    }
+    const {
+      workflowId,
+      stepId
+    } = context;
+    const type = (0, _apidomCore.toValue)(action.type);
+    if (type === 'end') {
+      return {
+        kind: 'end'
+      };
+    }
+    if (type === 'goto') {
+      const {
+        hasStepId,
+        hasWorkflowId
+      } = actionTargets(action);
+      if (hasStepId && hasWorkflowId) {
+        throw new _ExecutionError.default(`goto action on step "${stepId}" in workflow "${workflowId}" declares both a stepId and a workflowId (mutually exclusive)`, {
+          stepId,
+          workflowId,
+          reason: 'ambiguous-target'
+        });
+      }
+      if (hasStepId) {
+        return {
+          kind: 'goto',
+          stepId: (0, _apidomCore.toValue)(action.stepId)
+        };
+      }
+      if (hasWorkflowId) {
+        return {
+          kind: 'transfer',
+          workflowId: (0, _apidomCore.toValue)(action.workflowId)
+        };
+      }
+      throw new _ExecutionError.default(`goto action on step "${stepId}" in workflow "${workflowId}" has neither stepId nor workflowId`, {
+        stepId,
+        workflowId,
+        reason: 'goto-target-missing'
+      });
+    }
+    throw new _ExecutionError.default(`action on step "${stepId}" in workflow "${workflowId}" has unsupported type "${type}"`, {
+      stepId,
+      workflowId,
+      reason: 'unknown-action-type'
+    });
+  }
+
+  /**
+   * The index of a step within the workflow's steps, by `stepId`; a target that
+   * names no step in this workflow is an authoring error.
+   *
+   * A general lookup against the workflow's step list, shared rather than
+   * duplicated by its two callers — a `goto` target and a `retry` action's
+   * `stepId` reference — which report a miss the same way except for the
+   * `reason` and wording that name which one it was. `descriptor` is
+   * mandatory, not defaulted to the `goto` wording: an optional default would
+   * let a future third caller silently inherit goto's diagnostics by
+   * forgetting to pass one.
+   */
+  indexOfStep(steps, stepId, workflowId, descriptor) {
+    const index = steps.findIndex(step => (0, _apidomCore.toValue)(step.stepId) === stepId);
+    if (index === -1) {
+      throw new _ExecutionError.default(`${descriptor.label} step "${stepId}" not found in workflow "${workflowId}"`, {
+        stepId,
+        workflowId,
+        reason: descriptor.reason
+      });
+    }
+    return index;
+  }
+}
+var _default = exports.default = StepTransitionInterpreter;

package/src/executor/StepTransitionInterpreter.mjs

@@ -0,0 +1,151 @@
+import { toValue } from '@speclynx/apidom-core';
+import { isStringElement } from '@speclynx/apidom-datamodel';
+import ExecutionError from "../errors/ExecutionError.mjs";
+/**
+ * Which of an action's mutually exclusive `stepId` / `workflowId` fields are
+ * present, ahead of a caller deciding what that means.
+ *
+ * Shared rather than duplicated by `goto`'s own check here and a `retry`
+ * action's reference check in `WorkflowExecutor` — both Success/Failure
+ * Action Object fields carry the identical "mutually exclusive" constraint,
+ * so both need the identical two `isStringElement` reads before diverging on
+ * their own wording and branch handling.
+ * @internal
+ */
+export function actionTargets(action) {
+  return {
+    hasStepId: isStringElement(action.stepId),
+    hasWorkflowId: isStringElement(action.workflowId)
+  };
+}
+
+/**
+ * What a workflow does after a step, once the step's action has been
+ * interpreted.
+ *
+ * `next` runs the following step (the success default, or a matched `goto` that
+ * targets the next step); `goto` jumps to a step by id within the current
+ * workflow; `transfer` hands control one-way to another workflow, which the
+ * caller's run then ends on; `end` stops the run with `status: ended`; `break`
+ * stops with `status: failed` (the failure default).
+ * @internal
+ */
+
+/**
+ * Which step's outcome is being interpreted — carried for diagnostics only.
+ * @internal
+ */
+
+/**
+ * Turns the action a step resolved to into what the workflow does next.
+ *
+ * This is the Arazzo 1.0.1 Success/Failure Action Object semantics in one place,
+ * and nothing else: it holds no state, performs no I/O, and does not act on the
+ * transition it returns — moving through the step list stays the workflow
+ * executor's business.
+ *
+ * - **no matching action** — the path default: "the next sequential step shall be
+ *   executed" on success, "break and return" on failure.
+ * - **`end`** — "the workflow ends, and context returns to the caller with
+ *   applicable outputs".
+ * - **`goto` a `stepId`** — jumps within the current workflow, which is where the
+ *   specification requires the target to be.
+ * - **`goto` a `workflowId`** — a one-way transfer of control to another
+ *   workflow: the `stepId`/`workflowId` field descriptions condition "context
+ *   transfers back upon completion" on `retry` specifically, so for `goto` it
+ *   does not — the current run ends here, and running the target is the
+ *   executor's job, since running workflows is orchestration rather than
+ *   policy. A `goto` naming both `stepId` and `workflowId` is malformed — the
+ *   spec marks them mutually exclusive — and is rejected before either is
+ *   read.
+ * - **anything else** — malformed input rather than a defined control flow.
+ *   `retry` is the one action that never arrives here: it is settled by
+ *   {@link StepRetryRunner}, which yields only the terminal action a retry chain
+ *   resolves to.
+ * @internal
+ */
+class StepTransitionInterpreter {
+  /**
+   * Interprets a step's terminal action into the workflow's next transition.
+   */
+  interpret(action, successful, context) {
+    if (action === undefined) {
+      // path default: next step on success, break-and-return on failure.
+      return successful ? {
+        kind: 'next'
+      } : {
+        kind: 'break'
+      };
+    }
+    const {
+      workflowId,
+      stepId
+    } = context;
+    const type = toValue(action.type);
+    if (type === 'end') {
+      return {
+        kind: 'end'
+      };
+    }
+    if (type === 'goto') {
+      const {
+        hasStepId,
+        hasWorkflowId
+      } = actionTargets(action);
+      if (hasStepId && hasWorkflowId) {
+        throw new ExecutionError(`goto action on step "${stepId}" in workflow "${workflowId}" declares both a stepId and a workflowId (mutually exclusive)`, {
+          stepId,
+          workflowId,
+          reason: 'ambiguous-target'
+        });
+      }
+      if (hasStepId) {
+        return {
+          kind: 'goto',
+          stepId: toValue(action.stepId)
+        };
+      }
+      if (hasWorkflowId) {
+        return {
+          kind: 'transfer',
+          workflowId: toValue(action.workflowId)
+        };
+      }
+      throw new ExecutionError(`goto action on step "${stepId}" in workflow "${workflowId}" has neither stepId nor workflowId`, {
+        stepId,
+        workflowId,
+        reason: 'goto-target-missing'
+      });
+    }
+    throw new ExecutionError(`action on step "${stepId}" in workflow "${workflowId}" has unsupported type "${type}"`, {
+      stepId,
+      workflowId,
+      reason: 'unknown-action-type'
+    });
+  }
+
+  /**
+   * The index of a step within the workflow's steps, by `stepId`; a target that
+   * names no step in this workflow is an authoring error.
+   *
+   * A general lookup against the workflow's step list, shared rather than
+   * duplicated by its two callers — a `goto` target and a `retry` action's
+   * `stepId` reference — which report a miss the same way except for the
+   * `reason` and wording that name which one it was. `descriptor` is
+   * mandatory, not defaulted to the `goto` wording: an optional default would
+   * let a future third caller silently inherit goto's diagnostics by
+   * forgetting to pass one.
+   */
+  indexOfStep(steps, stepId, workflowId, descriptor) {
+    const index = steps.findIndex(step => toValue(step.stepId) === stepId);
+    if (index === -1) {
+      throw new ExecutionError(`${descriptor.label} step "${stepId}" not found in workflow "${workflowId}"`, {
+        stepId,
+        workflowId,
+        reason: descriptor.reason
+      });
+    }
+    return index;
+  }
+}
+export default StepTransitionInterpreter;

package/src/executor/WorkflowCallStack.cjs

@@ -0,0 +1,116 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ExecutionError = _interopRequireDefault(require("../errors/ExecutionError.cjs"));
+/**
+ * How a workflow invocation was entered.
+ *
+ * Recorded per call so a detected loop can be named for the mechanism that formed
+ * it: a repeat reached purely through `dependsOn` edges is a dependency cycle,
+ * one involving a sub-workflow step call — a `retry` action's `workflowId`
+ * reference — or a `goto`'s one-way transfer to a `workflowId` — is a call
+ * cycle. `retry` and `goto` are grouped with `step` for that classification, not
+ * `dependsOn`: each is a call the current step makes, not a stated precondition.
+ * @internal
+ */
+
+/**
+ * One workflow invocation in progress. Its identity is the (documentURI,
+ * workflowId) pair: two documents may each define a workflow of one id, and
+ * those are different workflows — comparing bare ids would call their meeting
+ * a cycle.
+ */
+
+/**
+ * Options for the WorkflowCallStack.
+ * @internal
+ */
+
+/**
+ * The chain of workflow invocations in progress, as an immutable value.
+ *
+ * {@link WorkflowCallStack.enter} returns a *new* stack with the given workflow
+ * pushed, or throws if entering it cannot be legitimate. Because entering yields
+ * a new value rather than mutating this one, leaving is implicit: an unwinding
+ * throw cannot leave a stale entry behind, and sibling calls each see only their
+ * own chain — so a diamond (a workflow reached twice on separate paths, having
+ * completed and unwound in between) is not a cycle, while a genuine re-entry is.
+ *
+ * Two distinct failures are guarded, in this order:
+ *
+ * - a **cycle** — the workflow is already in progress on this chain, so it can
+ *   never terminate. Checked *first* deliberately: a cycle would eventually trip
+ *   the depth ceiling too, but only after exhausting the whole budget of frames
+ *   and then reporting the wrong cause.
+ * - **excessive depth** — distinct workflows nested past `maxDepth`, which is
+ *   legitimate nesting that simply has to be bounded.
+ *
+ * Both carry the offending `path`, since the workflow the error names is rarely
+ * the one whose authoring needs looking at.
+ * @internal
+ */
+class WorkflowCallStack {
+  #calls;
+  #maxDepth;
+  #entryDocumentURI;
+  constructor(options, calls = []) {
+    this.#maxDepth = options.maxDepth;
+    this.#entryDocumentURI = options.entryDocumentURI;
+    this.#calls = calls;
+  }
+
+  /**
+   * The workflows in progress, outermost first — bare ids for entry-document
+   * frames, `{documentURI}#{workflowId}` for foreign ones.
+   */
+  get path() {
+    return this.#calls.map(call => this.#display(call.workflowId, call.documentURI));
+  }
+  #display(workflowId, documentURI) {
+    return documentURI === this.#entryDocumentURI ? workflowId : `${documentURI}#${workflowId}`;
+  }
+
+  /**
+   * Returns the stack with the workflow pushed — identified by its bare id
+   * together with the canonical URI of the document that owns it — or throws
+   * when entering it would form a cycle or exceed the nesting ceiling.
+   */
+  enter(workflowId, via, documentURI) {
+    const repeated = this.#calls.findIndex(call => call.workflowId === workflowId && call.documentURI === documentURI);
+    if (repeated !== -1) {
+      const path = [...this.path, this.#display(workflowId, documentURI)];
+      // name the loop for the mechanism that formed it: every edge closing the
+      // cycle being a `dependsOn` edge makes it a dependency cycle, while any
+      // sub-workflow step call in the loop makes it a call cycle. One stack
+      // detects both, so a loop crossing the two mechanisms cannot slip between
+      // them.
+      const closingEdges = [...this.#calls.slice(repeated + 1).map(call => call.via), via];
+      const reason = closingEdges.every(edge => edge === 'dependsOn') ? 'dependsOn-cycle' : 'workflow-cycle';
+      throw new _ExecutionError.default(`workflow "${workflowId}" is already in progress; its call chain forms a cycle (${path.join(' -> ')})`, {
+        workflowId,
+        reason,
+        path
+      });
+    }
+    if (this.#calls.length >= this.#maxDepth) {
+      throw new _ExecutionError.default(`workflow "${workflowId}" nests deeper than the limit of ${this.#maxDepth} workflows`, {
+        workflowId,
+        reason: 'workflow-depth',
+        path: [...this.path, this.#display(workflowId, documentURI)]
+      });
+    }
+    return new WorkflowCallStack({
+      maxDepth: this.#maxDepth,
+      entryDocumentURI: this.#entryDocumentURI
+    }, [...this.#calls, {
+      workflowId,
+      documentURI,
+      via
+    }]);
+  }
+}
+var _default = exports.default = WorkflowCallStack;