fumadocs-openapi 10.10.3 → 11.0.1

package/dist/utils/pages/preset-auto.d.ts

@@ -1,6 +1,5 @@
 import { OperationOutput, PageOutput, PagesBuilder, PagesBuilderConfig, WebhookOutput } from "./builder.js";
 import { DistributiveOmit } from "../../types.js";
-import { DereferencedDocument } from "../document/dereference.js";
 
 //#region src/utils/pages/preset-auto.d.ts
 interface OperationConfig extends BaseConfig {
@@ -46,7 +45,7 @@ interface SchemaConfig extends BaseConfig {
 type SchemaToPagesOptions = SchemaConfig | TagConfig | OperationConfig | ({
   per: 'custom';
 } & PagesBuilderConfig);
-type NameFn<Entry extends OperationOutput | WebhookOutput | PageOutput = OperationOutput | WebhookOutput | PageOutput> = (this: PagesBuilder, output: DistributiveOmit<Entry, 'path'>, document: DereferencedDocument['dereferenced']) => string;
+type NameFn<Entry extends OperationOutput | WebhookOutput | PageOutput = OperationOutput | WebhookOutput | PageOutput> = (this: PagesBuilder, output: DistributiveOmit<Entry, 'path'>) => string;
 interface NameFnOptions {
   /**
    * The version of algorithm used to generate file paths.

package/dist/utils/pages/preset-auto.js

@@ -1,5 +1,5 @@
-import { isUrl } from "../url.js";
 import * as path$1 from "node:path";
+import { dereferenceShallow } from "@fumadocs/api-docs/schema/dereference";
 //#region src/utils/pages/preset-auto.ts
 function createAutoPreset(options) {
 	if (options.per === "custom") return options;
@@ -10,18 +10,18 @@ function createAutoPreset(options) {
 	if (typeof options.name === "function") nameFn = options.name;
 	else {
 		const { algorithm = "v2" } = options.name ?? {};
-		nameFn = function(result, document) {
+		nameFn = function(result) {
 			if (result.type === "page") {
 				if (result.tag) return slugify(result.tag.name);
 				const schemaId = result.schemaId;
-				return isUrl(schemaId) ? "index" : path$1.basename(schemaId, path$1.extname(schemaId));
+				return schemaId.startsWith("http://") || schemaId.startsWith("https://") ? "index" : path$1.basename(schemaId, path$1.extname(schemaId));
 			}
 			if (result.type === "operation") {
-				const operation = document.paths[result.item.path][result.item.method];
+				const operation = this.document.paths[result.item.path][result.item.method];
 				if (algorithm === "v2" && operation.operationId) return operation.operationId;
 				return path$1.join(this.routePathToFilePath(result.item.path), result.item.method.toLowerCase());
 			}
-			const hook = document.webhooks[result.item.name][result.item.method];
+			const hook = dereferenceShallow(this.document.webhooks[result.item.name], this.document)[result.item.method];
 			if (algorithm === "v2" && hook.operationId) return hook.operationId;
 			return slugify(result.item.name);
 		};
@@ -29,7 +29,7 @@ function createAutoPreset(options) {
 	function group(builder, entries) {
 		const groups = /* @__PURE__ */ new Map();
 		const rest = [];
-		const { dereferenced } = builder.document;
+		const doc = builder.document;
 		const { groupBy = "none" } = options;
 		for (const entry of entries) switch (groupBy) {
 			case "route": {
@@ -52,7 +52,7 @@ function createAutoPreset(options) {
 				break;
 			}
 			case "tag": {
-				let tags = entry.type === "operation" ? dereferenced.paths[entry.item.path][entry.item.method].tags : dereferenced.webhooks[entry.item.name][entry.item.method].tags;
+				let tags = entry.type === "operation" ? dereferenceShallow(doc.paths?.[entry.item.path], doc)?.[entry.item.method]?.tags : dereferenceShallow(doc.webhooks?.[entry.item.name], doc)?.[entry.item.method]?.tags;
 				if (!tags || tags.length === 0) {
 					console.warn("When `groupBy` is set to `tag`, make sure a `tags` is defined for every operation schema.");
 					tags = ["unknown"];
@@ -78,13 +78,13 @@ function createAutoPreset(options) {
 					}
 					group.entries.push({
 						...entry,
-						path: path$1.join(groupName, `${nameFn.call(builder, entry, dereferenced)}.mdx`)
+						path: path$1.join(groupName, `${nameFn.call(builder, entry)}.mdx`)
 					});
 				}
 				break;
 			}
 			default: {
-				const fileName = `${nameFn.call(builder, entry, dereferenced)}.mdx`;
+				const fileName = `${nameFn.call(builder, entry)}.mdx`;
 				if (typeof groupBy === "function") {
 					const groupDisplayName = groupBy(entry);
 					const groupName = slugify(groupDisplayName);
@@ -115,7 +115,7 @@ function createAutoPreset(options) {
 		return rest;
 	}
 	return { toPages(builder) {
-		const { dereferenced } = builder.document;
+		const doc = builder.document;
 		const items = builder.extract();
 		if (options.per === "file") {
 			const entry = {
@@ -123,17 +123,17 @@ function createAutoPreset(options) {
 				schemaId: builder.id,
 				path: "",
 				info: {
-					title: dereferenced.info?.title ?? "Unknown",
-					description: dereferenced.info?.description
+					title: doc.info?.title ?? "Unknown",
+					description: doc.info?.description
 				},
 				...items
 			};
-			entry.path = `${nameFn.call(builder, entry, dereferenced)}.mdx`;
+			entry.path = `${nameFn.call(builder, entry)}.mdx`;
 			builder.create(entry);
 			return;
 		}
 		if (options.per === "tag") {
-			const tags = dereferenced.tags ?? [];
+			const tags = doc.tags ?? [];
 			for (const tag of tags) {
 				const { displayName } = builder.fromTag(tag);
 				const entry = {
@@ -148,7 +148,7 @@ function createAutoPreset(options) {
 					operations: items.operations.filter((op) => op.tags?.includes(tag.name)),
 					tag
 				};
-				entry.path = `${nameFn.call(builder, entry, dereferenced)}.mdx`;
+				entry.path = `${nameFn.call(builder, entry)}.mdx`;
 				builder.create(entry);
 			}
 			return;

package/dist/utils/pages/to-static-data.js

@@ -1,7 +1,8 @@
-import { idToTitle } from "../id-to-title.js";
+import { idToTitle } from "@fumadocs/api-docs/utils/id-to-title";
+import { dereferenceShallow } from "@fumadocs/api-docs/schema/dereference";
 import Slugger from "github-slugger";
 //#region src/utils/pages/to-static-data.ts
-function toStaticData(page, dereferenced) {
+function toStaticData(page, doc) {
 	const slugger = new Slugger();
 	const toc = [];
 	const structuredData = {
@@ -28,12 +29,12 @@ function toStaticData(page, dereferenced) {
 		});
 	}
 	for (const item of page.operations ?? []) {
-		const operation = dereferenced.paths?.[item.path]?.[item.method];
+		const operation = dereferenceShallow(doc.paths?.[item.path], doc)?.[item.method];
 		if (!operation) continue;
 		pathItem(operation, item.path);
 	}
 	for (const item of page.webhooks ?? []) {
-		const webhook = dereferenced.webhooks?.[item.name]?.[item.method];
+		const webhook = dereferenceShallow(doc.webhooks?.[item.name], doc)?.[item.method];
 		if (!webhook) continue;
 		pathItem(webhook, item.name);
 	}

package/dist/utils/pages/to-text.d.ts

@@ -1,4 +1,5 @@
 import { TagObject } from "../../types.js";
+
 //#region src/utils/pages/to-text.d.ts
 interface PagesToTextOptions {
   /**

package/dist/utils/pages/to-text.js

@@ -1,10 +1,10 @@
-import { removeUndefined } from "../remove-undefined.js";
 import { getPageProps } from "./builder.js";
 import { toStaticData } from "./to-static-data.js";
 import { doubleQuote } from "../../requests/string-utils.js";
+import { removeUndefined } from "../remove-undefined.js";
 import { dump } from "js-yaml";
 //#region src/utils/pages/to-text.ts
-function toText(entry, processed, options = {}) {
+function toText(entry, doc, options = {}) {
 	const { frontmatter, includeDescription = false } = options;
 	const extend = frontmatter?.(entry.info.title, entry.info.description, entry.type === "page" ? entry.tag ? {
 		type: "tag",
@@ -12,13 +12,13 @@ function toText(entry, processed, options = {}) {
 	} : { type: "file" } : { type: "operation" });
 	const pageProps = getPageProps(entry);
 	if (!includeDescription) pageProps.showDescription = false;
-	let meta;
-	if (entry.type === "operation" || entry.type === "webhook") meta = {
-		method: entry.item.method.toUpperCase(),
-		webhook: entry.type === "webhook",
-		deprecated: entry.info.deprecated
-	};
-	const data = toStaticData(pageProps, processed.dereferenced);
+	let meta = { preload: [entry.schemaId] };
+	if (entry.type === "operation" || entry.type === "webhook") {
+		meta.method = entry.item.method.toUpperCase();
+		meta.webhook = entry.type === "webhook";
+		meta.deprecated = entry.info.deprecated;
+	}
+	const data = toStaticData(pageProps, doc);
 	return generateDocument({
 		title: entry.info.title,
 		description: !includeDescription ? entry.info.description : void 0,
@@ -47,7 +47,7 @@ function generateDocument(frontmatter, content, options) {
 	return out.join("\n\n");
 }
 function pageContent({ showTitle, showDescription, document, webhooks, operations }) {
-	const propStrs = [`document={${doubleQuote(document)}}`];
+	const propStrs = [`document=${doubleQuote(document)}`];
 	if (webhooks) propStrs.push(`webhooks={${JSON.stringify(webhooks.map((item) => ({
 		name: item.name,
 		method: item.method
@@ -58,7 +58,17 @@ function pageContent({ showTitle, showDescription, document, webhooks, operation
 	})))}}`);
 	if (showTitle) propStrs.push(`showTitle`);
 	if (showDescription) propStrs.push(`showDescription`);
-	return `<APIPage ${propStrs.join(" ")} />`;
+	return `export default function Layout(props) {
+  const { APIPage, OpenAPIPage } = props.components ?? {};
+  // "APIPage" is the old name from v10, this allows both for backward compatibility
+  const Comp = OpenAPIPage ?? APIPage;
+  return (
+    <>
+      {props.children}
+      <Comp ${propStrs.join(" ")} />
+    </>
+  );
+}`;
 }
 //#endregion
 export { generateDocument, toText };

package/dist/utils/remove-undefined.js

@@ -1,19 +1,24 @@
-import { isPlainObject } from "./is-plain-object.js";
 //#region src/utils/remove-undefined.ts
 function removeUndefined(value, deep = false) {
-	if (!isPlainObject(value)) return value;
-	for (const key in value) {
-		const prop = value[key];
-		if (prop === void 0) {
-			delete value[key];
+	const obj = value;
+	for (const key in obj) {
+		if (obj[key] === void 0) delete obj[key];
+		if (!deep) continue;
+		const entry = obj[key];
+		if (isPlainObject(entry)) {
+			removeUndefined(entry, deep);
 			continue;
 		}
-		if (deep) {
-			if (Array.isArray(prop)) for (const item of prop) removeUndefined(item, deep);
-			if (isPlainObject(prop)) removeUndefined(prop, deep);
+		if (Array.isArray(entry)) {
+			for (const item of entry) if (isPlainObject(item)) removeUndefined(item, deep);
 		}
 	}
 	return value;
 }
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
 //#endregion
 export { removeUndefined };

package/dist/utils/schema.d.ts

@@ -0,0 +1,2 @@
+import { ParsedSchema } from "@fumadocs/api-docs/schema";
+export type { ParsedSchema };

package/dist/utils/{schema/index.js → schema.js}

@@ -1,5 +1,5 @@
-import { idToTitle } from "../id-to-title.js";
-//#region src/utils/schema/index.ts
+import { idToTitle } from "@fumadocs/api-docs/utils/id-to-title";
+//#region src/utils/schema.ts
 const methodKeys = [
 	"get",
 	"post",
@@ -17,19 +17,6 @@ function getTagDisplayName(tag) {
 	if (tag.summary) return tag.summary;
 	return idToTitle(tag.name);
 }
-/**
-* Summarize method endpoint information
-*/
-function createMethod(method, path, operation) {
-	return {
-		description: path.description,
-		summary: path.summary,
-		...operation,
-		servers: operation.servers ?? path.servers,
-		parameters: [...operation.parameters ?? [], ...path.parameters ?? []],
-		method
-	};
-}
 function pickExample(value) {
 	if (value.example !== void 0) return value.example;
 	if (value.content) {
@@ -45,19 +32,5 @@ function pickExample(value) {
 		if (examples.length > 0) return examples[0].value;
 	}
 }
-function parseSecurities(method, dereferenced) {
-	const result = [];
-	const security = method.security ?? dereferenced.security ?? [];
-	if (security.length === 0) return result;
-	for (const map of security) {
-		const list = [];
-		for (const [key, scopes] of Object.entries(map)) list.push({
-			id: key,
-			scopes
-		});
-		if (list.length > 0) result.push(list);
-	}
-	return result;
-}
 //#endregion
-export { createMethod, getPreferredType, getTagDisplayName, methodKeys, parseSecurities, pickExample };
+export { getPreferredType, getTagDisplayName, methodKeys, pickExample };

package/dist/{ui/client → utils}/storage-key.js

@@ -1,8 +1,8 @@
-import { useApiContext } from "../contexts/api.js";
+import { useRenderContext } from "../ui/contexts/api.js";
 import { useMemo } from "react";
-//#region src/ui/client/storage-key.ts
+//#region src/utils/storage-key.ts
 function useStorageKey() {
-	const { storageKeyPrefix } = useApiContext().client;
+	const { storageKeyPrefix } = useRenderContext();
 	return useMemo(() => ({
 		of: (name) => getStorageKey(storageKeyPrefix, name),
 		AuthField: (schemeId) => getStorageKey(storageKeyPrefix, `auth-${schemeId}`)

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "fumadocs-openapi",
-  "version": "10.10.3",
+  "version": "11.0.1",
   "description": "Generate MDX docs for your OpenAPI spec",
   "keywords": [
     "Docs",
-    "NextJs"
+    "fumadocs"
   ],
   "homepage": "https://fumadocs.dev",
   "license": "MIT",
@@ -31,8 +31,6 @@
     "./server": "./dist/server/index.js",
     "./ui": "./dist/ui/index.js",
     "./ui/base": "./dist/ui/base.js",
-    "./ui/client": "./dist/ui/client/index.js",
-    "./ui/create-client": "./dist/ui/create-client.js",
     "./package.json": "./package.json",
     "./css/*": "./css/*"
   },
@@ -40,46 +38,41 @@
     "access": "public"
   },
   "dependencies": {
+    "@fuma-translate/react": "^1.0.1",
     "@fumari/json-schema-ts": "^0.0.2",
-    "@radix-ui/react-accordion": "^1.2.12",
-    "@radix-ui/react-dialog": "^1.1.15",
-    "@radix-ui/react-select": "^2.2.6",
     "chokidar": "^5.0.0",
     "class-variance-authority": "^0.7.1",
     "github-slugger": "^2.0.0",
     "hast-util-to-jsx-runtime": "^2.3.6",
-    "js-yaml": "^4.1.1",
+    "js-yaml": "^4.2.0",
     "lucide-react": "^1.17.0",
     "remark": "^15.0.1",
     "remark-rehype": "^11.1.2",
-    "shiki": "^4.1.0",
+    "shiki": "^4.2.0",
     "tailwind-merge": "^3.6.0",
+    "@fumadocs/api-docs": "0.0.2",
     "@fumari/stf": "1.0.5"
   },
   "devDependencies": {
-    "@apidevtools/json-schema-ref-parser": "^15.3.5",
-    "@fastify/deepmerge": "^3.2.1",
-    "@scalar/api-client-react": "2.0.20",
-    "@scalar/openapi-upgrader": "^0.2.8",
+    "@scalar/api-client-react": "^2.0.24",
+    "@scalar/openapi-upgrader": "^0.2.9",
     "@tailwindcss/oxide": "^4.3.0",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "25.9.1",
-    "@types/react": "^19.2.15",
-    "ajv": "^8.20.0",
+    "@types/node": "25.9.2",
+    "@types/react": "^19.2.17",
     "fast-content-type-parse": "^3.0.0",
     "json-schema-typed": "^8.0.2",
-    "tailwindcss": "^4.3.0",
-    "tsdown": "0.22.0",
+    "tsdown": "0.22.2",
     "xml-js": "^1.6.11",
-    "fumadocs-core": "16.9.3",
-    "fumadocs-ui": "16.9.3",
+    "fumadocs-core": "16.10.1",
+    "fumadocs-ui": "16.10.1",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "@scalar/api-client-react": "^2.0.20",
     "@types/react": "*",
-    "fumadocs-core": "^16.9.0",
-    "fumadocs-ui": "^16.9.0",
+    "fumadocs-core": "^16.10.0",
+    "fumadocs-ui": "^16.10.0",
     "json-schema-typed": "*",
     "react": "^19.2.0",
     "react-dom": "^19.2.0"
@@ -96,14 +89,8 @@
     }
   },
   "inlinedDependencies": {
-    "@apidevtools/json-schema-ref-parser": "15.3.5",
-    "@fastify/deepmerge": "3.2.1",
-    "@scalar/openapi-upgrader": "0.2.8",
-    "ajv": "8.20.0",
+    "@scalar/openapi-upgrader": "0.2.9",
     "fast-content-type-parse": "3.0.0",
-    "fast-deep-equal": "3.1.3",
-    "fast-uri": "3.1.0",
-    "json-schema-traverse": "1.0.0",
     "xml-js": "1.6.11"
   },
   "scripts": {

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/bundle.js

@@ -1,239 +0,0 @@
-import { getHash, resolve, stripHash } from "./util/url.js";
-import { getSchemaBasePath } from "./util/schema-resources.js";
-import Pointer from "./pointer.js";
-import $Ref from "./ref.js";
-//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/bundle.js
-/**
-* Bundles all external JSON references into the main JSON schema, thus resulting in a schema that
-* only has *internal* references, not any *external* references.
-* This method mutates the JSON schema object, adding new references and re-mapping existing ones.
-*
-* @param parser
-* @param options
-*/
-function bundle(parser, options) {
-	const rootScopeBase = parser.$refs._root$Ref.dynamicIdScope ? getSchemaBasePath(parser.$refs._root$Ref.path, parser.schema) : parser.$refs._root$Ref.path;
-	const inventory = [];
-	crawl(parser, "schema", parser.$refs._root$Ref.path + "#", rootScopeBase, parser.$refs._root$Ref.dynamicIdScope, "#", 0, inventory, parser.$refs, options);
-	remap(inventory, options, parser.schema && typeof parser.schema === "object" && "$id" in parser.schema ? parser.schema.$id : void 0);
-	if ((options.bundle || {}).optimizeInternalRefs !== false) fixRefsThroughRefs(inventory, parser.schema);
-}
-/**
-* Recursively crawls the given value, and inventories all JSON references.
-*
-* @param parent - The object containing the value to crawl. If the value is not an object or array, it will be ignored.
-* @param key - The property key of `parent` to be crawled
-* @param path - The full path of the property being crawled, possibly with a JSON Pointer in the hash
-* @param pathFromRoot - The path of the property being crawled, from the schema root
-* @param indirections
-* @param inventory - An array of already-inventoried $ref pointers
-* @param $refs
-* @param options
-*/
-function crawl(parent, key, path, scopeBase, dynamicIdScope, pathFromRoot, indirections, inventory, $refs, options) {
-	const obj = key === null ? parent : parent[key];
-	const bundleOptions = options.bundle || {};
-	const isExcludedPath = bundleOptions.excludedPathMatcher || (() => false);
-	if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !isExcludedPath(pathFromRoot)) {
-		const currentScopeBase = scopeBase;
-		if ($Ref.isAllowed$Ref(obj)) inventory$Ref(parent, key, path, currentScopeBase, dynamicIdScope, pathFromRoot, indirections, inventory, $refs, options);
-		else {
-			const keys = Object.keys(obj).sort((a, b) => {
-				if (a === "definitions" || a === "$defs") return -1;
-				else if (b === "definitions" || b === "$defs") return 1;
-				else return a.length - b.length;
-			});
-			for (const key of keys) {
-				const keyPath = Pointer.join(path, key);
-				const keyPathFromRoot = Pointer.join(pathFromRoot, key);
-				const value = obj[key];
-				const childScopeBase = dynamicIdScope && value && typeof value === "object" && !ArrayBuffer.isView(value) ? getSchemaBasePath(currentScopeBase, value) : currentScopeBase;
-				if ($Ref.isAllowed$Ref(value)) inventory$Ref(obj, key, keyPath, childScopeBase, dynamicIdScope, keyPathFromRoot, indirections, inventory, $refs, options);
-				else crawl(obj, key, keyPath, childScopeBase, dynamicIdScope, keyPathFromRoot, indirections, inventory, $refs, options);
-				if (value && typeof value === "object" && !Array.isArray(value)) {
-					if ("$ref" in value) bundleOptions?.onBundle?.(value["$ref"], obj[key], obj, key);
-				}
-			}
-		}
-	}
-}
-/**
-* Inventories the given JSON Reference (i.e. records detailed information about it so we can
-* optimize all $refs in the schema), and then crawls the resolved value.
-*
-* @param $refParent - The object that contains a JSON Reference as one of its keys
-* @param $refKey - The key in `$refParent` that is a JSON Reference
-* @param path - The full path of the JSON Reference at `$refKey`, possibly with a JSON Pointer in the hash
-* @param indirections - unknown
-* @param pathFromRoot - The path of the JSON Reference at `$refKey`, from the schema root
-* @param inventory - An array of already-inventoried $ref pointers
-* @param $refs
-* @param options
-*/
-function inventory$Ref($refParent, $refKey, path, scopeBase, dynamicIdScope, pathFromRoot, indirections, inventory, $refs, options) {
-	const $ref = $refKey === null ? $refParent : $refParent[$refKey];
-	const $refPath = resolve(dynamicIdScope ? scopeBase : path, $ref.$ref);
-	const pointer = $refs._resolve($refPath, pathFromRoot, options);
-	if (pointer === null) return;
-	const depth = Pointer.parse(pathFromRoot).length;
-	const file = stripHash(pointer.path);
-	const hash = getHash(pointer.path);
-	const external = file !== $refs._root$Ref.path && !$refs._aliases[file];
-	const extended = $Ref.isExtended$Ref($ref);
-	indirections += pointer.indirections;
-	const existingEntry = findInInventory(inventory, $refParent, $refKey);
-	if (existingEntry) if (depth < existingEntry.depth || indirections < existingEntry.indirections) removeFromInventory(inventory, existingEntry);
-	else return;
-	inventory.push({
-		$ref,
-		parent: $refParent,
-		key: $refKey,
-		pathFromRoot,
-		depth,
-		file,
-		hash,
-		value: pointer.value,
-		circular: pointer.circular,
-		extended,
-		external,
-		indirections
-	});
-	if (!existingEntry || external) crawl(pointer.value, null, pointer.path, pointer.$ref.path, pointer.$ref.dynamicIdScope, pathFromRoot, indirections + 1, inventory, $refs, options);
-}
-/**
-* Re-maps every $ref pointer, so that they're all relative to the root of the JSON Schema.
-* Each referenced value is dereferenced EXACTLY ONCE.  All subsequent references to the same
-* value are re-mapped to point to the first reference.
-*
-* @example: {
-*    first: { $ref: somefile.json#/some/part },
-*    second: { $ref: somefile.json#/another/part },
-*    third: { $ref: somefile.json },
-*    fourth: { $ref: somefile.json#/some/part/sub/part }
-*  }
-*
-* In this example, there are four references to the same file, but since the third reference points
-* to the ENTIRE file, that's the only one we need to dereference.  The other three can just be
-* remapped to point inside the third one.
-*
-* On the other hand, if the third reference DIDN'T exist, then the first and second would both need
-* to be dereferenced, since they point to different parts of the file. The fourth reference does NOT
-* need to be dereferenced, because it can be remapped to point inside the first one.
-*
-* @param inventory
-*/
-function remap(inventory, options, rootId) {
-	inventory.sort((a, b) => {
-		if (a.file !== b.file) return a.file < b.file ? -1 : 1;
-		else if (a.hash !== b.hash) return a.hash < b.hash ? -1 : 1;
-		else if (a.circular !== b.circular) return a.circular ? -1 : 1;
-		else if (a.extended !== b.extended) return a.extended ? 1 : -1;
-		else if (a.indirections !== b.indirections) return a.indirections - b.indirections;
-		else if (a.depth !== b.depth) return a.depth - b.depth;
-		else {
-			const aDefinitionsIndex = Math.max(a.pathFromRoot.lastIndexOf("/definitions"), a.pathFromRoot.lastIndexOf("/$defs"));
-			const bDefinitionsIndex = Math.max(b.pathFromRoot.lastIndexOf("/definitions"), b.pathFromRoot.lastIndexOf("/$defs"));
-			if (aDefinitionsIndex !== bDefinitionsIndex) return bDefinitionsIndex - aDefinitionsIndex;
-			else return a.pathFromRoot.length - b.pathFromRoot.length;
-		}
-	});
-	let file, hash, pathFromRoot;
-	for (const entry of inventory) {
-		const bundleOpts = options.bundle || {};
-		if (!entry.external) {
-			if (bundleOpts.optimizeInternalRefs !== false) entry.$ref.$ref = entry.hash;
-		} else if (entry.file === file && entry.hash === hash) if (rootId && isInsideIdScope(inventory, entry)) entry.$ref.$ref = rootId + pathFromRoot;
-		else entry.$ref.$ref = pathFromRoot;
-		else if (entry.file === file && entry.hash.indexOf(hash + "/") === 0) {
-			const subPath = Pointer.join(pathFromRoot, Pointer.parse(entry.hash.replace(hash, "#")));
-			if (rootId && isInsideIdScope(inventory, entry)) entry.$ref.$ref = rootId + subPath;
-			else entry.$ref.$ref = subPath;
-		} else {
-			file = entry.file;
-			hash = entry.hash;
-			pathFromRoot = entry.pathFromRoot;
-			entry.$ref = entry.parent[entry.key] = $Ref.dereference(entry.$ref, entry.value, options);
-			if (entry.circular) entry.$ref.$ref = entry.pathFromRoot;
-		}
-	}
-}
-/**
-* TODO
-*/
-function findInInventory(inventory, $refParent, $refKey) {
-	for (const existingEntry of inventory) if (existingEntry && existingEntry.parent === $refParent && existingEntry.key === $refKey) return existingEntry;
-}
-function removeFromInventory(inventory, entry) {
-	const index = inventory.indexOf(entry);
-	inventory.splice(index, 1);
-}
-/**
-* After remapping, some $ref paths may traverse through other $ref nodes.
-* JSON pointer resolution does not follow $ref indirection, so these paths are invalid.
-* This function detects and fixes such paths by following any intermediate $refs
-* to compute a valid direct path.
-*/
-function fixRefsThroughRefs(inventory, schema) {
-	for (const entry of inventory) {
-		if (!entry.$ref || typeof entry.$ref !== "object" || !("$ref" in entry.$ref)) continue;
-		const refValue = entry.$ref.$ref;
-		if (typeof refValue !== "string" || !refValue.startsWith("#/")) continue;
-		const fixedPath = resolvePathThroughRefs(schema, refValue);
-		if (fixedPath !== refValue) entry.$ref.$ref = fixedPath;
-	}
-}
-/**
-* Walks a JSON pointer path through the schema. If any intermediate value
-* is a $ref, follows it and adjusts the path accordingly.
-* Returns the corrected path that doesn't traverse through any $ref.
-*/
-function resolvePathThroughRefs(schema, refPath) {
-	if (!refPath.startsWith("#/")) return refPath;
-	const segments = refPath.slice(2).split("/");
-	let current = schema;
-	const resolvedSegments = [];
-	for (const seg of segments) {
-		if (current === null || current === void 0 || typeof current !== "object") return refPath;
-		if ("$ref" in current && typeof current.$ref === "string" && current.$ref.startsWith("#/")) {
-			const targetSegments = current.$ref.slice(2).split("/");
-			resolvedSegments.length = 0;
-			resolvedSegments.push(...targetSegments);
-			current = walkPath(schema, current.$ref);
-			if (current === null || current === void 0 || typeof current !== "object") return refPath;
-		}
-		const decoded = seg.replace(/~1/g, "/").replace(/~0/g, "~");
-		current = current[Array.isArray(current) ? parseInt(decoded) : decoded];
-		resolvedSegments.push(seg);
-	}
-	return "#/" + resolvedSegments.join("/");
-}
-/**
-* Walks a JSON pointer path through a schema object, returning the value at that path.
-*/
-function walkPath(schema, path) {
-	if (!path.startsWith("#/")) return;
-	const segments = path.slice(2).split("/");
-	let current = schema;
-	for (const seg of segments) {
-		if (current === null || current === void 0 || typeof current !== "object") return;
-		const decoded = seg.replace(/~1/g, "/").replace(/~0/g, "~");
-		current = current[Array.isArray(current) ? parseInt(decoded) : decoded];
-	}
-	return current;
-}
-/**
-* Checks whether the given inventory entry is located inside a sub-schema that has its own $id.
-* If so, root-relative JSON Pointer $refs placed at this location would be resolved against
-* the $id base URI rather than the document root, making them invalid.
-*/
-function isInsideIdScope(inventory, entry) {
-	for (const other of inventory) {
-		if (other.pathFromRoot === "#" || other.pathFromRoot === "#/") continue;
-		if (entry.pathFromRoot.startsWith(other.pathFromRoot + "/")) {
-			if (other.value && typeof other.value === "object" && "$id" in other.value) return true;
-		}
-	}
-	return false;
-}
-//#endregion
-export { bundle as default };