@speclynx/apidom-reference 6.2.0 → 7.0.0

package/src/dereference/strategies/openapi-3-0/visitor.mjs

@@ -1,366 +1,144 @@
-import { propEq } from 'ramda';
 import { isUndefined } from 'ramda-adjunct';
-import { isStringElement, isElement, RefElement, cloneShallow, cloneDeep } from '@speclynx/apidom-datamodel';
-import { toValue, toYAML } from '@speclynx/apidom-core';
+import { isElement, isStringElement, cloneShallow } from '@speclynx/apidom-datamodel';
+import { toValue } from '@speclynx/apidom-core';
 import { ApiDOMStructuredError } from '@speclynx/apidom-error';
-import { traverse, traverseAsync, find } from '@speclynx/apidom-traverse';
-import { evaluate, URIFragmentIdentifier } from '@speclynx/apidom-json-pointer';
-import { isReferenceElement, isOperationElement, isPathItemElement, isReferenceLikeElement, refract, refractReference, refractPathItem, refractOperation } from '@speclynx/apidom-ns-openapi-3-0';
-import UnresolvableReferenceError from "../../../errors/UnresolvableReferenceError.mjs";
-import MaximumDereferenceDepthError from "../../../errors/MaximumDereferenceDepthError.mjs";
-import MaximumResolveDepthError from "../../../errors/MaximumResolveDepthError.mjs";
+import { find } from '@speclynx/apidom-traverse';
+import { evaluate as jsonPointerEvaluate, URIFragmentIdentifier } from '@speclynx/apidom-json-pointer';
+import { isReferenceLikeElement, isPathItemElement, isReferenceElement, isOperationElement, refract, refractReference } from '@speclynx/apidom-ns-openapi-3-0';
+import DereferenceVisitor from "../DereferenceVisitor.mjs";
 import * as url from "../../../util/url.mjs";
-import parse from "../../../parse/index.mjs";
-import Reference from "../../../Reference.mjs";
-import { AncestorLineage } from "../../util.mjs";
 /**
  * @public
  */
 /**
+ * Dereferences an OpenAPI 3.0 document. Reference Objects expect the type of their
+ * `referenced-element` meta, Path Item `$ref`s a Path Item Object. Link Objects get the
+ * Operation Object they point at attached, Example Objects the external value.
+ *
  * @public
  */
-class OpenAPI3_0DereferenceVisitor {
-  indirections;
-  reference;
-  options;
-  refractCache;
-  visited;
-
-  /**
-   * Tracks element ancestors across dive-deep traversal boundaries.
-   * Used for cycle detection: if a referenced element is found in
-   * the ancestor lineage, a circular reference is detected.
-   */
-  ancestors;
-  constructor({
-    reference,
-    options,
-    indirections = [],
-    ancestors = new AncestorLineage(),
-    refractCache = new WeakMap(),
-    visited = new WeakSet()
-  }) {
-    this.indirections = indirections;
-    this.reference = reference;
-    this.options = options;
-    this.ancestors = new AncestorLineage(...ancestors);
-    this.refractCache = refractCache;
-    this.visited = visited;
-  }
-  toAncestorLineage(path) {
-    const ancestorNodes = path.getAncestorNodes();
-    const directAncestors = new Set(ancestorNodes.filter(isElement));
-    const ancestorsLineage = new AncestorLineage(...this.ancestors, directAncestors);
-    return [ancestorsLineage, directAncestors];
+class OpenAPI3_0DereferenceVisitor extends DereferenceVisitor {
+  get strategyName() {
+    return 'openapi-3-0';
   }
-  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'
-      }
-    });
-
-    // register new mutable reference with a refSet
-    //
-    // NOTE(known limitation): the mutable reference is mutated in place during traversal
-    // (via `{ mutable: true }`). When an external document evaluates a JSON pointer back
-    // into this document, it may receive an already-resolved element instead of the original
-    // $ref. That resolved element was produced using the entry document's resolution context
-    // (ancestors, indirections), which may differ from the external document's context.
-    // This can affect cycle detection in rare cross-document circular reference patterns.
-    //
-    // Remediation: evaluate JSON pointers against the immutable (original) parse tree
-    // instead of the mutable working copy. The `immutable://` reference below preserves
-    // the original tree and could be used for pointer evaluation, ensuring every resolution
-    // context always sees raw, unresolved elements and processes them with its own
-    // ancestors/indirections. The trade-off is that elements referenced by multiple
-    // documents would be resolved once per context instead of being reused.
-    const mutableReference = new Reference({
-      uri: baseURI,
-      value: this.options.dereference.immutable ? cloneDeep(parseResult) : parseResult,
-      depth: this.reference.depth + 1
+  createVisitor(reference) {
+    return new OpenAPI3_0DereferenceVisitor({
+      reference,
+      options: this.options
     });
-    refSet.add(mutableReference);
-    if (this.options.dereference.immutable) {
-      // register new immutable reference with a refSet
-      const immutableReference = new Reference({
-        uri: `immutable://${baseURI}`,
-        value: parseResult,
-        depth: this.reference.depth + 1
-      });
-      refSet.add(immutableReference);
-    }
-    return mutableReference;
   }
 
   /**
-   * Handles an error according to the continueOnError option.
-   *
-   * For new errors: wraps in UnresolvableReferenceError with structured context
-   * (type, uri, location, codeFrame, refFieldName, refFieldValue, trace).
-   * 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).
+   * A Reference Object stands for the type its reference expects: it's dereferenced as that type.
    */
-  handleError(message, error, referencingElement, refFieldName, refFieldValue, visitorPath) {
-    const {
-      continueOnError
-    } = this.options.dereference;
-    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);
-
-    // find element location by identity in the document tree.
-    // guarded: this.reference.value may not be a ParseResultElement or may lack a result.
-    // falls back to visitorPath which may produce an incomplete path when
-    // dereferenceApiDOM is called with a fragment (cloneShallow creates a new root identity).
-    let location;
-    const root = this.reference.value.result;
-    if (isElement(root)) {
-      traverse(root, {
-        enter: p => {
-          if (p.node === referencingElement || this.refractCache.get(p.node) === referencingElement) {
-            location = p.formatPath();
-            p.stop();
-          }
-        }
-      });
-    }
-    location ??= visitorPath.formatPath();
-    const hop = {
-      uri,
-      type,
-      refFieldName,
-      refFieldValue,
-      location,
-      codeFrame
-    };
+  isOfType(element, type) {
+    return isReferenceElement(element) || element.element === type;
+  }
 
-    // enrich existing error from nested visitor or create new one
-    let unresolvedError;
-    if (error instanceof UnresolvableReferenceError) {
-      // prefix relative locations for entries belonging to the referenced document
-      const refBaseURI = this.toBaseURI(refFieldValue);
-      const fragment = URIFragmentIdentifier.fromURIReference(refFieldValue);
-      if (fragment) {
-        if (refBaseURI === error.uri && error.location) {
-          error.location = fragment + error.location;
-        }
-        for (const h of error.trace) {
-          if (h.uri === refBaseURI && h.location) h.location = fragment + h.location;
-        }
-      }
-      // @ts-ignore
-      error.trace = [hop, ...error.trace];
-      unresolvedError = error;
-    } else {
-      unresolvedError = new UnresolvableReferenceError(message, {
-        cause: error,
-        type,
-        uri,
-        location,
-        codeFrame,
-        refFieldName,
-        refFieldValue,
-        trace: []
-      });
+  /**
+   * A generic structure holding a `$ref` is a Reference Object to the expected type,
+   * unless the type has its own `$ref` field (Path Item Object).
+   */
+  refractTo(element, type) {
+    if (type !== 'pathItem' && isReferenceLikeElement(element)) {
+      const referenceElement = refractReference(element);
+      referenceElement.meta.set('referenced-element', type);
+      return referenceElement;
     }
-    if (!isEntryDocument || continueOnError === false) throw unresolvedError;
-    if (typeof continueOnError === 'function') continueOnError(unresolvedError);
+    return refract(element, {
+      element: type
+    });
   }
   async ReferenceElement(path) {
     const referencingElement = path.node;
 
-    // ignore Reference Object without a string $ref, e.g. an empty YAML value
-    if (!isStringElement(referencingElement.$ref)) {
-      return;
-    }
+    // the fields of a Reference Object hold no references
+    path.skip();
 
-    // skip current referencing element as it's already been access
-    if (this.indirections.includes(referencingElement)) {
-      path.skip();
+    // ignore Reference Object without a string $ref, e.g. an empty YAML value
+    if (this.isTranscluded(referencingElement) || !isStringElement(referencingElement.$ref)) {
       return;
     }
-    const retrievalURI = this.toBaseURI(toValue(referencingElement.$ref));
+    const $ref = toValue(referencingElement.$ref);
+    const retrievalURI = this.toBaseURI($ref);
     const isInternalReference = url.stripHash(this.reference.uri) === retrievalURI;
     const isExternalReference = !isInternalReference;
 
     // ignore resolving internal Reference Objects
     if (!this.options.resolve.internal && isInternalReference) {
-      // skip traversing this reference element and all it's child elements
-      path.skip();
       return;
     }
     // ignore resolving external Reference Objects
     if (!this.options.resolve.external && isExternalReference) {
-      // skip traversing this reference element and all it's child elements
-      path.skip();
       return;
     }
-    const $refBaseURI = url.resolve(retrievalURI, toValue(referencingElement.$ref));
-    const indirectionsSize = this.indirections.length;
+    const $refBaseURI = url.resolve(retrievalURI, $ref);
     try {
-      const reference = await this.toReference(toValue(referencingElement.$ref));
-      this.indirections.push(referencingElement);
+      const reference = await this.toReference($ref);
       const jsonPointer = URIFragmentIdentifier.fromURIReference($refBaseURI);
-
       // possibly non-semantic fragment
-      let referencedElement = evaluate(reference.value.result, jsonPointer);
+      const referencedElement = jsonPointerEvaluate(reference.value.result, jsonPointer);
 
-      // applying semantics to a fragment
-      const referencedElementType = referencingElement.meta.get('referenced-element');
-      if (referencedElement.element !== referencedElementType && !isReferenceElement(referencedElement)) {
-        if (this.refractCache.has(referencedElement)) {
-          referencedElement = this.refractCache.get(referencedElement);
-        } else if (isReferenceLikeElement(referencedElement)) {
-          // handling generic indirect references
-          const sourceElement = referencedElement;
-          referencedElement = refractReference(referencedElement);
-          referencedElement.meta.set('referenced-element', referencedElementType);
-          this.refractCache.set(sourceElement, referencedElement);
-        } else {
-          // handling direct references
-          const sourceElement = referencedElement;
-          referencedElement = refract(referencedElement, {
-            element: referencedElementType
-          });
-          this.refractCache.set(sourceElement, referencedElement);
-        }
-      }
-
-      // detect direct or indirect reference
+      // detect direct reference
       if (referencingElement === referencedElement) {
         throw new ApiDOMStructuredError('Recursive Reference Object detected', {
-          $ref: toValue(referencingElement.$ref)
+          $ref
         });
       }
 
-      // detect maximum depth of dereferencing
-      if (this.indirections.length > this.options.dereference.maxDepth) {
-        throw new MaximumDereferenceDepthError(`Maximum dereference depth of "${this.options.dereference.maxDepth}" has been exceeded in file "${this.reference.uri}"`, {
-          maxDepth: this.options.dereference.maxDepth,
-          uri: this.reference.uri
-        });
-      }
-
-      // detect second deep dive into the same fragment and avoid it
-      const [ancestorsLineage, directAncestors] = this.toAncestorLineage(path);
-      if (ancestorsLineage.includes(referencedElement)) {
-        reference.refSet.circular = true;
-        if (this.options.dereference.circular === 'error') {
-          throw new ApiDOMStructuredError('Circular reference detected', {
-            $ref: toValue(referencingElement.$ref)
+      // a reference without an expected type reads its target as its own type
+      const type = toValue(referencingElement.meta.get('referenced-element')) ?? referencedElement.element;
+      await this.addTransclusion(path, {
+        source: referencedElement,
+        type,
+        reference,
+        context: undefined
+      }, {
+        toTranscludedElement: (element, target) => {
+          // a chain of Reference Objects leading back to itself never reaches a value
+          if (isReferenceElement(target)) return element;
+
+          /**
+           * Creating a new version of referenced element to avoid modifying the original one.
+           */
+          const mergedElement = cloneShallow(target);
+          // annotate referenced element with info about original referencing element
+          mergedElement.meta.set('ref-fields', {
+            $ref
           });
-        } else if (this.options.dereference.circular === 'replace') {
-          const refElement = new RefElement($refBaseURI, {
-            type: referencingElement.element,
+          // annotate fragment with info about origin
+          mergedElement.meta.set('ref-origin', reference.uri);
+          mergedElement.meta.set('ref-type', element.element);
+          return mergedElement;
+        },
+        circular: {
+          uri: $refBaseURI,
+          meta: {
             uri: reference.uri,
-            $ref: toValue(referencingElement.$ref)
-          });
-          const replacer = this.options.dereference.strategyOpts['openapi-3-0']?.circularReplacer ?? this.options.dereference.circularReplacer;
-          const replacement = replacer(refElement);
-          path.replaceWith(replacement);
-          path.skip();
-          return;
-        }
-      }
-
-      /**
-       * Dive deep into the fragment.
-       *
-       * Cases to consider:
-       *  1. We're crossing document boundary
-       *  2. Fragment is from non-entry document
-       *  3. Fragment is a Reference Object. We need to follow it to get the eventual value
-       *  4. We are dereferencing the fragment lazily/eagerly depending on circular mode
-       */
-      const isNonEntryDocument = url.stripHash(reference.refSet.rootRef.uri) !== reference.uri;
-      const shouldDetectCircular = ['error', 'replace'].includes(this.options.dereference.circular);
-      if ((isExternalReference || isNonEntryDocument || isReferenceElement(referencedElement) || shouldDetectCircular && !this.visited.has(referencedElement)) && !ancestorsLineage.includesCycle(referencedElement)) {
-        if (shouldDetectCircular) {
-          this.visited.add(referencedElement);
+            $ref
+          },
+          details: {
+            $ref
+          }
         }
-
-        // append referencing reference to ancestors lineage
-        directAncestors.add(referencingElement);
-        const visitor = new OpenAPI3_0DereferenceVisitor({
-          reference,
-          indirections: [...this.indirections],
-          options: this.options,
-          refractCache: this.refractCache,
-          visited: this.visited,
-          ancestors: ancestorsLineage
-        });
-        referencedElement = await traverseAsync(referencedElement, visitor, {
-          mutable: true,
-          skipVisited: 'skip'
-        });
-
-        // remove referencing reference from ancestors lineage
-        directAncestors.delete(referencingElement);
-      }
-
-      /**
-       * Creating a new version of referenced element to avoid modifying the original one.
-       */
-      const mergedElement = cloneShallow(referencedElement);
-      // annotate referenced element with info about original referencing element
-      mergedElement.meta.set('ref-fields', {
-        $ref: toValue(referencingElement.$ref)
       });
-      // annotate fragment with info about origin
-      mergedElement.meta.set('ref-origin', reference.uri);
-      mergedElement.meta.set('ref-type', referencingElement.element);
-
-      /**
-       * Transclude referencing element with merged referenced element.
-       */
-      path.replaceWith(mergedElement);
-      path.skip();
     } catch (error) {
-      const $ref = toValue(referencingElement.$ref);
       this.handleError(`Error while dereferencing Reference Object. Cannot resolve $ref "${$ref}": ${error.message}`, error, referencingElement, '$ref', $ref, path);
-    } finally {
-      if (this.indirections.length > indirectionsSize) this.indirections.pop();
     }
   }
   async PathItemElement(path) {
     const referencingElement = path.node;
-
-    // ignore PathItemElement without $ref field
-    if (!isStringElement(referencingElement.$ref)) {
+    if (this.isTranscluded(referencingElement)) {
+      path.skip();
       return;
     }
 
-    // skip current referencing element as it's already been access
-    if (this.indirections.includes(referencingElement)) {
-      path.skip();
+    // ignore PathItemElement without $ref field
+    if (!isStringElement(referencingElement.$ref)) {
       return;
     }
-    const retrievalURI = this.toBaseURI(toValue(referencingElement.$ref));
+    const $ref = toValue(referencingElement.$ref);
+    const retrievalURI = this.toBaseURI($ref);
     const isInternalReference = url.stripHash(this.reference.uri) === retrievalURI;
     const isExternalReference = !isInternalReference;
 
@@ -374,134 +152,70 @@ class OpenAPI3_0DereferenceVisitor {
       // skip traversing this Path Item element but traverse all it's child elements
       return;
     }
-    const $refBaseURI = url.resolve(retrievalURI, toValue(referencingElement.$ref));
-    const indirectionsSize = this.indirections.length;
+    const $refBaseURI = url.resolve(retrievalURI, $ref);
     try {
-      const reference = await this.toReference(toValue(referencingElement.$ref));
-      this.indirections.push(referencingElement);
+      const reference = await this.toReference($ref);
       const jsonPointer = URIFragmentIdentifier.fromURIReference($refBaseURI);
-
       // possibly non-semantic referenced element
-      let referencedElement = evaluate(reference.value.result, jsonPointer);
+      const referencedElement = jsonPointerEvaluate(reference.value.result, jsonPointer);
 
-      // applying semantics to a referenced element
-      if (!isPathItemElement(referencedElement)) {
-        if (this.refractCache.has(referencedElement)) {
-          referencedElement = this.refractCache.get(referencedElement);
-        } else {
-          const sourceElement = referencedElement;
-          referencedElement = refractPathItem(referencedElement);
-          this.refractCache.set(sourceElement, referencedElement);
-        }
-      }
-
-      // detect direct or indirect reference
+      // detect direct reference
       if (referencingElement === referencedElement) {
         throw new ApiDOMStructuredError('Recursive Path Item Object reference detected', {
-          $ref: toValue(referencingElement.$ref)
-        });
-      }
-
-      // detect maximum depth of dereferencing
-      if (this.indirections.length > this.options.dereference.maxDepth) {
-        throw new MaximumDereferenceDepthError(`Maximum dereference depth of "${this.options.dereference.maxDepth}" has been exceeded in file "${this.reference.uri}"`, {
-          maxDepth: this.options.dereference.maxDepth,
-          uri: this.reference.uri
+          $ref
         });
       }
+      await this.addTransclusion(path, {
+        source: referencedElement,
+        type: 'pathItem',
+        reference,
+        context: undefined
+      }, {
+        toTranscludedElement: (element, target) => {
+          if (!isPathItemElement(target)) return target;
+
+          /**
+           * Creating a new version of Path Item by merging fields from referenced Path Item with referencing one.
+           */
+          const mergedElement = cloneShallow(target);
+          // existing keywords from referencing PathItemElement overrides ones from referenced element
+          element.forEach((value, keyElement, item) => {
+            mergedElement.remove(toValue(keyElement));
+            mergedElement.content.push(item);
+          });
+          mergedElement.remove('$ref');
 
-      // detect cross-boundary cycle
-      const [ancestorsLineage, directAncestors] = this.toAncestorLineage(path);
-      if (ancestorsLineage.includes(referencedElement)) {
-        reference.refSet.circular = true;
-        if (this.options.dereference.circular === 'error') {
-          throw new ApiDOMStructuredError('Circular reference detected', {
-            $ref: toValue(referencingElement.$ref)
+          // annotate referenced element with info about original referencing element
+          mergedElement.meta.set('ref-fields', {
+            $ref
           });
-        } else if (this.options.dereference.circular === 'replace') {
-          const refElement = new RefElement($refBaseURI, {
-            type: referencingElement.element,
+          // annotate referenced element with info about origin and type
+          mergedElement.meta.set('ref-origin', reference.uri);
+          mergedElement.meta.set('ref-type', element.element);
+          return mergedElement;
+        },
+        aliasField: '$ref',
+        circular: {
+          uri: $refBaseURI,
+          meta: {
             uri: reference.uri,
-            $ref: toValue(referencingElement.$ref)
-          });
-          const replacer = this.options.dereference.strategyOpts['openapi-3-0']?.circularReplacer ?? this.options.dereference.circularReplacer;
-          const replacement = replacer(refElement);
-          path.replaceWith(replacement);
-          path.skip();
-          return;
-        }
-      }
-
-      /**
-       * Dive deep into the fragment.
-       *
-       * Cases to consider:
-       *  1. We're crossing document boundary
-       *  2. Fragment is from non-entry document
-       *  3. Fragment is a Path Item Object with $ref field. We need to follow it to get the eventual value
-       *  4. We are dereferencing the fragment lazily/eagerly depending on circular mode
-       */
-      const isNonEntryDocument = url.stripHash(reference.refSet.rootRef.uri) !== reference.uri;
-      const shouldDetectCircular = ['error', 'replace'].includes(this.options.dereference.circular);
-      if ((isExternalReference || isNonEntryDocument || isPathItemElement(referencedElement) && isStringElement(referencedElement.$ref) || shouldDetectCircular && !this.visited.has(referencedElement)) && !ancestorsLineage.includesCycle(referencedElement)) {
-        if (shouldDetectCircular) {
-          this.visited.add(referencedElement);
+            $ref
+          },
+          details: {
+            $ref
+          }
         }
-
-        // append referencing reference to ancestors lineage
-        directAncestors.add(referencingElement);
-        const visitor = new OpenAPI3_0DereferenceVisitor({
-          reference,
-          indirections: [...this.indirections],
-          options: this.options,
-          refractCache: this.refractCache,
-          visited: this.visited,
-          ancestors: ancestorsLineage
-        });
-        referencedElement = await traverseAsync(referencedElement, visitor, {
-          mutable: true,
-          skipVisited: 'skip'
-        });
-
-        // remove referencing reference from ancestors lineage
-        directAncestors.delete(referencingElement);
-      }
-
-      /**
-       * Creating a new version of Path Item by merging fields from referenced Path Item with referencing one.
-       */
-      if (isPathItemElement(referencedElement)) {
-        const mergedElement = cloneShallow(referencedElement);
-        // existing keywords from referencing PathItemElement overrides ones from referenced element
-        referencingElement.forEach((value, keyElement, item) => {
-          mergedElement.remove(toValue(keyElement));
-          mergedElement.content.push(item);
-        });
-        mergedElement.remove('$ref');
-
-        // annotate referenced element with info about original referencing element
-        mergedElement.meta.set('ref-fields', {
-          $ref: toValue(referencingElement.$ref)
-        });
-        // annotate referenced element with info about origin and type
-        mergedElement.meta.set('ref-origin', reference.uri);
-        mergedElement.meta.set('ref-type', referencingElement.element);
-        referencedElement = mergedElement;
-      }
-
-      /**
-       * Transclude referencing element with merged referenced element.
-       */
-      path.replaceWith(referencedElement);
+      });
     } catch (error) {
-      const $ref = toValue(referencingElement.$ref);
       this.handleError(`Error while dereferencing Path Item Object. Cannot resolve $ref "${$ref}": ${error.message}`, error, referencingElement, '$ref', $ref, path);
-    } finally {
-      if (this.indirections.length > indirectionsSize) this.indirections.pop();
     }
   }
   async LinkElement(path) {
     const linkElement = path.node;
+    if (this.isTranscluded(linkElement)) {
+      path.skip();
+      return;
+    }
 
     // ignore LinkElement without operationRef or operationId field
     if (!isStringElement(linkElement.operationRef) && !isStringElement(linkElement.operationId)) {
@@ -516,11 +230,11 @@ class OpenAPI3_0DereferenceVisitor {
       });
     }
     try {
-      let operationElement;
       if (isStringElement(linkElement.operationRef)) {
+        const operationRef = toValue(linkElement.operationRef);
         // possibly non-semantic referenced element
-        const jsonPointer = URIFragmentIdentifier.fromURIReference(toValue(linkElement.operationRef));
-        const retrievalURI = this.toBaseURI(toValue(linkElement.operationRef));
+        const jsonPointer = URIFragmentIdentifier.fromURIReference(operationRef);
+        const retrievalURI = this.toBaseURI(operationRef);
         const isInternalReference = url.stripHash(this.reference.uri) === retrievalURI;
         const isExternalReference = !isInternalReference;
 
@@ -534,51 +248,52 @@ class OpenAPI3_0DereferenceVisitor {
           // skip traversing this Link element but traverse all it's child elements
           return;
         }
-        const reference = await this.toReference(toValue(linkElement.operationRef));
-        operationElement = evaluate(reference.value.result, jsonPointer);
-        // applying semantics to a referenced element
-        if (!isOperationElement(operationElement)) {
-          if (this.refractCache.has(operationElement)) {
-            operationElement = this.refractCache.get(operationElement);
-          } else {
-            const sourceElement = operationElement;
-            operationElement = refractOperation(operationElement);
-            this.refractCache.set(sourceElement, operationElement);
-          }
-        }
-        // create shallow clone to be able to annotate with metadata
-        operationElement = cloneShallow(operationElement);
-        // annotate operation element with info about origin
-        operationElement.meta.set('ref-origin', reference.uri);
-        operationElement.meta.set('ref-type', linkElement.element);
-        const linkElementCopy = cloneShallow(linkElement);
-        linkElementCopy.operationRef?.meta.set('operation', operationElement);
-
-        /**
-         * Transclude Link Object containing Operation Object in its meta.
-         */
-        path.replaceWith(linkElementCopy);
+        const reference = await this.toReference(operationRef);
+        const operationElement = jsonPointerEvaluate(reference.value.result, jsonPointer);
+        await this.addAttachment(path, {
+          source: operationElement,
+          type: 'operation',
+          reference,
+          context: undefined
+        }, (element, target) => {
+          // create shallow clone to be able to annotate with metadata
+          const operationCopy = cloneShallow(target);
+          // annotate operation element with info about origin and type
+          operationCopy.meta.set('ref-origin', reference.uri);
+          operationCopy.meta.set('ref-type', element.element);
+
+          /**
+           * Transclude Link Object containing Operation Object in its meta.
+           */
+          const linkElementCopy = cloneShallow(element);
+          linkElementCopy.operationRef?.meta.set('operation', operationCopy);
+          return linkElementCopy;
+        });
         return;
       }
-      if (isStringElement(linkElement.operationId)) {
-        const operationId = toValue(linkElement.operationId);
-        const reference = await this.toReference(url.unsanitize(this.reference.uri));
-        const operationPath = find(reference.value.result, path => isOperationElement(path.node) && isElement(path.node.operationId) && path.node.operationId.equals(operationId));
-        operationElement = operationPath?.node;
-        // OperationElement not found by its operationId
-        if (isUndefined(operationElement)) {
-          throw new ApiDOMStructuredError(`OperationElement(operationId=${operationId}) not found`, {
-            operationId
-          });
-        }
-        const linkElementCopy = cloneShallow(linkElement);
-        linkElementCopy.operationId?.meta.set('operation', operationElement);
-
+      const operationId = toValue(linkElement.operationId);
+      const reference = await this.toReference(url.unsanitize(this.reference.uri));
+      const operationPath = find(reference.value.result, p => isOperationElement(p.node) && isElement(p.node.operationId) && p.node.operationId.equals(operationId));
+      const operationElement = operationPath?.node;
+      // OperationElement not found by its operationId
+      if (isUndefined(operationElement)) {
+        throw new ApiDOMStructuredError(`OperationElement(operationId=${operationId}) not found`, {
+          operationId
+        });
+      }
+      await this.addAttachment(path, {
+        source: operationElement,
+        type: 'operation',
+        reference,
+        context: undefined
+      }, (element, target) => {
         /**
          * Transclude Link Object containing Operation Object in its meta.
          */
-        path.replaceWith(linkElementCopy);
-      }
+        const linkElementCopy = cloneShallow(element);
+        linkElementCopy.operationId?.meta.set('operation', target);
+        return linkElementCopy;
+      });
     } catch (error) {
       const refFieldName = isStringElement(linkElement.operationRef) ? 'operationRef' : 'operationId';
       const refFieldValue = isStringElement(linkElement.operationRef) ? toValue(linkElement.operationRef) : toValue(linkElement.operationId);
@@ -587,6 +302,10 @@ class OpenAPI3_0DereferenceVisitor {
   }
   async ExampleElement(path) {
     const exampleElement = path.node;
+    if (this.isTranscluded(exampleElement)) {
+      path.skip();
+      return;
+    }
 
     // ignore ExampleElement without externalValue field
     if (!isStringElement(exampleElement.externalValue)) {
@@ -600,11 +319,12 @@ class OpenAPI3_0DereferenceVisitor {
         externalValue: toValue(exampleElement.externalValue)
       });
     }
-    const retrievalURI = this.toBaseURI(toValue(exampleElement.externalValue));
+    const externalValue = toValue(exampleElement.externalValue);
+    const retrievalURI = this.toBaseURI(externalValue);
     const isInternalReference = url.stripHash(this.reference.uri) === retrievalURI;
     const isExternalReference = !isInternalReference;
 
-    // ignore resolving external Example Objects
+    // ignore resolving internal Example Objects
     if (!this.options.resolve.internal && isInternalReference) {
       // skip traversing this Example element but traverse all it's child elements
       return;
@@ -615,22 +335,28 @@ class OpenAPI3_0DereferenceVisitor {
       return;
     }
     try {
-      const reference = await this.toReference(toValue(exampleElement.externalValue));
-
-      // shallow clone of the referenced element
-      const valueElement = cloneShallow(reference.value.result);
-      // annotate operation element with info about origin
-      valueElement.meta.set('ref-origin', reference.uri);
-      valueElement.meta.set('ref-type', exampleElement.element);
-      const exampleElementCopy = cloneShallow(exampleElement);
-      exampleElementCopy.value = valueElement;
+      const reference = await this.toReference(externalValue);
+      const valueSource = reference.value.result;
+      await this.addAttachment(path, {
+        source: valueSource,
+        type: valueSource.element,
+        reference,
+        context: undefined
+      }, (element, target) => {
+        // shallow clone of the referenced element
+        const valueElement = cloneShallow(target);
+        // annotate element with info about origin and type
+        valueElement.meta.set('ref-origin', reference.uri);
+        valueElement.meta.set('ref-type', element.element);
 
-      /**
-       * Transclude Example Object containing external value.
-       */
-      path.replaceWith(exampleElementCopy);
+        /**
+         * Transclude Example Object containing external value.
+         */
+        const exampleElementCopy = cloneShallow(element);
+        exampleElementCopy.value = valueElement;
+        return exampleElementCopy;
+      });
     } catch (error) {
-      const externalValue = toValue(exampleElement.externalValue);
       this.handleError(`Error while dereferencing Example Object. Cannot resolve externalValue "${externalValue}": ${error.message}`, error, exampleElement, 'externalValue', externalValue, path);
     }
   }