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

package/src/resolver/RequestBodyResolver.cjs

@@ -0,0 +1,227 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ramda = require("ramda");
+var _apidomCore = require("@speclynx/apidom-core");
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _jsonPointer = require("@swaggerexpert/json-pointer");
+var _arazzoRuntimeExpression = require("@swaggerexpert/arazzo-runtime-expression");
+var _apidomNsArazzo = require("@speclynx/apidom-ns-arazzo-1");
+var _ResolverError = _interopRequireDefault(require("../errors/ResolverError.cjs"));
+var _ArazzoValueResolver = _interopRequireDefault(require("./ArazzoValueResolver.cjs"));
+/**
+ * Matches a canonical non-negative integer (RFC 6901 array index): no leading
+ * zeros other than `0` itself.
+ */
+const ARRAY_INDEX = /^(0|[1-9][0-9]*)$/;
+
+/**
+ * Marks a bare-expression payload value that did not resolve. Its container
+ * decides what "not provided" means there: an object member is omitted, while
+ * an array element or the whole payload throws.
+ */
+const UNRESOLVED = Symbol('unresolved');
+
+/**
+ * A resolved request body: the payload with all replacements applied, plus the
+ * declared content type when present.
+ * @public
+ */
+
+/**
+ * Resolves a step's `requestBody` to a concrete payload.
+ *
+ * The `payload` is resolved first. Per the specification it "can contain"
+ * runtime expressions, so it is walked: every string in it — the payload
+ * itself, or any value nested in its objects and arrays — that is a whole
+ * runtime expression resolves to its typed value, and every other string has
+ * its embedded `{expression}` occurrences interpolated (tolerantly, so literal
+ * braces such as a JSON template's own are kept). Object keys and resolved
+ * values are never evaluated.
+ *
+ * An unresolved expression reads as "not provided": an object member is
+ * omitted, while a whole-expression payload, an array element or an embedded
+ * expression — none of which can be omitted — throws {@link ResolverError}
+ * (`unresolved-expression`), as does an invalid embedded expression
+ * (`invalid-expression`).
+ *
+ * Then each `replacements` entry is applied — its `value` is resolved by the
+ * family-wide literal-vs-expression rule of {@link ArazzoValueResolver} and set
+ * into the payload at the replacement's `target` JSON Pointer. A replacement
+ * whose value does not resolve is skipped, leaving the payload as authored.
+ *
+ * `target` may be a JSON Pointer or an XPath per the specification; only JSON
+ * Pointer targets are supported — an XPath target throws {@link ResolverError}.
+ * @public
+ */
+class RequestBodyResolver extends _ArazzoValueResolver.default {
+  /**
+   * Resolves the request body, returning its payload and content type. Returns
+   * `undefined` when there is no request body.
+   *
+   * `scope` names the step in a thrown {@link ResolverError}.
+   */
+  resolve(requestBody, resolve, scope) {
+    if (requestBody === undefined) return undefined;
+
+    // present but scalar: `.payload`, `.replacements` and `.contentType` are
+    // all plain `undefined` on a non-map element, so the step would silently
+    // send no body and report success.
+    if (!(0, _apidomDatamodel.isObjectElement)(requestBody)) {
+      throw new _ResolverError.default('`requestBody` is present but is not a map', {
+        ...scope,
+        target: 'requestBody',
+        reason: 'malformed-request-body'
+      });
+    }
+    const authoredPayload = (0, _apidomCore.toValue)(requestBody.payload);
+    let payload = this.#requireResolved(authoredPayload, this.#resolvePayloadValue(authoredPayload, [], resolve, scope), [], scope);
+    if (requestBody.replacements !== undefined) {
+      // present but scalar: walking it would fail as a bare
+      // `TypeError: requestBody.replacements is not iterable`.
+      if (!(0, _apidomDatamodel.isArrayElement)(requestBody.replacements)) {
+        throw new _ResolverError.default('`requestBody.replacements` is present but is not a list', {
+          ...scope,
+          target: 'requestBody.replacements',
+          reason: 'malformed-replacements'
+        });
+      }
+      for (const replacement of requestBody.replacements) {
+        if (!(0, _apidomNsArazzo.isPayloadReplacementElement)(replacement)) continue;
+        const target = (0, _apidomCore.toValue)(replacement.target);
+        if (typeof target !== 'string') continue;
+        const value = this.resolveValue(replacement.value, resolve);
+        if (value === undefined) continue;
+        payload = this.#applyReplacement(payload, target, value, scope);
+      }
+    }
+    const contentType = (0, _apidomDatamodel.isStringElement)(requestBody.contentType) ? (0, _apidomCore.toValue)(requestBody.contentType) : undefined;
+    return contentType === undefined ? {
+      payload
+    } : {
+      payload,
+      contentType
+    };
+  }
+
+  /**
+   * Resolves one authored payload value at the `tokens` path, recursing into
+   * objects and arrays. Returns {@link UNRESOLVED} for a bare expression that
+   * did not resolve, for its container to handle.
+   */
+  #resolvePayloadValue(value, tokens, resolve, scope) {
+    if (typeof value === 'string') return this.#resolvePayloadString(value, tokens, resolve, scope);
+    if (Array.isArray(value)) {
+      return value.map((item, index) => {
+        const itemTokens = [...tokens, String(index)];
+        const resolved = this.#resolvePayloadValue(item, itemTokens, resolve, scope);
+        return this.#requireResolved(item, resolved, itemTokens, scope);
+      });
+    }
+    if (value !== null && typeof value === 'object') {
+      // `fromEntries` defines own properties, so an authored `__proto__` key
+      // stays a plain member instead of replacing the prototype.
+      return Object.fromEntries(Object.entries(value).map(([key, member]) => [key, this.#resolvePayloadValue(member, [...tokens, key], resolve, scope)]).filter(([, resolved]) => resolved !== UNRESOLVED));
+    }
+    return value;
+  }
+
+  /**
+   * Resolves one authored payload string: a whole runtime expression to its
+   * typed value (or {@link UNRESOLVED}), anything else by tolerant
+   * interpolation of its embedded `{expression}` occurrences.
+   */
+  #resolvePayloadString(value, tokens, resolve, scope) {
+    if ((0, _arazzoRuntimeExpression.test)(value)) {
+      const resolved = resolve(value);
+      return resolved === undefined ? UNRESOLVED : resolved;
+    }
+    return (0, _arazzoRuntimeExpression.interpolate)(value, expression => {
+      const resolved = resolve(expression);
+      if (resolved === undefined) throw this.#unresolvedError(expression, tokens, scope);
+      return resolved;
+    }, {
+      strict: false,
+      onError: ({
+        text
+      }) => {
+        throw new _ResolverError.default(`Invalid runtime expression "${text}" in ${this.#payloadTarget(tokens)}`, {
+          ...scope,
+          target: this.#payloadTarget(tokens),
+          reason: 'invalid-expression'
+        });
+      }
+    });
+  }
+
+  /**
+   * Throws for an unresolved bare expression where omission is not possible —
+   * the whole payload or an array element; passes every other value through.
+   */
+  #requireResolved(authored, resolved, tokens, scope) {
+    if (resolved === UNRESOLVED) throw this.#unresolvedError(authored, tokens, scope);
+    return resolved;
+  }
+  #unresolvedError(expression, tokens, scope) {
+    const target = this.#payloadTarget(tokens);
+    return new _ResolverError.default(`Runtime expression "${expression}" in ${target} did not resolve`, {
+      ...scope,
+      target,
+      reason: 'unresolved-expression'
+    });
+  }
+
+  /**
+   * Names a payload location for errors: `requestBody.payload` itself, or a
+   * member as a JSON Pointer fragment (e.g. `requestBody.payload#/order/petId`).
+   */
+  #payloadTarget(tokens) {
+    return tokens.length === 0 ? 'requestBody.payload' : `requestBody.payload#${(0, _jsonPointer.compile)(tokens)}`;
+  }
+
+  /**
+   * Immutably sets `value` into `payload` at the `target` JSON Pointer,
+   * returning a new payload (the input is never mutated, so a payload aliased
+   * from a runtime expression's resolved value — e.g. `$inputs.order` — is not
+   * corrupted). Throws {@link ResolverError} for a non-JSON-Pointer target
+   * (e.g. XPath) or a target that does not resolve within the payload.
+   */
+  #applyReplacement(payload, target, value, scope) {
+    if (!(0, _jsonPointer.testJSONPointer)(target)) {
+      throw new _ResolverError.default(`Unsupported requestBody replacement target "${target}" (expected JSON Pointer)`, {
+        ...scope,
+        target,
+        reason: 'unsupported-target'
+      });
+    }
+
+    // an empty pointer targets the payload root — replace the whole payload.
+    const tokens = this.#pathTokens(target);
+    if (tokens.length === 0) return value;
+
+    // the target must resolve against the payload; `hasPath` also rejects
+    // prototype-chain tokens (e.g. `__proto__`) since they are not own paths.
+    if (!(0, _ramda.hasPath)(tokens, payload)) {
+      throw new _ResolverError.default(`requestBody replacement target "${target}" does not resolve in the payload`, {
+        ...scope,
+        target,
+        reason: 'unresolved-target'
+      });
+    }
+    return (0, _ramda.assocPath)(tokens, value, payload);
+  }
+
+  /**
+   * Parses a JSON Pointer into path tokens, coercing an array-index token to a
+   * number so it indexes an array rather than converting it to an object key
+   * (Ramda's `assocPath` distinguishes numeric from string keys).
+   */
+  #pathTokens(target) {
+    return (0, _jsonPointer.parse)(target).tree.map(token => ARRAY_INDEX.test(token) ? Number(token) : token);
+  }
+}
+var _default = exports.default = RequestBodyResolver;

package/src/resolver/RequestBodyResolver.mjs

@@ -0,0 +1,220 @@
+import { assocPath, hasPath } from 'ramda';
+import { toValue } from '@speclynx/apidom-core';
+import { isArrayElement, isObjectElement, isStringElement } from '@speclynx/apidom-datamodel';
+import { compile as compileJSONPointer, parse as parseJSONPointer, testJSONPointer } from '@swaggerexpert/json-pointer';
+import { interpolate, test as isRuntimeExpression } from '@swaggerexpert/arazzo-runtime-expression';
+import { isPayloadReplacementElement } from '@speclynx/apidom-ns-arazzo-1';
+import ResolverError from "../errors/ResolverError.mjs";
+import ArazzoValueResolver from "./ArazzoValueResolver.mjs";
+/**
+ * Matches a canonical non-negative integer (RFC 6901 array index): no leading
+ * zeros other than `0` itself.
+ */
+const ARRAY_INDEX = /^(0|[1-9][0-9]*)$/;
+
+/**
+ * Marks a bare-expression payload value that did not resolve. Its container
+ * decides what "not provided" means there: an object member is omitted, while
+ * an array element or the whole payload throws.
+ */
+const UNRESOLVED = Symbol('unresolved');
+
+/**
+ * A resolved request body: the payload with all replacements applied, plus the
+ * declared content type when present.
+ * @public
+ */
+
+/**
+ * Resolves a step's `requestBody` to a concrete payload.
+ *
+ * The `payload` is resolved first. Per the specification it "can contain"
+ * runtime expressions, so it is walked: every string in it — the payload
+ * itself, or any value nested in its objects and arrays — that is a whole
+ * runtime expression resolves to its typed value, and every other string has
+ * its embedded `{expression}` occurrences interpolated (tolerantly, so literal
+ * braces such as a JSON template's own are kept). Object keys and resolved
+ * values are never evaluated.
+ *
+ * An unresolved expression reads as "not provided": an object member is
+ * omitted, while a whole-expression payload, an array element or an embedded
+ * expression — none of which can be omitted — throws {@link ResolverError}
+ * (`unresolved-expression`), as does an invalid embedded expression
+ * (`invalid-expression`).
+ *
+ * Then each `replacements` entry is applied — its `value` is resolved by the
+ * family-wide literal-vs-expression rule of {@link ArazzoValueResolver} and set
+ * into the payload at the replacement's `target` JSON Pointer. A replacement
+ * whose value does not resolve is skipped, leaving the payload as authored.
+ *
+ * `target` may be a JSON Pointer or an XPath per the specification; only JSON
+ * Pointer targets are supported — an XPath target throws {@link ResolverError}.
+ * @public
+ */
+class RequestBodyResolver extends ArazzoValueResolver {
+  /**
+   * Resolves the request body, returning its payload and content type. Returns
+   * `undefined` when there is no request body.
+   *
+   * `scope` names the step in a thrown {@link ResolverError}.
+   */
+  resolve(requestBody, resolve, scope) {
+    if (requestBody === undefined) return undefined;
+
+    // present but scalar: `.payload`, `.replacements` and `.contentType` are
+    // all plain `undefined` on a non-map element, so the step would silently
+    // send no body and report success.
+    if (!isObjectElement(requestBody)) {
+      throw new ResolverError('`requestBody` is present but is not a map', {
+        ...scope,
+        target: 'requestBody',
+        reason: 'malformed-request-body'
+      });
+    }
+    const authoredPayload = toValue(requestBody.payload);
+    let payload = this.#requireResolved(authoredPayload, this.#resolvePayloadValue(authoredPayload, [], resolve, scope), [], scope);
+    if (requestBody.replacements !== undefined) {
+      // present but scalar: walking it would fail as a bare
+      // `TypeError: requestBody.replacements is not iterable`.
+      if (!isArrayElement(requestBody.replacements)) {
+        throw new ResolverError('`requestBody.replacements` is present but is not a list', {
+          ...scope,
+          target: 'requestBody.replacements',
+          reason: 'malformed-replacements'
+        });
+      }
+      for (const replacement of requestBody.replacements) {
+        if (!isPayloadReplacementElement(replacement)) continue;
+        const target = toValue(replacement.target);
+        if (typeof target !== 'string') continue;
+        const value = this.resolveValue(replacement.value, resolve);
+        if (value === undefined) continue;
+        payload = this.#applyReplacement(payload, target, value, scope);
+      }
+    }
+    const contentType = isStringElement(requestBody.contentType) ? toValue(requestBody.contentType) : undefined;
+    return contentType === undefined ? {
+      payload
+    } : {
+      payload,
+      contentType
+    };
+  }
+
+  /**
+   * Resolves one authored payload value at the `tokens` path, recursing into
+   * objects and arrays. Returns {@link UNRESOLVED} for a bare expression that
+   * did not resolve, for its container to handle.
+   */
+  #resolvePayloadValue(value, tokens, resolve, scope) {
+    if (typeof value === 'string') return this.#resolvePayloadString(value, tokens, resolve, scope);
+    if (Array.isArray(value)) {
+      return value.map((item, index) => {
+        const itemTokens = [...tokens, String(index)];
+        const resolved = this.#resolvePayloadValue(item, itemTokens, resolve, scope);
+        return this.#requireResolved(item, resolved, itemTokens, scope);
+      });
+    }
+    if (value !== null && typeof value === 'object') {
+      // `fromEntries` defines own properties, so an authored `__proto__` key
+      // stays a plain member instead of replacing the prototype.
+      return Object.fromEntries(Object.entries(value).map(([key, member]) => [key, this.#resolvePayloadValue(member, [...tokens, key], resolve, scope)]).filter(([, resolved]) => resolved !== UNRESOLVED));
+    }
+    return value;
+  }
+
+  /**
+   * Resolves one authored payload string: a whole runtime expression to its
+   * typed value (or {@link UNRESOLVED}), anything else by tolerant
+   * interpolation of its embedded `{expression}` occurrences.
+   */
+  #resolvePayloadString(value, tokens, resolve, scope) {
+    if (isRuntimeExpression(value)) {
+      const resolved = resolve(value);
+      return resolved === undefined ? UNRESOLVED : resolved;
+    }
+    return interpolate(value, expression => {
+      const resolved = resolve(expression);
+      if (resolved === undefined) throw this.#unresolvedError(expression, tokens, scope);
+      return resolved;
+    }, {
+      strict: false,
+      onError: ({
+        text
+      }) => {
+        throw new ResolverError(`Invalid runtime expression "${text}" in ${this.#payloadTarget(tokens)}`, {
+          ...scope,
+          target: this.#payloadTarget(tokens),
+          reason: 'invalid-expression'
+        });
+      }
+    });
+  }
+
+  /**
+   * Throws for an unresolved bare expression where omission is not possible —
+   * the whole payload or an array element; passes every other value through.
+   */
+  #requireResolved(authored, resolved, tokens, scope) {
+    if (resolved === UNRESOLVED) throw this.#unresolvedError(authored, tokens, scope);
+    return resolved;
+  }
+  #unresolvedError(expression, tokens, scope) {
+    const target = this.#payloadTarget(tokens);
+    return new ResolverError(`Runtime expression "${expression}" in ${target} did not resolve`, {
+      ...scope,
+      target,
+      reason: 'unresolved-expression'
+    });
+  }
+
+  /**
+   * Names a payload location for errors: `requestBody.payload` itself, or a
+   * member as a JSON Pointer fragment (e.g. `requestBody.payload#/order/petId`).
+   */
+  #payloadTarget(tokens) {
+    return tokens.length === 0 ? 'requestBody.payload' : `requestBody.payload#${compileJSONPointer(tokens)}`;
+  }
+
+  /**
+   * Immutably sets `value` into `payload` at the `target` JSON Pointer,
+   * returning a new payload (the input is never mutated, so a payload aliased
+   * from a runtime expression's resolved value — e.g. `$inputs.order` — is not
+   * corrupted). Throws {@link ResolverError} for a non-JSON-Pointer target
+   * (e.g. XPath) or a target that does not resolve within the payload.
+   */
+  #applyReplacement(payload, target, value, scope) {
+    if (!testJSONPointer(target)) {
+      throw new ResolverError(`Unsupported requestBody replacement target "${target}" (expected JSON Pointer)`, {
+        ...scope,
+        target,
+        reason: 'unsupported-target'
+      });
+    }
+
+    // an empty pointer targets the payload root — replace the whole payload.
+    const tokens = this.#pathTokens(target);
+    if (tokens.length === 0) return value;
+
+    // the target must resolve against the payload; `hasPath` also rejects
+    // prototype-chain tokens (e.g. `__proto__`) since they are not own paths.
+    if (!hasPath(tokens, payload)) {
+      throw new ResolverError(`requestBody replacement target "${target}" does not resolve in the payload`, {
+        ...scope,
+        target,
+        reason: 'unresolved-target'
+      });
+    }
+    return assocPath(tokens, value, payload);
+  }
+
+  /**
+   * Parses a JSON Pointer into path tokens, coercing an array-index token to a
+   * number so it indexes an array rather than converting it to an object key
+   * (Ramda's `assocPath` distinguishes numeric from string keys).
+   */
+  #pathTokens(target) {
+    return parseJSONPointer(target).tree.map(token => ARRAY_INDEX.test(token) ? Number(token) : token);
+  }
+}
+export default RequestBodyResolver;

package/src/resolver/ResolverScope.cjs

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/src/resolver/ResolverScope.mjs

@@ -0,0 +1 @@
+export {};

package/src/resolver/StepParameterResolver.cjs

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ArazzoValueResolver = _interopRequireDefault(require("./ArazzoValueResolver.cjs"));
+/**
+ * Resolves a step's `parameters` to a plain map of resolved values.
+ *
+ * What a parameter's `value` means is the family-wide rule of
+ * {@link ArazzoValueResolver}; how the resolved values are *keyed* is the subclass's
+ * policy, one per step target — {@link OpenAPIOperationParameterResolver} keys
+ * request delivery for a step targeting an operation,
+ * {@link WorkflowParameterResolver} keys a sub-workflow's inputs for a step
+ * targeting a `workflowId`. Each executor constructs the one resolver its kind
+ * of step calls for.
+ * @public
+ */
+class StepParameterResolver extends _ArazzoValueResolver.default {}
+var _default = exports.default = StepParameterResolver;

package/src/resolver/StepParameterResolver.mjs

@@ -0,0 +1,15 @@
+import ArazzoValueResolver from "./ArazzoValueResolver.mjs";
+/**
+ * Resolves a step's `parameters` to a plain map of resolved values.
+ *
+ * What a parameter's `value` means is the family-wide rule of
+ * {@link ArazzoValueResolver}; how the resolved values are *keyed* is the subclass's
+ * policy, one per step target — {@link OpenAPIOperationParameterResolver} keys
+ * request delivery for a step targeting an operation,
+ * {@link WorkflowParameterResolver} keys a sub-workflow's inputs for a step
+ * targeting a `workflowId`. Each executor constructs the one resolver its kind
+ * of step calls for.
+ * @public
+ */
+class StepParameterResolver extends ArazzoValueResolver {}
+export default StepParameterResolver;

package/src/resolver/WorkflowParameterResolver.cjs

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _apidomCore = require("@speclynx/apidom-core");
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _apidomNsArazzo = require("@speclynx/apidom-ns-arazzo-1");
+var _ResolverError = _interopRequireDefault(require("../errors/ResolverError.cjs"));
+var _StepParameterResolver = _interopRequireDefault(require("./StepParameterResolver.cjs"));
+/**
+ * Resolves the `parameters` of a step targeting a `workflowId` into the
+ * sub-workflow's inputs.
+ *
+ * Values follow the family-wide literal-vs-expression rule of
+ * {@link ArazzoValueResolver}. Keys are bare parameter names: per the
+ * specification, "when the step in context specifies a `workflowId`, then all
+ * parameters map to workflow inputs" — which are keyed by name alone, even
+ * for an inherited parameter that carries an `in`. Locations are not
+ * consulted, so two parameters differing only in `in` collapse by name here,
+ * which for inputs is the override mechanism, not a loss.
+ *
+ * The first parameter to claim a name wins: the list is ordered by
+ * precedence, most specific first, as `ArazzoWorkflowNormalizer` leaves it
+ * once a step's own parameters have been merged with the ones it inherits —
+ * the override order the specification requires.
+ * @public
+ */
+class WorkflowParameterResolver extends _StepParameterResolver.default {
+  /**
+   * Resolves each parameter's `value`, returning a `name` → value map.
+   * Returns an empty object when there are no parameters.
+   *
+   * `scope` names the step in a thrown {@link ResolverError}.
+   */
+  resolve(parameters, resolve, scope) {
+    const result = {};
+    if (parameters === undefined) return result;
+    // present but scalar: walking it would fail as a bare
+    // `TypeError: parameters is not iterable`.
+    if (!(0, _apidomDatamodel.isArrayElement)(parameters)) {
+      throw new _ResolverError.default('`parameters` is present but is not a list', {
+        ...scope,
+        target: 'parameters',
+        reason: 'malformed-parameters'
+      });
+    }
+    for (const parameter of parameters) {
+      if (!(0, _apidomNsArazzo.isParameterElement)(parameter)) continue;
+      const name = (0, _apidomCore.toValue)(parameter.name);
+      if (typeof name !== 'string') continue;
+      // first entry wins — see the precedence note above. `Object.hasOwn` rather
+      // than `name in result`, so a parameter named `toString` is not mistaken
+      // for one already resolved.
+      if (Object.hasOwn(result, name)) continue;
+
+      // defined rather than assigned: a name like `__proto__` hits the
+      // Object.prototype accessor on bracket assignment, so no own property is
+      // ever created and the input is silently lost — and an object value
+      // additionally rewrites the record's prototype
+      Object.defineProperty(result, name, {
+        value: this.resolveValue(parameter.value, resolve),
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    }
+    return result;
+  }
+}
+var _default = exports.default = WorkflowParameterResolver;

package/src/resolver/WorkflowParameterResolver.mjs

@@ -0,0 +1,66 @@
+import { toValue } from '@speclynx/apidom-core';
+import { isArrayElement } from '@speclynx/apidom-datamodel';
+import { isParameterElement } from '@speclynx/apidom-ns-arazzo-1';
+import ResolverError from "../errors/ResolverError.mjs";
+import StepParameterResolver from "./StepParameterResolver.mjs";
+/**
+ * Resolves the `parameters` of a step targeting a `workflowId` into the
+ * sub-workflow's inputs.
+ *
+ * Values follow the family-wide literal-vs-expression rule of
+ * {@link ArazzoValueResolver}. Keys are bare parameter names: per the
+ * specification, "when the step in context specifies a `workflowId`, then all
+ * parameters map to workflow inputs" — which are keyed by name alone, even
+ * for an inherited parameter that carries an `in`. Locations are not
+ * consulted, so two parameters differing only in `in` collapse by name here,
+ * which for inputs is the override mechanism, not a loss.
+ *
+ * The first parameter to claim a name wins: the list is ordered by
+ * precedence, most specific first, as `ArazzoWorkflowNormalizer` leaves it
+ * once a step's own parameters have been merged with the ones it inherits —
+ * the override order the specification requires.
+ * @public
+ */
+class WorkflowParameterResolver extends StepParameterResolver {
+  /**
+   * Resolves each parameter's `value`, returning a `name` → value map.
+   * Returns an empty object when there are no parameters.
+   *
+   * `scope` names the step in a thrown {@link ResolverError}.
+   */
+  resolve(parameters, resolve, scope) {
+    const result = {};
+    if (parameters === undefined) return result;
+    // present but scalar: walking it would fail as a bare
+    // `TypeError: parameters is not iterable`.
+    if (!isArrayElement(parameters)) {
+      throw new ResolverError('`parameters` is present but is not a list', {
+        ...scope,
+        target: 'parameters',
+        reason: 'malformed-parameters'
+      });
+    }
+    for (const parameter of parameters) {
+      if (!isParameterElement(parameter)) continue;
+      const name = toValue(parameter.name);
+      if (typeof name !== 'string') continue;
+      // first entry wins — see the precedence note above. `Object.hasOwn` rather
+      // than `name in result`, so a parameter named `toString` is not mistaken
+      // for one already resolved.
+      if (Object.hasOwn(result, name)) continue;
+
+      // defined rather than assigned: a name like `__proto__` hits the
+      // Object.prototype accessor on bracket assignment, so no own property is
+      // ever created and the input is silently lost — and an object value
+      // additionally rewrites the record's prototype
+      Object.defineProperty(result, name, {
+        value: this.resolveValue(parameter.value, resolve),
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    }
+    return result;
+  }
+}
+export default WorkflowParameterResolver;