@hey-api/json-schema-ref-parser 1.2.4 → 1.3.1

package/{lib → src}/bundle.ts

@@ -1,21 +1,11 @@
-import $Ref from "./ref.js";
-import type { ParserOptions } from "./options.js";
-import Pointer from "./pointer.js";
-import * as url from "./util/url.js";
-import type $Refs from "./refs.js";
-import type { $RefParser } from "./index";
-import type { JSONSchema } from "./types/index.js";
-
-const DEBUG_PERFORMANCE =
-  process.env.DEBUG === "true" ||
-  (typeof globalThis !== "undefined" && (globalThis as any).DEBUG_BUNDLE_PERFORMANCE === true);
-
-const perf = {
-  mark: (name: string) => DEBUG_PERFORMANCE && performance.mark(name),
-  measure: (name: string, start: string, end: string) => DEBUG_PERFORMANCE && performance.measure(name, start, end),
-  log: (message: string, ...args: any[]) => DEBUG_PERFORMANCE && console.log("[PERF] " + message, ...args),
-  warn: (message: string, ...args: any[]) => DEBUG_PERFORMANCE && console.warn("[PERF] " + message, ...args),
-};
+import type { $RefParser } from '.';
+import type { ParserOptions } from './options';
+import Pointer from './pointer';
+import $Ref from './ref';
+import type $Refs from './refs';
+import type { JSONSchema } from './types';
+import { MissingPointerError } from './util/errors';
+import * as url from './util/url';
 
 export interface InventoryEntry {
   $ref: any;
@@ -27,10 +17,10 @@ export interface InventoryEntry {
   hash: any;
   indirections: any;
   key: any;
+  originalContainerType?: 'schemas' | 'parameters' | 'requestBodies' | 'responses' | 'headers';
   parent: any;
   pathFromRoot: any;
   value: any;
-  originalContainerType?: "schemas" | "parameters" | "requestBodies" | "responses" | "headers";
 }
 
 /**
@@ -40,8 +30,6 @@ const createInventoryLookup = () => {
   const lookup = new Map<string, InventoryEntry>();
   const objectIds = new WeakMap<object, string>(); // Use WeakMap to avoid polluting objects
   let idCounter = 0;
-  let lookupCount = 0;
-  let addCount = 0;
 
   const getObjectId = (obj: any) => {
     if (!objectIds.has(obj)) {
@@ -50,34 +38,24 @@ const createInventoryLookup = () => {
     return objectIds.get(obj)!;
   };
 
-  const createInventoryKey = ($refParent: any, $refKey: any) => {
+  const createInventoryKey = ($refParent: any, $refKey: any) =>
     // Use WeakMap-based lookup to avoid polluting the actual schema objects
-    return `${getObjectId($refParent)}_${$refKey}`;
-  };
+    `${getObjectId($refParent)}_${$refKey}`;
 
   return {
     add: (entry: InventoryEntry) => {
-      addCount++;
       const key = createInventoryKey(entry.parent, entry.key);
       lookup.set(key, entry);
-      if (addCount % 100 === 0) {
-        perf.log(`Inventory lookup: Added ${addCount} entries, map size: ${lookup.size}`);
-      }
     },
     find: ($refParent: any, $refKey: any) => {
-      lookupCount++;
       const key = createInventoryKey($refParent, $refKey);
       const result = lookup.get(key);
-      if (lookupCount % 100 === 0) {
-        perf.log(`Inventory lookup: ${lookupCount} lookups performed`);
-      }
       return result;
     },
     remove: (entry: InventoryEntry) => {
       const key = createInventoryKey(entry.parent, entry.key);
       lookup.delete(key);
     },
-    getStats: () => ({ lookupCount, addCount, mapSize: lookup.size }),
   };
 };
 
@@ -90,27 +68,27 @@ const createInventoryLookup = () => {
  */
 const getContainerTypeFromPath = (
   path: string,
-): "schemas" | "parameters" | "requestBodies" | "responses" | "headers" => {
+): 'schemas' | 'parameters' | 'requestBodies' | 'responses' | 'headers' => {
   const tokens = Pointer.parse(path);
   const has = (t: string) => tokens.includes(t);
   // Prefer more specific containers first
-  if (has("parameters")) {
-    return "parameters";
+  if (has('parameters')) {
+    return 'parameters';
   }
-  if (has("requestBody")) {
-    return "requestBodies";
+  if (has('requestBody')) {
+    return 'requestBodies';
   }
-  if (has("headers")) {
-    return "headers";
+  if (has('headers')) {
+    return 'headers';
   }
-  if (has("responses")) {
-    return "responses";
+  if (has('responses')) {
+    return 'responses';
   }
-  if (has("schema")) {
-    return "schemas";
+  if (has('schema')) {
+    return 'schemas';
   }
   // default: treat as schema-like
-  return "schemas";
+  return 'schemas';
 };
 
 /**
@@ -127,8 +105,8 @@ const inventory$Ref = <S extends object = JSONSchema>({
   options,
   path,
   pathFromRoot,
-  visitedObjects = new WeakSet(),
   resolvedRefs = new Map(),
+  visitedObjects = new WeakSet(),
 }: {
   /**
    * The key in `$refParent` that is a JSON Reference
@@ -160,38 +138,58 @@ const inventory$Ref = <S extends object = JSONSchema>({
    * The path of the JSON Reference at `$refKey`, from the schema root
    */
   pathFromRoot: string;
-  /**
-   * Set of already visited objects to avoid infinite loops and redundant processing
-   */
-  visitedObjects?: WeakSet<object>;
   /**
    * Cache for resolved $ref targets to avoid redundant resolution
    */
   resolvedRefs?: Map<string, any>;
+  /**
+   * Set of already visited objects to avoid infinite loops and redundant processing
+   */
+  visitedObjects?: WeakSet<object>;
 }) => {
-  perf.mark("inventory-ref-start");
   const $ref = $refKey === null ? $refParent : $refParent[$refKey];
   const $refPath = url.resolve(path, $ref.$ref);
 
   // Check cache first to avoid redundant resolution
   let pointer = resolvedRefs.get($refPath);
   if (!pointer) {
-    perf.mark("resolve-start");
-    pointer = $refs._resolve($refPath, pathFromRoot, options);
-    perf.mark("resolve-end");
-    perf.measure("resolve-time", "resolve-start", "resolve-end");
+    try {
+      pointer = $refs._resolve($refPath, pathFromRoot, options);
+    } catch (error) {
+      if (error instanceof MissingPointerError) {
+        // The ref couldn't be resolved in the target file. This commonly
+        // happens when a wrapper file redirects via $ref to a versioned
+        // file, and the bundler's crawl path retains the wrapper URL.
+        // Try resolving the hash fragment against other files in $refs
+        // that might contain the target schema.
+        const hash = url.getHash($refPath);
+        if (hash) {
+          const baseFile = url.stripHash($refPath);
+          for (const filePath of Object.keys($refs._$refs)) {
+            if (filePath === baseFile) continue;
+            try {
+              pointer = $refs._resolve(filePath + hash, pathFromRoot, options);
+              if (pointer) break;
+            } catch {
+              // try next file
+            }
+          }
+        }
+        if (!pointer) {
+          console.warn(`Skipping unresolvable $ref: ${$refPath}`);
+          return;
+        }
+      } else {
+        throw error;
+      }
+    }
 
     if (pointer) {
       resolvedRefs.set($refPath, pointer);
-      perf.log(`Cached resolved $ref: ${$refPath}`);
     }
   }
 
-  if (pointer === null) {
-    perf.mark("inventory-ref-end");
-    perf.measure("inventory-ref-time", "inventory-ref-start", "inventory-ref-end");
-    return;
-  }
+  if (pointer === null) return;
 
   const parsed = Pointer.parse(pathFromRoot);
   const depth = parsed.length;
@@ -202,10 +200,7 @@ const inventory$Ref = <S extends object = JSONSchema>({
   indirections += pointer.indirections;
 
   // Check if this exact location (parent + key + pathFromRoot) has already been inventoried
-  perf.mark("lookup-start");
   const existingEntry = inventoryLookup.find($refParent, $refKey);
-  perf.mark("lookup-end");
-  perf.measure("lookup-time", "lookup-start", "lookup-end");
 
   if (existingEntry && existingEntry.pathFromRoot === pathFromRoot) {
     // This exact location has already been inventoried, so we don't need to process it again
@@ -213,8 +208,6 @@ const inventory$Ref = <S extends object = JSONSchema>({
       removeFromInventory(inventory, existingEntry);
       inventoryLookup.remove(existingEntry);
     } else {
-      perf.mark("inventory-ref-end");
-      perf.measure("inventory-ref-time", "inventory-ref-start", "inventory-ref-end");
       return;
     }
   }
@@ -228,40 +221,49 @@ const inventory$Ref = <S extends object = JSONSchema>({
     file, // The file that the $ref pointer resolves to
     hash, // The hash within `file` that the $ref pointer resolves to
     indirections, // The number of indirect references that were traversed to resolve the value
-    key: $refKey, // The key in `parent` that is the $ref pointer
-    parent: $refParent, // The object that contains this $ref pointer
-    pathFromRoot, // The path to the $ref pointer, from the JSON Schema root
-    value: pointer.value, // The resolved value of the $ref pointer
-    originalContainerType: external ? getContainerTypeFromPath(pointer.path) : undefined, // The original container type in the external file
+    key: $refKey,
+    // The resolved value of the $ref pointer
+    originalContainerType: external ? getContainerTypeFromPath(pointer.path) : undefined,
+
+    // The key in `parent` that is the $ref pointer
+    parent: $refParent,
+
+    // The object that contains this $ref pointer
+    pathFromRoot,
+    // The path to the $ref pointer, from the JSON Schema root
+    value: pointer.value, // The original container type in the external file
   };
 
   inventory.push(newEntry);
   inventoryLookup.add(newEntry);
 
-  perf.log(`Inventoried $ref: ${$ref.$ref} -> ${file}${hash} (external: ${external}, depth: ${depth})`);
-
-  // Recursively crawl the resolved value
+  // Recursively crawl the resolved value.
+  // When the resolution followed a $ref chain to a different file,
+  // use the resolved file as the base path so that local $ref values
+  // (e.g. #/components/schemas/SiblingSchema) inside the resolved
+  // value resolve against the correct file.
   if (!existingEntry || external) {
-    perf.mark("crawl-recursive-start");
+    let crawlPath = pointer.path;
+
+    const originalFile = url.stripHash($refPath);
+    if (file !== originalFile) {
+      crawlPath = file + url.getHash(pointer.path);
+    }
+
     crawl({
-      parent: pointer.value,
-      key: null,
-      path: pointer.path,
-      pathFromRoot,
+      $refs,
       indirections: indirections + 1,
       inventory,
       inventoryLookup,
-      $refs,
+      key: null,
       options,
-      visitedObjects,
+      parent: pointer.value,
+      path: crawlPath,
+      pathFromRoot,
       resolvedRefs,
+      visitedObjects,
     });
-    perf.mark("crawl-recursive-end");
-    perf.measure("crawl-recursive-time", "crawl-recursive-start", "crawl-recursive-end");
   }
-
-  perf.mark("inventory-ref-end");
-  perf.measure("inventory-ref-time", "inventory-ref-start", "inventory-ref-end");
 };
 
 /**
@@ -277,8 +279,8 @@ const crawl = <S extends object = JSONSchema>({
   parent,
   path,
   pathFromRoot,
-  visitedObjects = new WeakSet(),
   resolvedRefs = new Map(),
+  visitedObjects = new WeakSet(),
 }: {
   $refs: $Refs<S>;
   indirections: number;
@@ -307,38 +309,34 @@ const crawl = <S extends object = JSONSchema>({
    * The path of the property being crawled, from the schema root
    */
   pathFromRoot: string;
-  /**
-   * Set of already visited objects to avoid infinite loops and redundant processing
-   */
-  visitedObjects?: WeakSet<object>;
   /**
    * Cache for resolved $ref targets to avoid redundant resolution
    */
   resolvedRefs?: Map<string, any>;
+  /**
+   * Set of already visited objects to avoid infinite loops and redundant processing
+   */
+  visitedObjects?: WeakSet<object>;
 }) => {
   const obj = key === null ? parent : parent[key as keyof typeof parent];
 
-  if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
+  if (obj && typeof obj === 'object' && !ArrayBuffer.isView(obj)) {
     // Early exit if we've already processed this exact object
-    if (visitedObjects.has(obj)) {
-      perf.log(`Skipping already visited object at ${pathFromRoot}`);
-      return;
-    }
+    if (visitedObjects.has(obj)) return;
 
     if ($Ref.isAllowed$Ref(obj)) {
-      perf.log(`Found $ref at ${pathFromRoot}: ${(obj as any).$ref}`);
       inventory$Ref({
-        $refParent: parent,
         $refKey: key,
-        path,
-        pathFromRoot,
+        $refParent: parent,
+        $refs,
         indirections,
         inventory,
         inventoryLookup,
-        $refs,
         options,
-        visitedObjects,
+        path,
+        pathFromRoot,
         resolvedRefs,
+        visitedObjects,
       });
     } else {
       // Mark this object as visited BEFORE processing its children
@@ -350,16 +348,16 @@ const crawl = <S extends object = JSONSchema>({
       const keys = Object.keys(obj).sort((a, b) => {
         // Most people will expect references to be bundled into the "definitions" property,
         // so we always crawl that property first, if it exists.
-        if (a === "definitions") {
+        if (a === 'definitions') {
           return -1;
-        } else if (b === "definitions") {
+        } else if (b === 'definitions') {
           return 1;
         } else {
           // Otherwise, crawl the keys based on their length.
           // This produces the shortest possible bundled references
           return a.length - b.length;
         }
-      }) as (keyof typeof obj)[];
+      }) as Array<keyof typeof obj>;
 
       for (const key of keys) {
         const keyPath = Pointer.join(path, key);
@@ -368,31 +366,31 @@ const crawl = <S extends object = JSONSchema>({
 
         if ($Ref.isAllowed$Ref(value)) {
           inventory$Ref({
-            $refParent: obj,
             $refKey: key,
-            path,
-            pathFromRoot: keyPathFromRoot,
+            $refParent: obj,
+            $refs,
             indirections,
             inventory,
             inventoryLookup,
-            $refs,
             options,
-            visitedObjects,
+            path,
+            pathFromRoot: keyPathFromRoot,
             resolvedRefs,
+            visitedObjects,
           });
         } else {
           crawl({
-            parent: obj,
-            key,
-            path: keyPath,
-            pathFromRoot: keyPathFromRoot,
+            $refs,
             indirections,
             inventory,
             inventoryLookup,
-            $refs,
+            key,
             options,
-            visitedObjects,
+            parent: obj,
+            path: keyPath,
+            pathFromRoot: keyPathFromRoot,
             resolvedRefs,
+            visitedObjects,
           });
         }
       }
@@ -404,13 +402,10 @@ const crawl = <S extends object = JSONSchema>({
  * Remap external refs by hoisting resolved values into a shared container in the root schema
  * and pointing all occurrences to those internal definitions. Internal refs remain internal.
  */
-function remap(parser: $RefParser, inventory: InventoryEntry[]) {
-  perf.log(`Starting remap with ${inventory.length} inventory entries`);
-  perf.mark("remap-start");
+function remap(parser: $RefParser, inventory: Array<InventoryEntry>) {
   const root = parser.schema as any;
 
   // Group & sort all the $ref pointers, so they're in the order that we need to dereference/remap them
-  perf.mark("sort-inventory-start");
   inventory.sort((a: InventoryEntry, b: InventoryEntry) => {
     if (a.file !== b.file) {
       // Group all the $refs that point to the same file
@@ -433,8 +428,8 @@ function remap(parser: $RefParser, inventory: InventoryEntry[]) {
     } else {
       // Determine how far each $ref is from the "definitions" property.
       // Most people will expect references to be bundled into the the "definitions" property if possible.
-      const aDefinitionsIndex = a.pathFromRoot.lastIndexOf("/definitions");
-      const bDefinitionsIndex = b.pathFromRoot.lastIndexOf("/definitions");
+      const aDefinitionsIndex = a.pathFromRoot.lastIndexOf('/definitions');
+      const bDefinitionsIndex = b.pathFromRoot.lastIndexOf('/definitions');
       if (aDefinitionsIndex !== bDefinitionsIndex) {
         // Give higher priority to the $ref that's closer to the "definitions" property
         return bDefinitionsIndex - aDefinitionsIndex;
@@ -445,69 +440,66 @@ function remap(parser: $RefParser, inventory: InventoryEntry[]) {
     }
   });
 
-  perf.mark("sort-inventory-end");
-  perf.measure("sort-inventory-time", "sort-inventory-start", "sort-inventory-end");
-
-  perf.log(`Sorted ${inventory.length} inventory entries`);
-
   // Ensure or return a container by component type. Prefer OpenAPI-aware placement;
   // otherwise use existing root containers; otherwise create components/*.
-  const ensureContainer = (type: "schemas" | "parameters" | "requestBodies" | "responses" | "headers") => {
-    const isOas3 = !!(root && typeof root === "object" && typeof root.openapi === "string");
-    const isOas2 = !!(root && typeof root === "object" && typeof root.swagger === "string");
+  const ensureContainer = (
+    type: 'schemas' | 'parameters' | 'requestBodies' | 'responses' | 'headers',
+  ) => {
+    const isOas3 = !!(root && typeof root === 'object' && typeof root.openapi === 'string');
+    const isOas2 = !!(root && typeof root === 'object' && typeof root.swagger === 'string');
 
     if (isOas3) {
-      if (!root.components || typeof root.components !== "object") {
+      if (!root.components || typeof root.components !== 'object') {
         root.components = {};
       }
-      if (!root.components[type] || typeof root.components[type] !== "object") {
+      if (!root.components[type] || typeof root.components[type] !== 'object') {
         root.components[type] = {};
       }
       return { obj: root.components[type], prefix: `#/components/${type}` } as const;
     }
 
     if (isOas2) {
-      if (type === "schemas") {
-        if (!root.definitions || typeof root.definitions !== "object") {
+      if (type === 'schemas') {
+        if (!root.definitions || typeof root.definitions !== 'object') {
           root.definitions = {};
         }
-        return { obj: root.definitions, prefix: "#/definitions" } as const;
+        return { obj: root.definitions, prefix: '#/definitions' } as const;
       }
-      if (type === "parameters") {
-        if (!root.parameters || typeof root.parameters !== "object") {
+      if (type === 'parameters') {
+        if (!root.parameters || typeof root.parameters !== 'object') {
           root.parameters = {};
         }
-        return { obj: root.parameters, prefix: "#/parameters" } as const;
+        return { obj: root.parameters, prefix: '#/parameters' } as const;
       }
-      if (type === "responses") {
-        if (!root.responses || typeof root.responses !== "object") {
+      if (type === 'responses') {
+        if (!root.responses || typeof root.responses !== 'object') {
           root.responses = {};
         }
-        return { obj: root.responses, prefix: "#/responses" } as const;
+        return { obj: root.responses, prefix: '#/responses' } as const;
       }
       // requestBodies/headers don't exist as reusable containers in OAS2; fallback to definitions
-      if (!root.definitions || typeof root.definitions !== "object") {
+      if (!root.definitions || typeof root.definitions !== 'object') {
         root.definitions = {};
       }
-      return { obj: root.definitions, prefix: "#/definitions" } as const;
+      return { obj: root.definitions, prefix: '#/definitions' } as const;
     }
 
     // No explicit version: prefer existing containers
-    if (root && typeof root === "object") {
-      if (root.components && typeof root.components === "object") {
-        if (!root.components[type] || typeof root.components[type] !== "object") {
+    if (root && typeof root === 'object') {
+      if (root.components && typeof root.components === 'object') {
+        if (!root.components[type] || typeof root.components[type] !== 'object') {
           root.components[type] = {};
         }
         return { obj: root.components[type], prefix: `#/components/${type}` } as const;
       }
-      if (root.definitions && typeof root.definitions === "object") {
-        return { obj: root.definitions, prefix: "#/definitions" } as const;
+      if (root.definitions && typeof root.definitions === 'object') {
+        return { obj: root.definitions, prefix: '#/definitions' } as const;
       }
       // Create components/* by default if nothing exists
-      if (!root.components || typeof root.components !== "object") {
+      if (!root.components || typeof root.components !== 'object') {
         root.components = {};
       }
-      if (!root.components[type] || typeof root.components[type] !== "object") {
+      if (!root.components[type] || typeof root.components[type] !== 'object') {
         root.components[type] = {};
       }
       return { obj: root.components[type], prefix: `#/components/${type}` } as const;
@@ -515,7 +507,7 @@ function remap(parser: $RefParser, inventory: InventoryEntry[]) {
 
     // Fallback
     root.definitions = root.definitions || {};
-    return { obj: root.definitions, prefix: "#/definitions" } as const;
+    return { obj: root.definitions, prefix: '#/definitions' } as const;
   };
 
   /**
@@ -539,24 +531,24 @@ function remap(parser: $RefParser, inventory: InventoryEntry[]) {
   const targetToNameByPrefix = new Map<string, Map<string, string>>();
   const usedNamesByObj = new Map<any, Set<string>>();
 
-  const sanitize = (name: string) => name.replace(/[^A-Za-z0-9_-]/g, "_");
+  const sanitize = (name: string) => name.replace(/[^A-Za-z0-9_-]/g, '_');
   const baseName = (filePath: string) => {
     try {
-      const withoutHash = filePath.split("#")[0];
-      const parts = withoutHash.split("/");
-      const filename = parts[parts.length - 1] || "schema";
-      const dot = filename.lastIndexOf(".");
+      const withoutHash = filePath.split('#')[0]!;
+      const parts = withoutHash.split('/');
+      const filename = parts[parts.length - 1] || 'schema';
+      const dot = filename.lastIndexOf('.');
       return sanitize(dot > 0 ? filename.substring(0, dot) : filename);
     } catch {
-      return "schema";
+      return 'schema';
     }
   };
   const lastToken = (hash: string) => {
-    if (!hash || hash === "#") {
-      return "root";
+    if (!hash || hash === '#') {
+      return 'root';
     }
-    const tokens = hash.replace(/^#\//, "").split("/");
-    return sanitize(tokens[tokens.length - 1] || "root");
+    const tokens = hash.replace(/^#\//, '').split('/');
+    return sanitize(tokens[tokens.length - 1] || 'root');
   };
   const uniqueName = (containerObj: any, proposed: string) => {
     if (!usedNamesByObj.has(containerObj)) {
@@ -571,11 +563,9 @@ function remap(parser: $RefParser, inventory: InventoryEntry[]) {
     used.add(name);
     return name;
   };
-  perf.mark("remap-loop-start");
   for (const entry of inventory) {
     // Safety check: ensure entry and entry.$ref are valid objects
-    if (!entry || !entry.$ref || typeof entry.$ref !== "object") {
-      perf.warn(`Skipping invalid inventory entry:`, entry);
+    if (!entry || !entry.$ref || typeof entry.$ref !== 'object') {
       continue;
     }
 
@@ -583,7 +573,7 @@ function remap(parser: $RefParser, inventory: InventoryEntry[]) {
     // (i.e. it has additional properties in addition to "$ref"), then we must
     // preserve the original $ref rather than rewriting it to the resolved hash.
     if (!entry.external) {
-      if (!entry.extended && entry.$ref && typeof entry.$ref === "object") {
+      if (!entry.extended && entry.$ref && typeof entry.$ref === 'object') {
         entry.$ref.$ref = entry.hash;
       }
       continue;
@@ -591,7 +581,7 @@ function remap(parser: $RefParser, inventory: InventoryEntry[]) {
 
     // Avoid changing direct self-references; keep them internal
     if (entry.circular) {
-      if (entry.$ref && typeof entry.$ref === "object") {
+      if (entry.$ref && typeof entry.$ref === 'object') {
         entry.$ref.$ref = entry.pathFromRoot;
       }
       continue;
@@ -613,17 +603,36 @@ function remap(parser: $RefParser, inventory: InventoryEntry[]) {
       let proposedBase = baseName(entry.file);
       try {
         const parserAny: any = parser as any;
-        if (parserAny && parserAny.sourcePathToPrefix && typeof parserAny.sourcePathToPrefix.get === "function") {
-          const withoutHash = (entry.file || "").split("#")[0];
+        if (
+          parserAny &&
+          parserAny.sourcePathToPrefix &&
+          typeof parserAny.sourcePathToPrefix.get === 'function'
+        ) {
+          const withoutHash = (entry.file || '').split('#')[0];
           const mapped = parserAny.sourcePathToPrefix.get(withoutHash);
-          if (mapped && typeof mapped === "string") {
+          if (mapped && typeof mapped === 'string') {
             proposedBase = mapped;
           }
         }
       } catch {
         // Ignore errors
       }
-      const proposed = `${proposedBase}_${lastToken(entry.hash)}`;
+
+      // Try without prefix first (cleaner names)
+      const schemaName = lastToken(entry.hash);
+      let proposed = schemaName;
+
+      // Check if this name would conflict with existing schemas from other files
+      if (!usedNamesByObj.has(container)) {
+        usedNamesByObj.set(container, new Set<string>(Object.keys(container || {})));
+      }
+      const used = usedNamesByObj.get(container)!;
+
+      // If the name is already used, add the file prefix
+      if (used.has(proposed)) {
+        proposed = `${proposedBase}_${schemaName}`;
+      }
+
       defName = uniqueName(container, proposed);
       namesForPrefix.set(targetKey, defName);
       // Store the resolved value under the container
@@ -632,22 +641,15 @@ function remap(parser: $RefParser, inventory: InventoryEntry[]) {
 
     // Point the occurrence to the internal definition, preserving extensions
     const refPath = `${prefix}/${defName}`;
-    if (entry.extended && entry.$ref && typeof entry.$ref === "object") {
+    if (entry.extended && entry.$ref && typeof entry.$ref === 'object') {
       entry.$ref.$ref = refPath;
     } else {
       entry.parent[entry.key] = { $ref: refPath };
     }
   }
-  perf.mark("remap-loop-end");
-  perf.measure("remap-loop-time", "remap-loop-start", "remap-loop-end");
-
-  perf.mark("remap-end");
-  perf.measure("remap-total-time", "remap-start", "remap-end");
-
-  perf.log(`Completed remap of ${inventory.length} entries`);
 }
 
-function removeFromInventory(inventory: InventoryEntry[], entry: any) {
+function removeFromInventory(inventory: Array<InventoryEntry>, entry: any) {
   const index = inventory.indexOf(entry);
   inventory.splice(index, 1);
 }
@@ -660,68 +662,26 @@ function removeFromInventory(inventory: InventoryEntry[], entry: any) {
  * @param parser
  * @param options
  */
-export const bundle = (parser: $RefParser, options: ParserOptions) => {
-  // console.log('Bundling $ref pointers in %s', parser.$refs._root$Ref.path);
-  perf.mark("bundle-start");
-
-  // Build an inventory of all $ref pointers in the JSON Schema
-  const inventory: InventoryEntry[] = [];
+export function bundle(parser: $RefParser, options: ParserOptions): void {
+  const inventory: Array<InventoryEntry> = [];
   const inventoryLookup = createInventoryLookup();
 
-  perf.log("Starting crawl phase");
-  perf.mark("crawl-phase-start");
-
   const visitedObjects = new WeakSet<object>();
-  const resolvedRefs = new Map<string, any>(); // Cache for resolved $ref targets
+  const resolvedRefs = new Map<string, any>();
 
   crawl<JSONSchema>({
-    parent: parser,
-    key: "schema",
-    path: parser.$refs._root$Ref.path + "#",
-    pathFromRoot: "#",
+    $refs: parser.$refs,
     indirections: 0,
     inventory,
     inventoryLookup,
-    $refs: parser.$refs,
+    key: 'schema',
     options,
-    visitedObjects,
+    parent: parser,
+    path: parser.$refs._root$Ref.path + '#',
+    pathFromRoot: '#',
     resolvedRefs,
+    visitedObjects,
   });
 
-  perf.mark("crawl-phase-end");
-  perf.measure("crawl-phase-time", "crawl-phase-start", "crawl-phase-end");
-
-  const stats = inventoryLookup.getStats();
-  perf.log(`Crawl phase complete. Found ${inventory.length} $refs. Lookup stats:`, stats);
-
-  // Remap all $ref pointers
-  perf.log("Starting remap phase");
-  perf.mark("remap-phase-start");
   remap(parser, inventory);
-  perf.mark("remap-phase-end");
-  perf.measure("remap-phase-time", "remap-phase-start", "remap-phase-end");
-
-  perf.mark("bundle-end");
-  perf.measure("bundle-total-time", "bundle-start", "bundle-end");
-
-  perf.log("Bundle complete. Performance summary:");
-
-  // Log final stats
-  const finalStats = inventoryLookup.getStats();
-  perf.log(`Final inventory stats:`, finalStats);
-  perf.log(`Resolved refs cache size: ${resolvedRefs.size}`);
-
-  if (DEBUG_PERFORMANCE) {
-    // Log all performance measures
-    const measures = performance.getEntriesByType("measure");
-    measures.forEach((measure) => {
-      if (measure.name.includes("time")) {
-        console.log(`${measure.name}: ${measure.duration.toFixed(2)}ms`);
-      }
-    });
-
-    // Clear performance marks and measures for next run
-    performance.clearMarks();
-    performance.clearMeasures();
-  }
-};
+}