@nocobase/plugin-mcp-server 2.1.0-alpha.16 → 2.1.0-alpha.17

package/dist/node_modules/@apidevtools/swagger-parser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apidevtools/swagger-parser",
-  "version": "10.1.1",
+  "version": "12.1.0",
   "description": "Swagger 2.0 and OpenAPI 3.0 parser and validator for Node and browsers",
   "keywords": [
     "swagger",
@@ -19,11 +19,16 @@
     "reference",
     "dereference"
   ],
-  "author": {
-    "name": "James Messinger",
-    "url": "https://jamesmessinger.com"
-  },
-  "homepage": "https://apitools.dev/swagger-parser/",
+  "contributors": [
+    {
+      "name": "James Messinger"
+    },
+    {
+      "name": "JonLuca DeCaro",
+      "email": "apis@jonlu.ca"
+    }
+  ],
+  "homepage": "https://apidevtools.com/swagger-parser/",
   "repository": {
     "type": "git",
     "url": "https://github.com/APIDevTools/swagger-parser.git"
@@ -35,53 +40,49 @@
     "lib"
   ],
   "scripts": {
-    "clean": "shx rm -rf .nyc_output coverage",
-    "lint": "eslint lib test online/src/js",
-    "lint:fix": "eslint --fix lib test online/src/js",
-    "build": "npm run build:website && npm run build:sass",
-    "build:website": "node build-website.mjs",
-    "build:sass": "sass online/src/scss/style.scss online/css/style.min.css",
-    "test": "npm run test:node && npm run test:typescript && npm run lint",
+    "clean": "rimraf .nyc_output coverage",
+    "lint": "eslint lib test",
+    "lint:fix": "eslint --fix lib test",
+    "test": "npm run test:node && npm run test:typescript",
     "test:node": "mocha",
-    "test:typescript": "tsc --noEmit --strict --lib esnext,dom test/specs/typescript-definition.spec.ts",
+    "test:typescript": "tsc --noEmit --strict --skipDefaultLibCheck --skipLibCheck --lib esnext,dom test/specs/typescript-definition.spec.ts",
     "coverage": "npm run coverage:node",
-    "coverage:node": "cross-env QUICK_TEST=true nyc mocha",
-    "upgrade": "npm-check -u && npm audit fix",
-    "bump": "bump --tag --push --all",
-    "--release--cannot upgrade or everything breaks": "npm run upgrade && npm run clean && npm run build && npm test && npm run bump",
-    "release": "npm run clean && npm run build && npm test && npm run bump"
+    "coverage:node": "cross-env QUICK_TEST=true nyc mocha"
   },
   "devDependencies": {
+    "@eslint/compat": "^1.3.0",
+    "@eslint/js": "^9.29.0",
     "@jsdevtools/host-environment": "^2.1.2",
-    "@jsdevtools/version-bump-prompt": "^6.1.0",
-    "@types/node": "^22.7.5",
-    "chai": "^4",
+    "@types/node": "^24.0.3",
+    "chai": "^5",
     "cross-env": "^7.0.3",
-    "esbuild": "^0.24.0",
+    "esbuild": "^0.25.5",
     "esbuild-plugin-polyfill-node": "^0.3.0",
-    "eslint": "^8",
-    "eslint-plugin-jsdoc": "^50.3.1",
+    "eslint": "^9.29.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-jsdoc": "^51.0.1",
+    "eslint-plugin-prettier": "^5.4.1",
+    "eslint-plugin-unused-imports": "^4.1.4",
+    "globals": "^16.2.0",
     "js-yaml": "^4.1.0",
-    "mocha": "^10.7.3",
-    "node-fetch": "^2",
-    "npm-check": "^6.0.1",
+    "mocha": "^11.6.0",
     "nyc": "^17.1.0",
     "openapi-types": "^12.1.3",
-    "sass": "^1.79.4",
-    "shx": "^0.3.4",
-    "sinon": "^19.0.2",
-    "typescript": "^5.6.3"
+    "prettier": "^3.5.3",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.34.1"
   },
   "dependencies": {
-    "@apidevtools/json-schema-ref-parser": "11.7.2",
+    "@apidevtools/json-schema-ref-parser": "14.0.1",
     "@apidevtools/openapi-schemas": "^2.1.0",
     "@apidevtools/swagger-methods": "^3.0.2",
-    "@jsdevtools/ono": "^7.1.3",
     "ajv": "^8.17.1",
     "ajv-draft-04": "^1.0.0",
     "call-me-maybe": "^1.0.2"
   },
   "peerDependencies": {
     "openapi-types": ">=7"
-  }
+  },
+  "packageManager": "yarn@4.9.1"
 }

package/dist/node_modules/light-my-request/package.json

@@ -1 +1 @@
-{"name":"light-my-request","version":"6.6.0","description":"Fake HTTP injection library","main":"index.js","type":"commonjs","types":"types/index.d.ts","dependencies":{"cookie":"^1.0.1","process-warning":"^4.0.0","set-cookie-parser":"^2.6.0"},"devDependencies":{"@fastify/ajv-compiler":"^4.0.0","@fastify/pre-commit":"^2.1.0","@types/node":"^22.7.7","c8":"^10.1.2","end-of-stream":"^1.4.4","eslint":"^9.17.0","express":"^4.19.2","form-auto-content":"^3.2.1","form-data":"^4.0.0","formdata-node":"^6.0.3","multer":"^1.4.5-lts.1","neostandard":"^0.12.0","tinybench":"^3.0.0","tsd":"^0.31.0","undici":"^7.0.0"},"scripts":{"benchmark":"node benchmark/benchmark.js","coverage":"npm run unit -- --cov --coverage-report=html","lint":"eslint","lint:fix":"eslint --fix","test":"npm run lint && npm run test:unit && npm run test:typescript","test:typescript":"tsd","test:unit":"c8 --100 node --test"},"repository":{"type":"git","url":"git+https://github.com/fastify/light-my-request.git"},"keywords":["http","inject","fake","request","server"],"author":"Tomas Della Vedova - @delvedor (http://delved.org)","contributors":[{"name":"Matteo Collina","email":"hello@matteocollina.com"},{"name":"Manuel Spigolon","email":"behemoth89@gmail.com"},{"name":"Aras Abbasi","email":"aras.abbasi@gmail.com"},{"name":"Frazer Smith","email":"frazer.dev@icloud.com","url":"https://github.com/fdawgs"}],"license":"BSD-3-Clause","bugs":{"url":"https://github.com/fastify/light-my-request/issues"},"homepage":"https://github.com/fastify/light-my-request#readme","funding":[{"type":"github","url":"https://github.com/sponsors/fastify"},{"type":"opencollective","url":"https://opencollective.com/fastify"}],"_lastModified":"2026-04-14T00:04:42.026Z"}
+{"name":"light-my-request","version":"6.6.0","description":"Fake HTTP injection library","main":"index.js","type":"commonjs","types":"types/index.d.ts","dependencies":{"cookie":"^1.0.1","process-warning":"^4.0.0","set-cookie-parser":"^2.6.0"},"devDependencies":{"@fastify/ajv-compiler":"^4.0.0","@fastify/pre-commit":"^2.1.0","@types/node":"^22.7.7","c8":"^10.1.2","end-of-stream":"^1.4.4","eslint":"^9.17.0","express":"^4.19.2","form-auto-content":"^3.2.1","form-data":"^4.0.0","formdata-node":"^6.0.3","multer":"^1.4.5-lts.1","neostandard":"^0.12.0","tinybench":"^3.0.0","tsd":"^0.31.0","undici":"^7.0.0"},"scripts":{"benchmark":"node benchmark/benchmark.js","coverage":"npm run unit -- --cov --coverage-report=html","lint":"eslint","lint:fix":"eslint --fix","test":"npm run lint && npm run test:unit && npm run test:typescript","test:typescript":"tsd","test:unit":"c8 --100 node --test"},"repository":{"type":"git","url":"git+https://github.com/fastify/light-my-request.git"},"keywords":["http","inject","fake","request","server"],"author":"Tomas Della Vedova - @delvedor (http://delved.org)","contributors":[{"name":"Matteo Collina","email":"hello@matteocollina.com"},{"name":"Manuel Spigolon","email":"behemoth89@gmail.com"},{"name":"Aras Abbasi","email":"aras.abbasi@gmail.com"},{"name":"Frazer Smith","email":"frazer.dev@icloud.com","url":"https://github.com/fdawgs"}],"license":"BSD-3-Clause","bugs":{"url":"https://github.com/fastify/light-my-request/issues"},"homepage":"https://github.com/fastify/light-my-request#readme","funding":[{"type":"github","url":"https://github.com/sponsors/fastify"},{"type":"opencollective","url":"https://opencollective.com/fastify"}],"_lastModified":"2026-04-17T02:45:44.693Z"}

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 James Messinger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/README.md

@@ -0,0 +1,168 @@
+# JSON Schema $Ref Parser
+
+#### Parse, Resolve, and Dereference JSON Schema $ref pointers
+
+[![Build Status](https://github.com/APIDevTools/json-schema-ref-parser/workflows/CI-CD/badge.svg?branch=master)](https://github.com/APIDevTools/json-schema-ref-parser/actions)
+[![Coverage Status](https://coveralls.io/repos/github/APIDevTools/json-schema-ref-parser/badge.svg?branch=master)](https://coveralls.io/github/APIDevTools/json-schema-ref-parser)
+
+[![npm](https://img.shields.io/npm/v/@apidevtools/json-schema-ref-parser.svg)](https://www.npmjs.com/package/@apidevtools/json-schema-ref-parser)
+[![License](https://img.shields.io/npm/l/@apidevtools/json-schema-ref-parser.svg)](LICENSE)
+[![Buy us a tree](https://img.shields.io/badge/Treeware-%F0%9F%8C%B3-lightgreen)](https://plant.treeware.earth/APIDevTools/json-schema-ref-parser)
+
+## Installation
+
+Install using [npm](https://docs.npmjs.com/about-npm/):
+
+```bash
+npm install @apidevtools/json-schema-ref-parser
+yarn add @apidevtools/json-schema-ref-parser
+bun add @apidevtools/json-schema-ref-parser
+```
+
+## The Problem:
+
+You've got a JSON Schema with `$ref` pointers to other files and/or URLs. Maybe you know all the referenced files ahead
+of time. Maybe you don't. Maybe some are local files, and others are remote URLs. Maybe they are a mix of JSON and YAML
+format. Maybe some of the files contain cross-references to each other.
+
+```json
+{
+  "definitions": {
+    "person": {
+      // references an external file
+      "$ref": "schemas/people/Bruce-Wayne.json"
+    },
+    "place": {
+      // references a sub-schema in an external file
+      "$ref": "schemas/places.yaml#/definitions/Gotham-City"
+    },
+    "thing": {
+      // references a URL
+      "$ref": "http://wayne-enterprises.com/things/batmobile"
+    },
+    "color": {
+      // references a value in an external file via an internal reference
+      "$ref": "#/definitions/thing/properties/colors/black-as-the-night"
+    }
+  }
+}
+```
+
+## The Solution:
+
+JSON Schema $Ref Parser is a full [JSON Reference](https://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03)
+and [JSON Pointer](https://tools.ietf.org/html/rfc6901) implementation that crawls even the most
+complex [JSON Schemas](http://json-schema.org/latest/json-schema-core.html) and gives you simple, straightforward
+JavaScript objects.
+
+- Use **JSON** or **YAML** schemas — or even a mix of both!
+- Supports `$ref` pointers to external files and URLs, as well
+  as [custom sources](https://apitools.dev/json-schema-ref-parser/docs/plugins/resolvers.html) such as databases
+- Can [bundle](https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#bundlepath-options-callback) multiple
+  files into a single schema that only has _internal_ `$ref` pointers
+- Can [dereference](https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#dereferencepath-options-callback)
+  your schema, producing a plain-old JavaScript object that's easy to work with
+- Supports [circular references](https://apitools.dev/json-schema-ref-parser/docs/#circular-refs), nested references,
+  back-references, and cross-references between files
+- Maintains object reference equality — `$ref` pointers to the same value always resolve to the same object
+  instance
+- Compatible with Node LTS and beyond, and all major web browsers on Windows, Mac, and Linux
+
+## Example
+
+```javascript
+import $RefParser from "@apidevtools/json-schema-ref-parser";
+
+try {
+  await $RefParser.dereference(mySchema);
+  // note - by default, mySchema is modified in place, and the returned value is a reference to the same object
+  console.log(mySchema.definitions.person.properties.firstName);
+
+  // if you want to avoid modifying the original schema, you can disable the `mutateInputSchema` option
+  let clonedSchema = await $RefParser.dereference(mySchema, { mutateInputSchema: false });
+  console.log(clonedSchema.definitions.person.properties.firstName);
+} catch (err) {
+  console.error(err);
+}
+```
+
+For more detailed examples, please see the [API Documentation](https://apitools.dev/json-schema-ref-parser/docs/)
+
+## Polyfills
+
+If you are using Node.js < 18, you'll need a polyfill for `fetch`,
+like [node-fetch](https://github.com/node-fetch/node-fetch):
+
+```javascript
+import fetch from "node-fetch";
+
+globalThis.fetch = fetch;
+```
+
+## Browser support
+
+JSON Schema $Ref Parser supports recent versions of every major web browser. Older browsers may
+require [Babel](https://babeljs.io/) and/or [polyfills](https://babeljs.io/docs/en/next/babel-polyfill).
+
+To use JSON Schema $Ref Parser in a browser, you'll need to use a bundling tool such
+as [Webpack](https://webpack.js.org/), [Rollup](https://rollupjs.org/), [Parcel](https://parceljs.org/),
+or [Browserify](http://browserify.org/). Some bundlers may require a bit of configuration, such as
+setting `browser: true` in [rollup-plugin-resolve](https://github.com/rollup/rollup-plugin-node-resolve).
+
+#### Webpack 5
+
+Webpack 5 has dropped the default export of node core modules in favour of polyfills, you'll need to set them up
+yourself ( after npm-installing them )
+Edit your `webpack.config.js` :
+
+```js
+config.resolve.fallback = {
+  path: require.resolve("path-browserify"),
+  fs: require.resolve("browserify-fs"),
+};
+
+config.plugins.push(
+  new webpack.ProvidePlugin({
+    Buffer: ["buffer", "Buffer"],
+  }),
+);
+```
+
+## API Documentation
+
+Full API documentation is available [right here](https://apitools.dev/json-schema-ref-parser/docs/)
+
+## Contributing
+
+I welcome any contributions, enhancements, and
+bug-fixes. [Open an issue](https://github.com/APIDevTools/json-schema-ref-parser/issues) on GitHub
+and [submit a pull request](https://github.com/APIDevTools/json-schema-ref-parser/pulls).
+
+#### Building/Testing
+
+To build/test the project locally on your computer:
+
+1. **Clone this repo**<br>
+   `git clone https://github.com/APIDevTools/json-schema-ref-parser.git`
+
+2. **Install dependencies**<br>
+   `yarn install`
+
+3. **Run the tests**<br>
+   `yarn test`
+
+## License
+
+JSON Schema $Ref Parser is 100% free and open-source, under the [MIT license](LICENSE). Use it however you want.
+
+This package is [Treeware](http://treeware.earth). If you use it in production, then we ask that you [**buy the world a
+tree**](https://plant.treeware.earth/APIDevTools/json-schema-ref-parser) to thank us for our work. By contributing to
+the Treeware forest you’ll be creating employment for local families and restoring wildlife habitats.
+
+## Big Thanks To
+
+Thanks to these awesome companies for their support of Open Source developers ❤
+
+[![Stoplight](https://svgshare.com/i/TK5.svg)](https://stoplight.io/?utm_source=github&utm_medium=readme&utm_campaign=json_schema_ref_parser)
+[![SauceLabs](https://jstools.dev/img/badges/sauce-labs.svg)](https://saucelabs.com)
+[![Coveralls](https://jstools.dev/img/badges/coveralls.svg)](https://coveralls.io)

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/bundle.d.ts

@@ -0,0 +1,27 @@
+import type $RefParser from "./index";
+import type { ParserOptions } from "./index";
+import type { JSONSchema } from "./index";
+export interface InventoryEntry {
+    $ref: any;
+    parent: any;
+    key: any;
+    pathFromRoot: any;
+    depth: any;
+    file: any;
+    hash: any;
+    value: any;
+    circular: any;
+    extended: any;
+    external: any;
+    indirections: any;
+}
+/**
+ * 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
+ */
+declare function bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(parser: $RefParser<S, O>, options: O): void;
+export default bundle;

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/bundle.js

@@ -0,0 +1,283 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ref_js_1 = __importDefault(require("./ref.js"));
+const pointer_js_1 = __importDefault(require("./pointer.js"));
+const url = __importStar(require("./util/url.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) {
+    // console.log('Bundling $ref pointers in %s', parser.$refs._root$Ref.path);
+    // Build an inventory of all $ref pointers in the JSON Schema
+    const inventory = [];
+    crawl(parser, "schema", parser.$refs._root$Ref.path + "#", "#", 0, inventory, parser.$refs, options);
+    // Remap all $ref pointers
+    remap(inventory);
+}
+/**
+ * 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, pathFromRoot, indirections, inventory, $refs, options) {
+    const obj = key === null ? parent : parent[key];
+    if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
+        if (ref_js_1.default.isAllowed$Ref(obj)) {
+            inventory$Ref(parent, key, path, pathFromRoot, indirections, inventory, $refs, options);
+        }
+        else {
+            // Crawl the object in a specific order that's optimized for bundling.
+            // This is important because it determines how `pathFromRoot` gets built,
+            // which later determines which keys get dereferenced and which ones get remapped
+            const keys = Object.keys(obj).sort((a, b) => {
+                // Most people will expect references to be bundled into the the "definitions" property,
+                // so we always crawl that property first, if it exists.
+                if (a === "definitions") {
+                    return -1;
+                }
+                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;
+                }
+            });
+            for (const key of keys) {
+                const keyPath = pointer_js_1.default.join(path, key);
+                const keyPathFromRoot = pointer_js_1.default.join(pathFromRoot, key);
+                const value = obj[key];
+                if (ref_js_1.default.isAllowed$Ref(value)) {
+                    inventory$Ref(obj, key, path, keyPathFromRoot, indirections, inventory, $refs, options);
+                }
+                else {
+                    crawl(obj, key, keyPath, keyPathFromRoot, indirections, inventory, $refs, options);
+                }
+            }
+        }
+    }
+}
+/**
+ * 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, pathFromRoot, indirections, inventory, $refs, options) {
+    const $ref = $refKey === null ? $refParent : $refParent[$refKey];
+    const $refPath = url.resolve(path, $ref.$ref);
+    const pointer = $refs._resolve($refPath, pathFromRoot, options);
+    if (pointer === null) {
+        return;
+    }
+    const parsed = pointer_js_1.default.parse(pathFromRoot);
+    const depth = parsed.length;
+    const file = url.stripHash(pointer.path);
+    const hash = url.getHash(pointer.path);
+    const external = file !== $refs._root$Ref.path;
+    const extended = ref_js_1.default.isExtended$Ref($ref);
+    indirections += pointer.indirections;
+    const existingEntry = findInInventory(inventory, $refParent, $refKey);
+    if (existingEntry) {
+        // This $Ref has already been inventoried, so we don't need to process it again
+        if (depth < existingEntry.depth || indirections < existingEntry.indirections) {
+            removeFromInventory(inventory, existingEntry);
+        }
+        else {
+            return;
+        }
+    }
+    inventory.push({
+        $ref, // The JSON Reference (e.g. {$ref: string})
+        parent: $refParent, // The object that contains this $ref pointer
+        key: $refKey, // The key in `parent` that is the $ref pointer
+        pathFromRoot, // The path to the $ref pointer, from the JSON Schema root
+        depth, // How far from the JSON Schema root is this $ref pointer?
+        file, // The file that the $ref pointer resolves to
+        hash, // The hash within `file` that the $ref pointer resolves to
+        value: pointer.value, // The resolved value of the $ref pointer
+        circular: pointer.circular, // Is this $ref pointer DIRECTLY circular? (i.e. it references itself)
+        extended, // Does this $ref extend its resolved value? (i.e. it has extra properties, in addition to "$ref")
+        external, // Does this $ref pointer point to a file other than the main JSON Schema file?
+        indirections, // The number of indirect references that were traversed to resolve the value
+    });
+    // Recursively crawl the resolved value
+    if (!existingEntry || external) {
+        crawl(pointer.value, null, pointer.path, 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) {
+    // Group & sort all the $ref pointers, so they're in the order that we need to dereference/remap them
+    inventory.sort((a, b) => {
+        if (a.file !== b.file) {
+            // Group all the $refs that point to the same file
+            return a.file < b.file ? -1 : +1;
+        }
+        else if (a.hash !== b.hash) {
+            // Group all the $refs that point to the same part of the file
+            return a.hash < b.hash ? -1 : +1;
+        }
+        else if (a.circular !== b.circular) {
+            // If the $ref points to itself, then sort it higher than other $refs that point to this $ref
+            return a.circular ? -1 : +1;
+        }
+        else if (a.extended !== b.extended) {
+            // If the $ref extends the resolved value, then sort it lower than other $refs that don't extend the value
+            return a.extended ? +1 : -1;
+        }
+        else if (a.indirections !== b.indirections) {
+            // Sort direct references higher than indirect references
+            return a.indirections - b.indirections;
+        }
+        else if (a.depth !== b.depth) {
+            // Sort $refs by how close they are to the JSON Schema root
+            return a.depth - b.depth;
+        }
+        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");
+            if (aDefinitionsIndex !== bDefinitionsIndex) {
+                // Give higher priority to the $ref that's closer to the "definitions" property
+                return bDefinitionsIndex - aDefinitionsIndex;
+            }
+            else {
+                // All else is equal, so use the shorter path, which will produce the shortest possible reference
+                return a.pathFromRoot.length - b.pathFromRoot.length;
+            }
+        }
+    });
+    let file, hash, pathFromRoot;
+    for (const entry of inventory) {
+        // console.log('Re-mapping $ref pointer "%s" at %s', entry.$ref.$ref, entry.pathFromRoot);
+        if (!entry.external) {
+            // This $ref already resolves to the main JSON Schema file
+            entry.$ref.$ref = entry.hash;
+        }
+        else if (entry.file === file && entry.hash === hash) {
+            // This $ref points to the same value as the prevous $ref, so remap it to the same path
+            entry.$ref.$ref = pathFromRoot;
+        }
+        else if (entry.file === file && entry.hash.indexOf(hash + "/") === 0) {
+            // This $ref points to a sub-value of the prevous $ref, so remap it beneath that path
+            entry.$ref.$ref = pointer_js_1.default.join(pathFromRoot, pointer_js_1.default.parse(entry.hash.replace(hash, "#")));
+        }
+        else {
+            // We've moved to a new file or new hash
+            file = entry.file;
+            hash = entry.hash;
+            pathFromRoot = entry.pathFromRoot;
+            // This is the first $ref to point to this value, so dereference the value.
+            // Any other $refs that point to the same value will point to this $ref instead
+            entry.$ref = entry.parent[entry.key] = ref_js_1.default.dereference(entry.$ref, entry.value);
+            if (entry.circular) {
+                // This $ref points to itself
+                entry.$ref.$ref = entry.pathFromRoot;
+            }
+        }
+    }
+    // we want to ensure that any $refs that point to another $ref are remapped to point to the final value
+    // let hadChange = true;
+    // while (hadChange) {
+    //   hadChange = false;
+    //   for (const entry of inventory) {
+    //     if (entry.$ref && typeof entry.$ref === "object" && "$ref" in entry.$ref) {
+    //       const resolved = inventory.find((e: InventoryEntry) => e.pathFromRoot === entry.$ref.$ref);
+    //       if (resolved) {
+    //         const resolvedPointsToAnotherRef =
+    //           resolved.$ref && typeof resolved.$ref === "object" && "$ref" in resolved.$ref;
+    //         if (resolvedPointsToAnotherRef && entry.$ref.$ref !== resolved.$ref.$ref) {
+    //           // console.log('Re-mapping $ref pointer "%s" at %s', entry.$ref.$ref, entry.pathFromRoot);
+    //           entry.$ref.$ref = resolved.$ref.$ref;
+    //           hadChange = true;
+    //         }
+    //       }
+    //     }
+    //   }
+    // }
+}
+/**
+ * TODO
+ */
+function findInInventory(inventory, $refParent, $refKey) {
+    for (const existingEntry of inventory) {
+        if (existingEntry && existingEntry.parent === $refParent && existingEntry.key === $refKey) {
+            return existingEntry;
+        }
+    }
+    return undefined;
+}
+function removeFromInventory(inventory, entry) {
+    const index = inventory.indexOf(entry);
+    inventory.splice(index, 1);
+}
+exports.default = bundle;

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/dereference.d.ts

@@ -0,0 +1,12 @@
+import type { ParserOptions } from "./options.js";
+import type { JSONSchema } from "./types";
+import type $RefParser from "./index";
+export default dereference;
+/**
+ * Crawls the JSON schema, finds all JSON references, and dereferences them.
+ * This method mutates the JSON schema object, replacing JSON references with their resolved value.
+ *
+ * @param parser
+ * @param options
+ */
+declare function dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(parser: $RefParser<S, O>, options: O): void;