@speclynx/apidom-reference 4.14.0 → 4.16.0

package/src/bundle/strategies/asyncapi-2/visitor.mjs

@@ -0,0 +1,563 @@
+import { propEq } from 'ramda';
+import { isElement, isObjectElement, isStringElement, ObjectElement, AnnotationElement, cloneDeep } from '@speclynx/apidom-datamodel';
+import { toValue, toYAML, fixedFields } from '@speclynx/apidom-core';
+import { traverseAsync } from '@speclynx/apidom-traverse';
+import { evaluate, escape, parse as parseJSONPointer, URIFragmentIdentifier } from '@speclynx/apidom-json-pointer';
+import { ComponentsElement, ComponentsSchemasElement, ComponentsServersElement, ComponentsServerVariablesElement, ComponentsChannelsElement, ComponentsMessagesElement, ComponentsSecuritySchemesElement, ComponentsParametersElement, ComponentsCorrelationIDsElement, ComponentsOperationTraitsElement, ComponentsMessageTraitsElement, ComponentsServerBindingsElement, ComponentsChannelBindingsElement, ComponentsOperationBindingsElement, ComponentsMessageBindingsElement, isReferenceElement, isReferenceLikeElement, isChannelItemElement, refract, refractReference, refractChannelItem } from '@speclynx/apidom-ns-asyncapi-2';
+import BundleError from "../../../errors/BundleError.mjs";
+import UnresolvableReferenceError from "../../../errors/UnresolvableReferenceError.mjs";
+import MaximumBundleDepthError from "../../../errors/MaximumBundleDepthError.mjs";
+import MaximumResolveDepthError from "../../../errors/MaximumResolveDepthError.mjs";
+import * as url from "../../../util/url.mjs";
+import parse from "../../../parse/index.mjs";
+import Reference from "../../../Reference.mjs";
+import { toPascalCase, sanitizeComponentName, uniqueName as resolveUniqueName } from "../../util.mjs";
+/**
+ * Maps the `referenced-element` meta value (set during refraction) to the
+ * Components Object field where the referenced element should be hoisted.
+ * Field names are sourced from the Components Object fixed fields so they
+ * cannot drift from the namespace definition.
+ */
+const cf = fixedFields(ComponentsElement, {
+  indexed: true
+});
+const componentFieldByReferencedElement = {
+  schema: cf.schemas.name,
+  server: cf.servers.name,
+  serverVariable: cf.serverVariables.name,
+  channelItem: cf.channels.name,
+  message: cf.messages.name,
+  securityScheme: cf.securitySchemes.name,
+  parameter: cf.parameters.name,
+  correlationID: cf.correlationIds.name,
+  operationTrait: cf.operationTraits.name,
+  messageTrait: cf.messageTraits.name,
+  serverBindings: cf.serverBindings.name,
+  channelBindings: cf.channelBindings.name,
+  operationBindings: cf.operationBindings.name,
+  messageBindings: cf.messageBindings.name
+};
+
+/**
+ * Maps a Components Object field to the named-content element the namespace
+ * uses for it, so a bundle-created field matches a parsed/refracted one
+ * (e.g. carries the `components-schemas` class) rather than being a generic
+ * object.
+ */
+const componentFieldElementByField = {
+  [cf.schemas.name]: ComponentsSchemasElement,
+  [cf.servers.name]: ComponentsServersElement,
+  [cf.serverVariables.name]: ComponentsServerVariablesElement,
+  [cf.channels.name]: ComponentsChannelsElement,
+  [cf.messages.name]: ComponentsMessagesElement,
+  [cf.securitySchemes.name]: ComponentsSecuritySchemesElement,
+  [cf.parameters.name]: ComponentsParametersElement,
+  [cf.correlationIds.name]: ComponentsCorrelationIDsElement,
+  [cf.operationTraits.name]: ComponentsOperationTraitsElement,
+  [cf.messageTraits.name]: ComponentsMessageTraitsElement,
+  [cf.serverBindings.name]: ComponentsServerBindingsElement,
+  [cf.channelBindings.name]: ComponentsChannelBindingsElement,
+  [cf.operationBindings.name]: ComponentsOperationBindingsElement,
+  [cf.messageBindings.name]: ComponentsMessageBindingsElement
+};
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class AsyncAPI2BundleVisitor {
+  reference;
+  options;
+
+  /**
+   * The base URI (without hash) of the entry document. A reference is
+   * considered internal when it resolves to this URI and external otherwise.
+   * Derived from the shared refSet's root reference.
+   */
+  get entryURI() {
+    return url.stripHash(this.reference.refSet?.rootRef?.uri ?? '');
+  }
+
+  /**
+   * The entry parse result. Derived from the shared refSet's root reference.
+   */
+  get entryParseResult() {
+    return this.reference.refSet.rootRef.value;
+  }
+
+  /**
+   * The entry document element. Hoisted external fragments are placed into its
+   * `components` object. The `canBundle` guard guarantees it is an
+   * AsyncApi2Element.
+   */
+  get entryResult() {
+    return this.entryParseResult.result;
+  }
+
+  /**
+   * Shared across the entry document and every external document visitor.
+   * Guarantees each external fragment is hoisted exactly once and gives us a
+   * stable internal pointer to rewrite every referencing element to.
+   */
+  assignments;
+
+  /**
+   * Component names already reserved per Components Object field. Reserved
+   * before recursion so collision suffixing (`Pet`, `Pet-2`, ...) accounts for
+   * components that are still being bundled.
+   */
+  reservedNames;
+
+  /**
+   * Caches refracted fragments keyed by source element and target element type.
+   * The type is part of the key because the same source can be refracted into
+   * different semantic elements depending on the referencing context (e.g. a
+   * generic object referenced once as a Parameter and once as a Schema).
+   */
+  refractCache;
+  constructor({
+    reference,
+    options,
+    assignments = new Map(),
+    reservedNames = new Map(),
+    refractCache = new WeakMap()
+  }) {
+    this.reference = reference;
+    this.options = options;
+    this.assignments = assignments;
+    this.reservedNames = reservedNames;
+    this.refractCache = refractCache;
+  }
+  getRefracted(source, type) {
+    return this.refractCache.get(source)?.get(type);
+  }
+  setRefracted(source, type, refracted) {
+    let byType = this.refractCache.get(source);
+    if (byType === undefined) {
+      byType = new Map();
+      this.refractCache.set(source, byType);
+    }
+    byType.set(type, refracted);
+  }
+  toBaseURI(uri) {
+    return url.resolve(this.reference.uri, url.sanitize(url.stripHash(uri)));
+  }
+  async toReference(uri) {
+    // detect maximum depth of resolution
+    if (this.reference.depth >= this.options.resolve.maxDepth) {
+      throw new MaximumResolveDepthError(`Maximum resolution depth of ${this.options.resolve.maxDepth} has been exceeded by file "${this.reference.uri}"`, {
+        maxDepth: this.options.resolve.maxDepth,
+        uri: this.reference.uri
+      });
+    }
+    const baseURI = this.toBaseURI(uri);
+    const {
+      refSet
+    } = this.reference;
+
+    // we've already processed this Reference in past
+    if (refSet.has(baseURI)) {
+      return refSet.find(propEq(baseURI, 'uri'));
+    }
+    const parseResult = await parse(url.unsanitize(baseURI), {
+      ...this.options,
+      parse: {
+        ...this.options.parse,
+        mediaType: 'text/plain'
+      }
+    });
+    const reference = new Reference({
+      uri: baseURI,
+      value: parseResult,
+      depth: this.reference.depth + 1
+    });
+    refSet.add(reference);
+    return reference;
+  }
+
+  /**
+   * Normalizes a self-reference (e.g. `./root.json#/components/schemas/Pet`)
+   * to a bare fragment (`#/components/schemas/Pet`) so the bundled document stays
+   * transferable. Bare fragments are returned unchanged.
+   */
+  normalizeSelfReference(ref) {
+    return ref.startsWith('#') ? ref : url.getHash(ref);
+  }
+
+  /**
+   * Handles an error according to the `bundle.continueOnError` option.
+   *
+   * For new errors: wraps in UnresolvableReferenceError with structured
+   * context. For errors already wrapped by a nested visitor: prepends the
+   * current hop to the trace.
+   *
+   * Inner/intermediate visitors always throw to let the trace accumulate. Only
+   * the entry document visitor respects continueOnError (callback/swallow/throw).
+   */
+  handleError(message, error, referencingElement, refFieldName, refFieldValue, visitorPath) {
+    // a collision reported as `error` is a deliberate hard stop with no
+    // resolution-failure analog, so pass it through unchanged. A maxDepth
+    // breach (MaximumBundleDepthError, which also extends BundleError) is a
+    // resolution failure and flows through below — wrapped and subject to
+    // continueOnError, like dereferencing.
+    if (error instanceof BundleError && !(error instanceof MaximumBundleDepthError)) {
+      throw error;
+    }
+    const {
+      continueOnError
+    } = this.options.bundle;
+    const isEntryDocument = url.stripHash(this.reference.refSet?.rootRef?.uri ?? '') === this.reference.uri;
+    const uri = this.reference.uri;
+    const type = referencingElement.element;
+    const codeFrame = toYAML(referencingElement);
+    const location = visitorPath.formatPath();
+    const hop = {
+      uri,
+      type,
+      refFieldName,
+      refFieldValue,
+      location,
+      codeFrame
+    };
+    let unresolvedError;
+    if (error instanceof UnresolvableReferenceError) {
+      // @ts-ignore
+      error.trace = [hop, ...error.trace];
+      unresolvedError = error;
+    } else {
+      unresolvedError = new UnresolvableReferenceError(message, {
+        cause: error,
+        type,
+        uri,
+        location,
+        codeFrame,
+        refFieldName,
+        refFieldValue,
+        trace: []
+      });
+    }
+    if (!isEntryDocument || continueOnError === false) throw unresolvedError;
+    if (typeof continueOnError === 'function') continueOnError(unresolvedError);
+  }
+
+  /**
+   * Lazily creates the Components Object (and the requested field within it)
+   * on the entry document, returning the field where a fragment is hoisted.
+   */
+  ensureComponentsField(field) {
+    const entryResult = this.entryResult;
+    let components = entryResult.components;
+    if (!isObjectElement(components)) {
+      components = new ComponentsElement();
+      entryResult.components = components;
+    }
+    let fieldElement = components.get(field);
+    if (!isObjectElement(fieldElement)) {
+      const FieldElement = componentFieldElementByField[field] ?? ObjectElement;
+      fieldElement = new FieldElement();
+      components.set(field, fieldElement);
+    }
+    return fieldElement;
+  }
+
+  /**
+   * Derives a component name from the referenced JSON Pointer's last token,
+   * falling back to the referenced file's basename.
+   */
+  basenameOf(jsonPointer, baseURI) {
+    const tokens = parseJSONPointer(jsonPointer).tree;
+    const lastToken = tokens.length > 0 ? tokens[tokens.length - 1] : '';
+    return lastToken || url.getBasename(baseURI) || 'Schema';
+  }
+
+  /**
+   * Computes the base component name (before collision suffixing) according to
+   * the configured naming strategy.
+   */
+  baseName(element, field, jsonPointer, baseURI) {
+    // strategy specific options take precedence over the top-level bundle options
+    const componentNamesStrategy = this.options.bundle.strategyOpts['asyncapi-2']?.componentNamesStrategy ?? this.options.bundle.componentNamesStrategy;
+    if (typeof componentNamesStrategy === 'function') {
+      const resolved = componentNamesStrategy({
+        element,
+        field,
+        jsonPointer,
+        baseURI
+      });
+      if (typeof resolved === 'string' && resolved !== '') {
+        return resolved;
+      }
+      return this.basenameOf(jsonPointer, baseURI);
+    }
+    if (componentNamesStrategy === 'title') {
+      const title = isObjectElement(element) ? toValue(element.get('title')) : undefined;
+      if (typeof title === 'string' && title.trim() !== '') {
+        const name = sanitizeComponentName(toPascalCase(title));
+        if (name !== '') return name;
+      }
+      // fall back to basename when no usable title is present
+    }
+    return this.basenameOf(jsonPointer, baseURI);
+  }
+
+  /**
+   * Computes a collision-free component name within the target field. A name is
+   * taken if it's already placed in components or reserved by a component that
+   * is still being bundled (reserved before recursion).
+   */
+  uniqueName(candidate, field) {
+    const fieldElement = this.ensureComponentsField(field);
+    const reserved = this.reservedNames.get(field) ?? new Set();
+    return resolveUniqueName(candidate, name => fieldElement.hasKey(name) || reserved.has(name));
+  }
+
+  /**
+   * Reports a collision-forced rename according to the configured severity.
+   * A rename means two distinct targets resolved to the same name; each keeps
+   * its own component (and origin), so report the rename per severity.
+   */
+  reportNameCollision(preferredName, componentName, field) {
+    // strategy specific options take precedence over the top-level bundle options
+    const onComponentNameCollision = this.options.bundle.strategyOpts['asyncapi-2']?.onComponentNameCollision ?? this.options.bundle.onComponentNameCollision;
+    if (componentName === preferredName || onComponentNameCollision === 'off') {
+      return;
+    }
+    const message = `Component "${preferredName}" in components/${field} is referenced with the same name but different content. Renamed to "${componentName}".`;
+    if (onComponentNameCollision === 'error') {
+      throw new BundleError(message);
+    }
+    const annotation = new AnnotationElement(message);
+    annotation.classes.push('warning');
+    annotation.code = 'bundle-component-name-collision';
+    // append (never prepend) so the result element stays ahead of annotations
+    this.entryParseResult.content.push(annotation);
+  }
+  async ReferenceElement(path) {
+    const referencingElement = path.node;
+    const $ref = toValue(referencingElement.$ref);
+    const retrievalURI = this.toBaseURI($ref);
+    const isInternalReference = this.entryURI === retrievalURI;
+    const isExternalReference = !isInternalReference;
+    if (isInternalReference) {
+      // normalize self-references to a bare fragment so the bundled
+      // document stays transferable; bare fragments are left untouched
+      referencingElement.set('$ref', this.normalizeSelfReference($ref));
+      path.skip();
+      return;
+    }
+
+    // honor the resolve.external switch
+    if (!this.options.resolve.external && isExternalReference) {
+      path.skip();
+      return;
+    }
+    const $refBaseURI = url.resolve(retrievalURI, $ref);
+    const jsonPointer = URIFragmentIdentifier.fromURIReference($refBaseURI);
+
+    // the target bucket depends on the referencing context, so it's part of the
+    // identity: the same external target referenced as e.g. both a Schema and a
+    // Message must be hoisted into both components fields. The refractor sets
+    // `referenced-element` for every Reference Object position; the `schema`
+    // fallback is a defensive default for the (unexpected) untagged case.
+    const referencedElementType = referencingElement.meta.get('referenced-element');
+    const field = componentFieldByReferencedElement[referencedElementType] ?? componentFieldByReferencedElement.schema;
+    const canonicalKey = `${field}\t${retrievalURI}#${jsonPointer}`;
+
+    // already hoisted (or being hoisted) — just rewrite the pointer.
+    //
+    // this is also how circular references terminate: the assignment is
+    // reserved BEFORE recursing into the fragment (see below), so a reference
+    // that cycles back (directly or indirectly) finds its pointer already
+    // reserved here and is rewritten without recursing. Cycles are deliberately
+    // preserved as internal `$ref`s pointing at each other — that is valid,
+    // serializable output; resolving the cycle (if desired) is dereferencing's
+    // job, not bundling's.
+    if (this.assignments.has(canonicalKey)) {
+      referencingElement.set('$ref', this.assignments.get(canonicalKey));
+      path.skip();
+      return;
+    }
+    try {
+      // detect maximum depth of bundling
+      if (this.reference.depth >= this.options.bundle.maxDepth) {
+        throw new MaximumBundleDepthError(`Maximum bundle depth of "${this.options.bundle.maxDepth}" has been exceeded in file "${this.reference.uri}"`, {
+          maxDepth: this.options.bundle.maxDepth,
+          uri: this.reference.uri
+        });
+      }
+      const reference = await this.toReference($ref);
+
+      // possibly non-semantic fragment
+      let referencedElement = evaluate(reference.value.result, jsonPointer);
+
+      // apply semantics to the fragment so nested references become Reference Objects
+      if (referencedElement.element !== referencedElementType && !isReferenceElement(referencedElement)) {
+        const cached = this.getRefracted(referencedElement, referencedElementType);
+        if (cached !== undefined) {
+          referencedElement = cached;
+        } else if (isReferenceLikeElement(referencedElement)) {
+          const sourceElement = referencedElement;
+          referencedElement = refractReference(referencedElement);
+          referencedElement.meta.set('referenced-element', referencedElementType);
+          this.setRefracted(sourceElement, referencedElementType, referencedElement);
+        } else {
+          const sourceElement = referencedElement;
+          referencedElement = refract(referencedElement, {
+            element: referencedElementType
+          });
+          this.setRefracted(sourceElement, referencedElementType, referencedElement);
+        }
+      }
+      const preferredName = this.baseName(referencedElement, field, jsonPointer, retrievalURI);
+      const componentName = this.uniqueName(preferredName, field);
+      const internalPointer = `#/components/${field}/${escape(componentName)}`;
+      this.reportNameCollision(preferredName, componentName, field);
+
+      // reserve the assignment and component name before recursing so cyclic
+      // references terminate
+      this.assignments.set(canonicalKey, internalPointer);
+      if (!this.reservedNames.has(field)) this.reservedNames.set(field, new Set());
+      this.reservedNames.get(field).add(componentName);
+
+      // own a copy of the fragment and bundle its own external references
+      const hoistedElement = cloneDeep(referencedElement);
+      const visitor = new AsyncAPI2BundleVisitor({
+        reference,
+        options: this.options,
+        assignments: this.assignments,
+        reservedNames: this.reservedNames,
+        refractCache: this.refractCache
+      });
+      const bundledElement = await traverseAsync(hoistedElement, visitor, {
+        mutable: true
+      });
+
+      // annotate the hoisted fragment with info about its origin
+      if (isElement(bundledElement)) {
+        bundledElement.meta.set('ref-origin', reference.uri);
+      }
+
+      // place the bundled fragment into the entry document's components
+      this.ensureComponentsField(field).set(componentName, bundledElement);
+
+      // rewrite the referencing element to point at the hoisted fragment
+      referencingElement.set('$ref', internalPointer);
+      path.skip();
+    } catch (error) {
+      this.handleError(`Error while bundling Reference Object. Cannot resolve $ref "${$ref}": ${error.message}`, error, referencingElement, '$ref', $ref, path);
+      path.skip();
+    }
+  }
+
+  /**
+   * AsyncAPI 2.0 has a `components.channels` field, so an external Channel Item
+   * Object is hoisted there and the referencing `$ref` is rewritten to an
+   * internal pointer — mirroring how Reference Objects are bundled. Sibling
+   * fields next to the `$ref` (e.g. `description`) are kept on the referencing
+   * element.
+   */
+  async ChannelItemElement(path) {
+    const channelItemElement = path.node;
+
+    // ignore Channel Item Objects without a $ref field
+    if (!isStringElement(channelItemElement.$ref)) {
+      return;
+    }
+    const $ref = toValue(channelItemElement.$ref);
+    const retrievalURI = this.toBaseURI($ref);
+    const isInternalReference = this.entryURI === retrievalURI;
+    const isExternalReference = !isInternalReference;
+    if (isInternalReference) {
+      // normalize self-references to a bare fragment so the bundled
+      // document stays transferable; bare fragments are left untouched
+      channelItemElement.set('$ref', this.normalizeSelfReference($ref));
+      path.skip();
+      return;
+    }
+
+    // honor the resolve.external switch
+    if (!this.options.resolve.external && isExternalReference) {
+      path.skip();
+      return;
+    }
+    const $refBaseURI = url.resolve(retrievalURI, $ref);
+    const jsonPointer = URIFragmentIdentifier.fromURIReference($refBaseURI);
+    const field = cf.channels.name;
+    const canonicalKey = `${field}\t${retrievalURI}#${jsonPointer}`;
+
+    // already hoisted (or being hoisted) — just rewrite the pointer. The
+    // assignment is reserved BEFORE recursing, so a circular Channel Item chain
+    // terminates here with an internal pointer instead of recursing forever.
+    if (this.assignments.has(canonicalKey)) {
+      channelItemElement.set('$ref', this.assignments.get(canonicalKey));
+      path.skip();
+      return;
+    }
+    try {
+      // detect maximum depth of bundling
+      if (this.reference.depth >= this.options.bundle.maxDepth) {
+        throw new MaximumBundleDepthError(`Maximum bundle depth of "${this.options.bundle.maxDepth}" has been exceeded in file "${this.reference.uri}"`, {
+          maxDepth: this.options.bundle.maxDepth,
+          uri: this.reference.uri
+        });
+      }
+      const reference = await this.toReference($ref);
+      let referencedElement = evaluate(reference.value.result, jsonPointer);
+
+      // apply Channel Item semantics to the referenced fragment
+      if (!isChannelItemElement(referencedElement)) {
+        const cached = this.getRefracted(referencedElement, 'channelItem');
+        if (cached !== undefined) {
+          referencedElement = cached;
+        } else {
+          const sourceElement = referencedElement;
+          referencedElement = refractChannelItem(referencedElement);
+          this.setRefracted(sourceElement, 'channelItem', referencedElement);
+        }
+      }
+      const preferredName = this.baseName(referencedElement, field, jsonPointer, retrievalURI);
+      const componentName = this.uniqueName(preferredName, field);
+      const internalPointer = `#/components/${field}/${escape(componentName)}`;
+      this.reportNameCollision(preferredName, componentName, field);
+
+      // reserve the assignment and component name before recursing so cyclic
+      // references terminate
+      this.assignments.set(canonicalKey, internalPointer);
+      if (!this.reservedNames.has(field)) this.reservedNames.set(field, new Set());
+      this.reservedNames.get(field).add(componentName);
+
+      // own a copy of the fragment and bundle its own external references
+      const hoistedElement = cloneDeep(referencedElement);
+      const visitor = new AsyncAPI2BundleVisitor({
+        reference,
+        options: this.options,
+        assignments: this.assignments,
+        reservedNames: this.reservedNames,
+        refractCache: this.refractCache
+      });
+      const bundledElement = await traverseAsync(hoistedElement, visitor, {
+        mutable: true
+      });
+
+      // a `$ref` surviving on the hoisted Channel Item means it pointed at
+      // another Channel Item (a chain or cycle); it has already been rewritten
+      // to an internal `#/components/channels/...` pointer by the child traversal
+      bundledElement.meta.set('ref-origin', reference.uri);
+
+      // place the bundled Channel Item into the entry document's components
+      this.ensureComponentsField(field).set(componentName, bundledElement);
+
+      // rewrite the referencing Channel Item to point at the hoisted one, keeping
+      // any sibling fields (e.g. description) next to the $ref
+      channelItemElement.set('$ref', internalPointer);
+      path.skip();
+    } catch (error) {
+      this.handleError(`Error while bundling Channel Item Object. Cannot resolve $ref "${$ref}": ${error.message}`, error, channelItemElement, '$ref', $ref, path);
+      path.skip();
+    }
+  }
+}
+export default AsyncAPI2BundleVisitor;

package/src/configuration/saturated.cjs

@@ -39,18 +39,20 @@ var _index28 = _interopRequireDefault(require("../dereference/strategies/overlay
 var _index29 = _interopRequireDefault(require("../bundle/strategies/openapi-2/index.cjs"));
 var _index30 = _interopRequireDefault(require("../bundle/strategies/openapi-3-0/index.cjs"));
 var _index31 = _interopRequireDefault(require("../bundle/strategies/openapi-3-1/index.cjs"));
-var _index32 = require("../index.cjs");
-Object.keys(_index32).forEach(function (key) {
+var _index32 = _interopRequireDefault(require("../bundle/strategies/asyncapi-2/index.cjs"));
+var _index33 = _interopRequireDefault(require("../bundle/strategies/arazzo-1/index.cjs"));
+var _index34 = require("../index.cjs");
+Object.keys(_index34).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _index32[key]) return;
+  if (key in exports && exports[key] === _index34[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _index32[key];
+      return _index34[key];
     }
   });
 });
-_index32.options.parse.parsers = [new _index9.default({
+_index34.options.parse.parsers = [new _index9.default({
   allowEmpty: true,
   sourceMap: false
 }), new _index0.default({
@@ -98,11 +100,11 @@ _index32.options.parse.parsers = [new _index9.default({
 }), new _indexNode2.default({
   allowEmpty: true
 })];
-_index32.options.resolve.resolvers = [new _indexNode.default(), new _index.default({
+_index34.options.resolve.resolvers = [new _indexNode.default(), new _index.default({
   timeout: 5000,
   redirects: 5,
   withCredentials: false
 })];
-_index32.options.resolve.strategies = [new _index2.default(), new _index3.default(), new _index4.default(), new _index5.default(), new _index6.default(), new _index7.default(), new _index8.default()];
-_index32.options.dereference.strategies = [new _index23.default(), new _index24.default(), new _index25.default(), new _index26.default(), new _index27.default(), new _index28.default(), new _index22.default()];
-_index32.options.bundle.strategies = [new _index29.default(), new _index30.default(), new _index31.default()];
+_index34.options.resolve.strategies = [new _index2.default(), new _index3.default(), new _index4.default(), new _index5.default(), new _index6.default(), new _index7.default(), new _index8.default()];
+_index34.options.dereference.strategies = [new _index23.default(), new _index24.default(), new _index25.default(), new _index26.default(), new _index27.default(), new _index28.default(), new _index22.default()];
+_index34.options.bundle.strategies = [new _index29.default(), new _index30.default(), new _index31.default(), new _index32.default(), new _index33.default()];

package/src/configuration/saturated.mjs

@@ -33,6 +33,8 @@ import Overlay1DereferenceStrategy from "../dereference/strategies/overlay-1/ind
 import OpenAPI2BundleStrategy from "../bundle/strategies/openapi-2/index.mjs";
 import OpenAPI3_0BundleStrategy from "../bundle/strategies/openapi-3-0/index.mjs";
 import OpenAPI3_1BundleStrategy from "../bundle/strategies/openapi-3-1/index.mjs";
+import AsyncAPI2BundleStrategy from "../bundle/strategies/asyncapi-2/index.mjs";
+import Arazzo1BundleStrategy from "../bundle/strategies/arazzo-1/index.mjs";
 import { options } from "../index.mjs";
 options.parse.parsers = [new OpenAPIJSON2Parser({
   allowEmpty: true,
@@ -89,5 +91,5 @@ options.resolve.resolvers = [new FileResolver(), new HTTPResolverAxios({
 })];
 options.resolve.strategies = [new OpenAPI2ResolveStrategy(), new OpenAPI3_0ResolveStrategy(), new OpenAPI3_1ResolveStrategy(), new AsyncAPI2ResolveStrategy(), new Arazzo1ResolveStrategy(), new Overlay1ResolveStrategy(), new ApiDOMResolveStrategy()];
 options.dereference.strategies = [new OpenAPI2DereferenceStrategy(), new OpenAPI3_0DereferenceStrategy(), new OpenAPI3_1DereferenceStrategy(), new AsyncAPI2DereferenceStrategy(), new Arazzo1DereferenceStrategy(), new Overlay1DereferenceStrategy(), new ApiDOMDereferenceStrategy()];
-options.bundle.strategies = [new OpenAPI2BundleStrategy(), new OpenAPI3_0BundleStrategy(), new OpenAPI3_1BundleStrategy()];
+options.bundle.strategies = [new OpenAPI2BundleStrategy(), new OpenAPI3_0BundleStrategy(), new OpenAPI3_1BundleStrategy(), new AsyncAPI2BundleStrategy(), new Arazzo1BundleStrategy()];
 export * from "../index.mjs";

package/types/bundle/strategies/arazzo-1/index.d.ts

@@ -0,0 +1,31 @@
+import { ParseResultElement } from '@speclynx/apidom-datamodel';
+import File from '../../../File.ts';
+import BundleStrategy, { BundleStrategyOptions } from '../BundleStrategy.ts';
+import Arazzo1BundleVisitor from './visitor.ts';
+import type { ReferenceOptions } from '../../../options/index.ts';
+export type { default as DereferenceStrategy, DereferenceStrategyOptions, } from '../../../dereference/strategies/DereferenceStrategy.ts';
+export type { default as File, FileOptions } from '../../../File.ts';
+export type { default as Reference, ReferenceOptions } from '../../../Reference.ts';
+export type { default as ReferenceSet, ReferenceSetOptions } from '../../../ReferenceSet.ts';
+export type { Arazzo1BundleVisitorOptions } from './visitor.ts';
+export type { ReferenceOptions as ApiDOMReferenceOptions, ReferenceBundleOptions as ApiDOMReferenceBundleOptions, ReferenceDereferenceOptions as ApiDOMReferenceDereferenceOptions, ReferenceParseOptions as ApiDOMReferenceParseOptions, ReferenceResolveOptions as ApiDOMReferenceResolveOptions, } from '../../../options/index.ts';
+export type { default as Parser, ParserOptions } from '../../../parse/parsers/Parser.ts';
+export type { default as Resolver, ResolverOptions } from '../../../resolve/resolvers/Resolver.ts';
+export type { default as ResolveStrategy, ResolveStrategyOptions, } from '../../../resolve/strategies/ResolveStrategy.ts';
+export type { default as BundleStrategy, BundleStrategyOptions } from '../BundleStrategy.ts';
+export type { ComponentNamesStrategy, ComponentNameResolver, ComponentNameResolverArgs, ComponentNameCollisionSeverity, } from '../../../options/index.ts';
+/**
+ * @public
+ */
+export interface Arazzo1BundleStrategyOptions extends Omit<BundleStrategyOptions, 'name'> {
+}
+/**
+ * @public
+ */
+declare class Arazzo1BundleStrategy extends BundleStrategy {
+    constructor(options?: Arazzo1BundleStrategyOptions);
+    canBundle(file: File): boolean;
+    bundle(file: File, options: ReferenceOptions): Promise<ParseResultElement>;
+}
+export { Arazzo1BundleVisitor };
+export default Arazzo1BundleStrategy;