@speclynx/apidom-reference 6.1.2 → 7.0.0

package/src/dereference/strategies/arazzo-1/visitor.mjs

@@ -1,249 +1,171 @@
-import { propEq, none } from 'ramda';
-import { isElement, isStringElement, isParseResultElement, RefElement, cloneShallow, cloneDeep } from '@speclynx/apidom-datamodel';
-import { toValue, toYAML } from '@speclynx/apidom-core';
+import { none } from 'ramda';
+import { isStringElement, isParseResultElement, isPrimitiveElement, includesClasses, cloneShallow, cloneDeep } from '@speclynx/apidom-datamodel';
+import { toValue } from '@speclynx/apidom-core';
 import { ApiDOMStructuredError } from '@speclynx/apidom-error';
-import { traverse, traverseAsync } from '@speclynx/apidom-traverse';
+import { traverse } from '@speclynx/apidom-traverse';
 import { evaluate as jsonPointerEvaluate, compile as jsonPointerCompile, URIFragmentIdentifier } from '@speclynx/apidom-json-pointer';
-import { isParameterElement, isJSONSchemaElement, isBooleanJSONSchemaElement } from '@speclynx/apidom-ns-arazzo-1';
+import { isParameterElement, isJSONSchemaElement, isBooleanJSONSchemaElement, refract, refractJSONSchema } from '@speclynx/apidom-ns-arazzo-1';
 import { parse as parseRuntimeExpression } from '@swaggerexpert/arazzo-runtime-expression';
 import { isAnchor, uriToAnchor, locate as $anchorLocate } from "./selectors/$anchor.mjs";
 import { locate as uriLocate } from "./selectors/uri.mjs";
 import { locate as jsonPointerLocate } from "../openapi-3-1/selectors/json-pointer.mjs";
-import { schema$idsOf, resolveSchema$ids, resolveSchemaBaseURI, resolveSchema$refField } from "../openapi-3-1/util.mjs";
-import { maybeRefractToJSONSchemaElement, resolveArazzo$selfField, identifiedBy$self } from "./util.mjs";
-import UnresolvableReferenceError from "../../../errors/UnresolvableReferenceError.mjs";
-import MaximumDereferenceDepthError from "../../../errors/MaximumDereferenceDepthError.mjs";
-import MaximumResolveDepthError from "../../../errors/MaximumResolveDepthError.mjs";
+import { isJSONSchemaElementWith$id, collectSchema$ids, resolveSchema$ids, resolveSchemaBaseURI, resolveSchema$refField } from "../openapi-3-1/util.mjs";
+import { resolveArazzo$selfField, identifiedBy$self } from "./util.mjs";
+import DereferenceVisitor from "../DereferenceVisitor.mjs";
 import * as url from "../../../util/url.mjs";
-import parse from "../../../parse/index.mjs";
-import Reference from "../../../Reference.mjs";
 import File from "../../../File.mjs";
-import { AncestorLineage } from "../../util.mjs";
 import EvaluationJsonSchemaUriError from "../../../errors/EvaluationJsonSchemaUriError.mjs";
 /**
- * @public
+ * Type a JSON Schema `$ref` expects its target to have.
  */
+const JSON_SCHEMA_TYPE = 'JSONSchema';
+
 /**
- * @public
+ * Context of a source being dereferenced: the `$id`s of the JSON Schema elements enclosing it.
  */
-class Arazzo1DereferenceVisitor {
-  indirections;
-  reference;
 
-  /**
-   * Base URI of the current document for resolving relative references.
-   * Honors the Arazzo `$self` field when present, otherwise falls back
-   * to the retrieval URI (`this.reference.uri`).
-   */
-  baseURI;
-  options;
+/**
+ * @public
+ */
 
+/**
+ * Dereferences an Arazzo document. Reusable Objects expect the type of their
+ * `referenced-element` meta, JSON Schema `$ref`s expect a JSON Schema.
+ *
+ * @public
+ */
+class Arazzo1DereferenceVisitor extends DereferenceVisitor {
   /**
-   * Index of `$id`-bearing schemas per document, shared across nested visitors
-   * of a single dereference run so it never outlives mutations of the documents.
+   * Index of `$id`-bearing schemas per document, shared across the visitors
+   * of a single dereference run.
    */
   schema$idIndex;
-  visited;
 
   /**
    * `$id`s of the JSON Schema elements enclosing the traversal root within its
    * document (outermost first). Empty when the root is the document itself; a
-   * nested visitor traversing a fragment is seeded with the `$id`s of the
-   * schemas the fragment sits under, so the `$ref`s and `$id`s within resolve
-   * against the same base as they would from the document root.
+   * visitor traversing a fragment is seeded with the `$id`s of the schemas the
+   * fragment sits under, so the `$ref`s and `$id`s within resolve against the
+   * same base as they would from the document root.
    */
   ancestorSchema$ids;
-
-  /**
-   * 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 = [],
     schema$idIndex = new WeakMap(),
-    ancestors = new AncestorLineage(),
-    visited = new WeakSet(),
     ancestorSchema$ids = []
   }) {
-    this.indirections = indirections;
-    this.reference = reference;
-    this.baseURI = resolveArazzo$selfField(reference.uri, reference.value?.result);
-    this.options = options;
+    super({
+      reference,
+      options
+    });
     this.schema$idIndex = schema$idIndex;
-    this.ancestors = new AncestorLineage(...ancestors);
-    this.visited = visited;
     this.ancestorSchema$ids = ancestorSchema$ids;
   }
-  toAncestorLineage(path) {
-    const ancestorNodes = path.getAncestorNodes();
-    const directAncestors = new Set(ancestorNodes.filter(isElement));
-    const ancestorsLineage = new AncestorLineage(...this.ancestors, directAncestors);
-    return [ancestorsLineage, directAncestors];
+  get strategyName() {
+    return 'arazzo-1';
   }
-  toBaseURI(uri) {
-    return url.resolve(this.baseURI, url.sanitize(url.stripHash(uri)));
+  createVisitor(reference, {
+    ancestorSchema$ids
+  }) {
+    return new Arazzo1DereferenceVisitor({
+      reference,
+      options: this.options,
+      schema$idIndex: this.schema$idIndex,
+      ancestorSchema$ids
+    });
   }
-  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'));
-    }
-
-    // identity-based referencing: URI matches `$self` of an already processed Arazzo document
-    const referenceBy$self = refSet.find(identifiedBy$self(baseURI));
-    if (referenceBy$self !== undefined) {
-      return referenceBy$self;
-    }
-    const parseResult = await parse(url.unsanitize(baseURI), {
-      ...this.options,
-      parse: {
-        ...this.options.parse,
-        mediaType: 'text/plain'
-      }
+  refractTo(element, type) {
+    return type === JSON_SCHEMA_TYPE ? refractJSONSchema(element) : refract(element, {
+      element: type
     });
+  }
+  isOfType(element, type) {
+    return type === JSON_SCHEMA_TYPE ? isJSONSchemaElement(element) || isBooleanJSONSchemaElement(element) : element.element === type;
+  }
 
-    // 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
-    });
-    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;
+  /**
+   * Honors the Arazzo `$self` field when present, otherwise falls back to the retrieval URI.
+   */
+  toDocumentBaseURI(reference) {
+    return resolveArazzo$selfField(reference.uri, reference.value?.result);
   }
 
   /**
-   * 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).
+   * Identity-based referencing: URI matches `$self` of an already processed Arazzo document.
    */
-  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);
+  findReferenceByIdentity(uri) {
+    return this.reference.refSet?.find(identifiedBy$self(uri));
+  }
 
-    // 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) {
-            location = p.formatPath();
-            p.stop();
-          }
-        }
-      });
+  /**
+   * A document as JSON Schema for locating schemas within it: a generic document is
+   * refracted to JSON Schema once per dereference run, a semantic one is used as it is.
+   */
+  toJSONSchemaDocument(document) {
+    if (!isPrimitiveElement(document)) return document;
+    let byType = this.run.refracted.get(document);
+    if (byType === undefined) {
+      byType = new Map();
+      this.run.refracted.set(document, byType);
+    }
+    let refracted = byType.get(JSON_SCHEMA_TYPE);
+    if (refracted === undefined) {
+      refracted = refractJSONSchema(document);
+      byType.set(JSON_SCHEMA_TYPE, refracted);
     }
-    location ??= visitorPath.formatPath();
-    const hop = {
-      uri,
-      type,
-      refFieldName,
-      refFieldValue,
-      location,
-      codeFrame
-    };
+    return refracted;
+  }
 
-    // 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;
+  /**
+   * Indexes the `$id`-bearing schemas of a document for the run. Transcluded elements aren't
+   * indexed: they're copies of structures indexed where they're defined,
+   * and in a document dereferenced in place their shared structure would be walked once per path.
+   */
+  index$ids(element) {
+    if (this.schema$idIndex.has(element)) return;
+    const entries = [];
+    traverse(element, {
+      enter: path => {
+        if (this.isTranscluded(path.node)) {
+          path.skip();
+        } else if (isJSONSchemaElementWith$id(path.node)) {
+          entries.push({
+            schema: path.node,
+            $ids: collectSchema$ids(path)
+          });
         }
       }
-      // @ts-ignore
-      error.trace = [hop, ...error.trace];
-      unresolvedError = error;
-    } else {
-      unresolvedError = new UnresolvableReferenceError(message, {
-        cause: error,
-        type,
-        uri,
-        location,
-        codeFrame,
-        refFieldName,
-        refFieldValue,
-        trace: []
-      });
+    });
+    this.schema$idIndex.set(element, entries);
+  }
+  enter(path) {
+    if (this.isTranscluded(path.node)) {
+      path.skip();
+      return;
+    }
+    // a Source Description parsed into the document has its own components: it's dereferenced
+    // in its own context by the strategy, never by the document referencing it
+    if (path.parentPath !== null && isParseResultElement(path.node) && includesClasses(path.node, ['source-description'])) {
+      path.skip();
     }
-    if (!isEntryDocument || continueOnError === false) throw unresolvedError;
-    if (typeof continueOnError === 'function') continueOnError(unresolvedError);
   }
-  ReusableElement(path) {
+  async ReusableElement(path) {
     const referencingElement = path.node;
 
+    // the fields of a Reusable Object hold no references
+    path.skip();
+
     // skip current Reusable Object if reference field is not defined as a string
     if (!isStringElement(referencingElement.reference)) {
-      path.skip();
       return;
     }
 
     // ignore if resolve.internal is false (Reusable Objects are internal references only)
     if (!this.options.resolve.internal) {
-      path.skip();
       return;
     }
     const runtimeExpression = toValue(referencingElement.reference);
-    let referencedElement;
     try {
       // parse the runtime expression
       const {
@@ -265,6 +187,7 @@ class Arazzo1DereferenceVisitor {
 
       // evaluate runtime expression as JSON Pointer to get the referenced element
       const jsonPointer = jsonPointerCompile(['components', tree.componentType, tree.componentName]);
+      let referencedElement;
       try {
         referencedElement = jsonPointerEvaluate(this.reference.value.result, jsonPointer);
       } catch {
@@ -272,50 +195,62 @@ class Arazzo1DereferenceVisitor {
           runtimeExpression
         });
       }
+
+      // the reference decides the type of the referenced component
+      const type = toValue(referencingElement.meta.get('referenced-element')) ?? referencedElement.element;
+      await this.addTransclusion(path, {
+        source: referencedElement,
+        type,
+        reference: this.reference,
+        context: {
+          ancestorSchema$ids: []
+        }
+      }, {
+        toTranscludedElement: (element, target) => {
+          const reusableElement = element;
+          const mergedElement = cloneShallow(target);
+          // annotate with info about original referencing element
+          mergedElement.meta.set('ref-fields', {
+            reference: runtimeExpression,
+            value: toValue(reusableElement.value)
+          });
+          // annotate with info about origin
+          mergedElement.meta.set('ref-origin', this.reference.uri);
+          mergedElement.meta.set('ref-type', element.element);
+
+          // override value field if present for Parameter Objects
+          if (isParameterElement(mergedElement) && reusableElement.hasKey('value')) {
+            mergedElement.remove('value');
+            mergedElement.set('value', reusableElement.get('value'));
+          }
+          return mergedElement;
+        },
+        circular: {
+          uri: runtimeExpression,
+          meta: {
+            uri: this.reference.uri,
+            reference: runtimeExpression
+          },
+          details: {
+            runtimeExpression
+          }
+        }
+      });
     } catch (error) {
       this.handleError(`Error while dereferencing Reusable Object. Cannot resolve reference "${runtimeExpression}": ${error.message}`, error, referencingElement, 'reference', runtimeExpression, path);
-      return;
     }
-
-    /**
-     * Create a shallow clone of the referenced element to avoid modifying the original.
-     */
-    const mergedElement = cloneShallow(referencedElement);
-    // annotate with info about original referencing element
-    mergedElement.meta.set('ref-fields', {
-      reference: runtimeExpression,
-      value: toValue(referencingElement.value)
-    });
-    // annotate with info about origin
-    mergedElement.meta.set('ref-origin', this.reference.uri);
-    mergedElement.meta.set('ref-type', referencingElement.element);
-
-    // override value field if present for Parameter Objects
-    if (isParameterElement(mergedElement) && referencingElement.hasKey('value')) {
-      mergedElement.remove('value');
-      mergedElement.set('value', referencingElement.get('value'));
-    }
-
-    /**
-     * Transclude referencing element with merged referenced element.
-     */
-    path.replaceWith(mergedElement);
-    path.skip();
   }
   async JSONSchemaElement(path) {
     const referencingElement = path.node;
-
-    // skip current referencing schema as $ref keyword was not defined
-    if (!isStringElement(referencingElement.$ref)) {
+    if (this.isTranscluded(referencingElement)) {
+      path.skip();
       return;
     }
 
-    // skip current referencing element as it's already been accessed
-    if (this.indirections.includes(referencingElement)) {
-      path.skip();
+    // skip current referencing schema as $ref keyword was not defined
+    if (!isStringElement(referencingElement.$ref)) {
       return;
     }
-    const indirectionsSize = this.indirections.length;
     try {
       // compute baseURI using rules around $self, $id and $ref keywords
       let reference = await this.toReference(url.unsanitize(this.reference.uri));
@@ -346,11 +281,12 @@ class Arazzo1DereferenceVisitor {
           retrievalURI = this.toBaseURI($refBaseURI);
           const selector = $refBaseURI;
           const documentElement = reference.value.result;
-          const referenceAsSchema = maybeRefractToJSONSchemaElement(documentElement);
+          const referenceAsSchema = this.toJSONSchemaDocument(documentElement);
+          this.index$ids(referenceAsSchema);
           // a document that is itself a fragment detached from its source carries
           // the $ids enclosing it only as `ancestorSchema$ids`: its $ids are then
           // indexed against the base that chain leaves in effect, and the chain
-          // prefixes the one of the located schema. A nested visitor rooted at a
+          // prefixes the one of the located schema. A visitor rooted at a
           // fragment of a whole document indexes that document against its own base.
           const rootNode = path.getAncestorNodes().at(-1) ?? path.node;
           const isDocumentRoot = (isParseResultElement(rootNode) ? rootNode.result : rootNode) === documentElement;
@@ -364,7 +300,6 @@ class Arazzo1DereferenceVisitor {
           if (isDocumentRoot) {
             ancestorSchema$ids = [...this.ancestorSchema$ids, ...ancestorSchema$ids];
           }
-          referencedElement = maybeRefractToJSONSchemaElement(referencedElement);
 
           // ignore resolving internal Schema Objects
           if (!this.options.resolve.internal && isInternalReference) {
@@ -394,12 +329,11 @@ class Arazzo1DereferenceVisitor {
           }
           reference = await this.toReference(url.unsanitize($refBaseURI));
           const selector = URIFragmentIdentifier.fromURIReference($refBaseURI);
-          const referenceAsSchema = maybeRefractToJSONSchemaElement(reference.value.result);
+          const referenceAsSchema = this.toJSONSchemaDocument(reference.value.result);
           ({
             element: referencedElement,
             ancestorSchema$ids
           } = jsonPointerLocate(referenceAsSchema, selector));
-          referencedElement = maybeRefractToJSONSchemaElement(referencedElement);
         }
       } catch (error) {
         /**
@@ -424,12 +358,11 @@ class Arazzo1DereferenceVisitor {
             }
             reference = await this.toReference(url.unsanitize($refBaseURI));
             const selector = uriToAnchor($refBaseURI);
-            const referenceAsSchema = maybeRefractToJSONSchemaElement(reference.value.result);
+            const referenceAsSchema = this.toJSONSchemaDocument(reference.value.result);
             ({
               element: referencedElement,
               ancestorSchema$ids
             } = $anchorLocate(selector, referenceAsSchema));
-            referencedElement = maybeRefractToJSONSchemaElement(referencedElement);
           } else {
             // we're assuming here that we're dealing with JSON Pointer here
             retrievalURI = this.toBaseURI($refBaseURI);
@@ -448,140 +381,84 @@ class Arazzo1DereferenceVisitor {
             }
             reference = await this.toReference(url.unsanitize($refBaseURI));
             const selector = URIFragmentIdentifier.fromURIReference($refBaseURI);
-            const referenceAsSchema = maybeRefractToJSONSchemaElement(reference.value.result);
+            const referenceAsSchema = this.toJSONSchemaDocument(reference.value.result);
             ({
               element: referencedElement,
               ancestorSchema$ids
             } = jsonPointerLocate(referenceAsSchema, selector));
-            referencedElement = maybeRefractToJSONSchemaElement(referencedElement);
           }
         } else {
           throw error;
         }
       }
-      this.indirections.push(referencingElement);
 
-      // detect direct or indirect reference
+      // detect direct reference
       if (referencingElement === referencedElement) {
         throw new ApiDOMStructuredError('Recursive JSON Schema 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
-        });
-      }
-
-      // 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)
+      // a JSON Schema $ref reads whatever it points at as a JSON Schema
+      const $ref = toValue(referencingElement.$ref);
+      const origin = reference.uri;
+      await this.addTransclusion(path, {
+        source: referencedElement,
+        type: JSON_SCHEMA_TYPE,
+        reference,
+        context: {
+          ancestorSchema$ids
+        }
+      }, {
+        toTranscludedElement: (element, target) => {
+          // Boolean JSON Schemas
+          if (isBooleanJSONSchemaElement(target)) {
+            const booleanJsonSchemaElement = cloneDeep(target);
+            // annotate referenced element with info about original referencing element
+            booleanJsonSchemaElement.meta.set('ref-fields', {
+              $ref
+            });
+            // annotate referenced element with info about origin
+            booleanJsonSchemaElement.meta.set('ref-origin', origin);
+            booleanJsonSchemaElement.meta.set('ref-type', element.element);
+            return booleanJsonSchemaElement;
+          }
+          if (!isJSONSchemaElement(target)) return target;
+
+          /**
+           * Creating a new version of JSON Schema by merging fields from referenced Schema with referencing one.
+           */
+          const mergedElement = cloneShallow(target);
+          // existing keywords from referencing schema overrides ones from referenced schema
+          element.forEach((value, keyElement, item) => {
+            mergedElement.remove(toValue(keyElement));
+            mergedElement.content.push(item);
           });
-        } else if (this.options.dereference.circular === 'replace') {
-          const refElement = new RefElement($refBaseURI, {
-            type: referencingElement.element,
-            uri: reference.uri,
-            $ref: toValue(referencingElement.$ref)
+          mergedElement.remove('$ref');
+          // annotate referenced element with info about original referencing element
+          mergedElement.meta.set('ref-fields', {
+            $ref
           });
-          const replacer = this.options.dereference.strategyOpts['arazzo-1']?.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 JSON Schema 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);
-      // content transplanted into the referencing site is traversed under that
-      // site's $id chain; a fragment enclosed by a different chain has its own
-      // $refs resolved in place first, by a nested visitor seeded with that chain
-      const hasDifferentEnclosingBase = resolveSchema$ids(resolveArazzo$selfField(reference.uri, reference.value.result), ancestorSchema$ids) !== resolveSchema$ids(rootBaseURI, schema$idsOf(path.getAncestorNodes().reverse()));
-      if ((isExternalReference || isNonEntryDocument || hasDifferentEnclosingBase || isJSONSchemaElement(referencedElement) && isStringElement(referencedElement.$ref) || shouldDetectCircular && !this.visited.has(referencedElement)) && !ancestorsLineage.includesCycle(referencedElement)) {
-        if (shouldDetectCircular) {
-          this.visited.add(referencedElement);
+          // annotate fragment with info about origin
+          mergedElement.meta.set('ref-origin', origin);
+          mergedElement.meta.set('ref-type', element.element);
+          return mergedElement;
+        },
+        aliasField: '$ref',
+        circular: {
+          uri: $refBaseURI,
+          meta: {
+            uri: origin,
+            $ref
+          },
+          details: {
+            $ref
+          }
         }
-
-        // append referencing reference to ancestors lineage
-        directAncestors.add(referencingElement);
-        const visitor = new Arazzo1DereferenceVisitor({
-          reference,
-          indirections: [...this.indirections],
-          options: this.options,
-          schema$idIndex: this.schema$idIndex,
-          visited: this.visited,
-          ancestors: ancestorsLineage,
-          ancestorSchema$ids
-        });
-        referencedElement = await traverseAsync(referencedElement, visitor, {
-          mutable: true,
-          skipVisited: 'skip'
-        });
-
-        // remove referencing reference from ancestors lineage
-        directAncestors.delete(referencingElement);
-      }
-
-      // Boolean JSON Schemas
-      if (isBooleanJSONSchemaElement(referencedElement)) {
-        const booleanJsonSchemaElement = cloneDeep(referencedElement);
-        // annotate referenced element with info about original referencing element
-        booleanJsonSchemaElement.meta.set('ref-fields', {
-          $ref: toValue(referencingElement.$ref)
-        });
-        // annotate referenced element with info about origin
-        booleanJsonSchemaElement.meta.set('ref-origin', reference.uri);
-        booleanJsonSchemaElement.meta.set('ref-type', referencingElement.element);
-        path.replaceWith(booleanJsonSchemaElement);
-        path.skip();
-        return;
-      }
-
-      /**
-       * Creating a new version of JSON Schema by merging fields from referenced Schema with referencing one.
-       */
-      if (isJSONSchemaElement(referencedElement)) {
-        const mergedElement = cloneShallow(referencedElement);
-        // existing keywords from referencing schema overrides ones from referenced schema
-        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 fragment with info about origin
-        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 Schema Object. Cannot resolve $ref "${$ref}": ${error.message}`, error, referencingElement, '$ref', $ref, path);
-    } finally {
-      if (this.indirections.length > indirectionsSize) this.indirections.pop();
     }
   }
 }