@hey-api/shared 0.4.0 → 0.4.2

package/dist/index.mjs

@@ -5,7 +5,7 @@ import open from "open";
 import { sync } from "cross-spawn";
 import * as semver from "semver";
 import { getResolvedInput, sendRequest } from "@hey-api/json-schema-ref-parser";
-import { fromRef, ref } from "@hey-api/codegen-core";
+import { fromRef, log, ref } from "@hey-api/codegen-core";
 import { EOL } from "node:os";
 //#region src/tsConfig.ts
 function findPackageJson(initialDir) {
@@ -628,13 +628,21 @@ function getLogs(userLogs) {
 //#endregion
 //#region src/config/output/postprocess.ts
 function postprocessOutput(config, postProcessors, jobPrefix) {
+	if (!fs.existsSync(config.path) || !fs.readdirSync(config.path).length) return;
 	for (const processor of config.postProcess) {
 		const resolved = typeof processor === "string" ? postProcessors[processor] : processor;
 		if (!resolved) continue;
 		const name = resolved.name ?? resolved.command;
 		const args = resolved.args.map((arg) => arg.replace("{{path}}", config.path));
 		console.log(`${jobPrefix}🧹 Running ${colors.cyanBright(name)}`);
-		sync(resolved.command, args);
+		const result = sync(resolved.command, args);
+		if (result.error) throw new ConfigError(`Post-processor "${name}" failed to run: ${result.error.message}`);
+		if (result.status !== null && result.status !== 0) {
+			let message = `Post-processor "${name}" exited with code ${result.status}`;
+			const stderr = result.stderr?.toString().trim();
+			if (stderr) message += `:\n${stderr}`;
+			throw new ConfigError(message);
+		}
 	}
 }
 //#endregion
@@ -1294,28 +1302,28 @@ function operationToId({ context, count = 1, id, method, path, state }) {
 //#endregion
 //#region src/debug/ir.ts
 const indent = (level) => "  ".repeat(level);
-const log = (message, level) => console.log(`${indent(level ?? 0)}${message}`);
+const log$1 = (message, level) => console.log(`${indent(level ?? 0)}${message}`);
 const print = (ir, options = {}) => {
 	const { depth = 2, section = "all", verbosity = "summary" } = options;
 	const printObject = (obj, level, kind = "generic") => {
 		if (verbosity === "summary" && obj && typeof obj === "object") if (kind === "responses") {
 			const count = Object.keys(obj).length;
 			const noun = count === 1 ? "code" : "codes";
-			log(`responses: ${colors.yellow(`${count} ${noun}`)}`, level);
-		} else if (kind === "requestBody") log(`requestBody: ${Object.keys(obj).join(", ")}`, level);
-		else if (kind === "schema") log(`schema keys: ${Object.keys(obj).join(", ")}`, level);
-		else log(`keys: ${Object.keys(obj).join(", ")}`, level);
-		else log(JSON.stringify(obj, null, depth), level);
+			log$1(`responses: ${colors.yellow(`${count} ${noun}`)}`, level);
+		} else if (kind === "requestBody") log$1(`requestBody: ${Object.keys(obj).join(", ")}`, level);
+		else if (kind === "schema") log$1(`schema keys: ${Object.keys(obj).join(", ")}`, level);
+		else log$1(`keys: ${Object.keys(obj).join(", ")}`, level);
+		else log$1(JSON.stringify(obj, null, depth), level);
 	};
 	const printPathItem = (key, item, base = 1) => {
 		if ("$ref" in item) {
-			log(`${colors.cyan(key)} is a $ref → ${colors.yellow(item.$ref)}`, base);
+			log$1(`${colors.cyan(key)} is a $ref → ${colors.yellow(item.$ref)}`, base);
 			return;
 		}
 		for (const method of Object.keys(item)) {
 			if (!httpMethods.includes(method)) continue;
 			const operation = item[method];
-			log(`${colors.green(method.toUpperCase())} ${colors.cyan(key)} (${colors.magenta(operation.operationId ?? "")})`, base);
+			log$1(`${colors.green(method.toUpperCase())} ${colors.cyan(key)} (${colors.magenta(operation.operationId ?? "")})`, base);
 			if (operation.body) printObject(operation.body, base + 1, "requestBody");
 			if (operation.responses) printObject(operation.responses, base + 1, "responses");
 		}
@@ -1324,20 +1332,20 @@ const print = (ir, options = {}) => {
 	for (const section of sections) switch (section) {
 		case "components":
 			if (ir.components?.schemas) {
-				log(`Components: ${Object.keys(ir.components.schemas).length} schemas`);
+				log$1(`Components: ${Object.keys(ir.components.schemas).length} schemas`);
 				for (const [, schema] of Object.entries(ir.components.schemas)) printObject(schema, 1, "schema");
 			}
 			break;
 		case "paths": {
 			const paths = ir.paths || {};
-			log(`paths (${Object.keys(paths).length} items):`);
+			log$1(`paths (${Object.keys(paths).length} items):`);
 			for (const [path, item] of Object.entries(paths)) printPathItem(path, item);
 			break;
 		}
 		case "servers": break;
 		case "webhooks": {
 			const webhooks = ir.webhooks || {};
-			log(`webhooks (${Object.keys(webhooks).length} items):`);
+			log$1(`webhooks (${Object.keys(webhooks).length} items):`);
 			for (const [path, item] of Object.entries(webhooks)) printPathItem(path, item);
 			break;
 		}
@@ -1540,24 +1548,38 @@ var MinHeap = class {
 * added to the graph.
 */
 const walkDeclarations = (graph, callback, options) => {
-	const pointers = Array.from(graph.nodes.keys());
 	if (options?.preferGroups && options.preferGroups.length) {
-		const emitted = /* @__PURE__ */ new Set();
-		if (options.matchPointerToGroup) for (const kind of options.preferGroups) for (const pointer of pointers) {
-			const result = options.matchPointerToGroup(pointer);
-			if (!result.matched) continue;
-			if (result.kind === kind) {
-				emitted.add(pointer);
-				callback(pointer, graph.nodes.get(pointer));
+		const preferGroupsSet = new Set(options.preferGroups);
+		const buckets = /* @__PURE__ */ new Map();
+		const unmatched = [];
+		for (const pointer of graph.nodes.keys()) {
+			if (options.matchPointerToGroup) {
+				const result = options.matchPointerToGroup(pointer);
+				if (result.matched) {
+					if (preferGroupsSet.has(result.kind)) {
+						let bucket = buckets.get(result.kind);
+						if (!bucket) {
+							bucket = [];
+							buckets.set(result.kind, bucket);
+						}
+						bucket.push(pointer);
+					} else unmatched.push(pointer);
+					continue;
+				}
 			}
+			unmatched.push(pointer);
 		}
-		for (const pointer of pointers) {
-			if (emitted.has(pointer)) continue;
-			callback(pointer, graph.nodes.get(pointer));
+		const emittedGroups = /* @__PURE__ */ new Set();
+		for (const kind of options.preferGroups) {
+			if (emittedGroups.has(kind)) continue;
+			emittedGroups.add(kind);
+			const pointers = buckets.get(kind);
+			if (pointers) for (const pointer of pointers) callback(pointer, graph.nodes.get(pointer));
 		}
+		for (const pointer of unmatched) callback(pointer, graph.nodes.get(pointer));
 		return;
 	}
-	for (const pointer of pointers) callback(pointer, graph.nodes.get(pointer));
+	for (const [pointer, node] of graph.nodes) callback(pointer, node);
 };
 /**
 * Walks the nodes of the graph in topological order (dependencies before dependents).
@@ -1569,36 +1591,32 @@ const walkDeclarations = (graph, callback, options) => {
 */
 const walkTopological = (graph, callback, options) => {
 	const pointers = Array.from(graph.nodes.keys());
-	const baseIndex = /* @__PURE__ */ new Map();
-	pointers.forEach((pointer, index) => baseIndex.set(pointer, index));
 	const declIndex = /* @__PURE__ */ new Map();
-	for (const pointer of pointers) {
-		const composite = (options?.getPointerPriority?.(pointer) ?? 10) * 1e6 + (baseIndex.get(pointer) ?? 0);
-		declIndex.set(pointer, composite);
-	}
 	const depsOf = /* @__PURE__ */ new Map();
-	for (const pointer of pointers) {
+	const inDegree = /* @__PURE__ */ new Map();
+	const dependents = /* @__PURE__ */ new Map();
+	const heap = new MinHeap(declIndex);
+	pointers.forEach((pointer, index) => {
+		const priority = options?.getPointerPriority?.(pointer) ?? 10;
+		declIndex.set(pointer, priority * 1e6 + index);
 		const raw = graph.subtreeDependencies?.get(pointer) ?? /* @__PURE__ */ new Set();
-		const filtered = /* @__PURE__ */ new Set();
+		const deps = /* @__PURE__ */ new Set();
 		for (const rawPointer of raw) {
 			if (rawPointer === pointer) continue;
-			if (graph.nodes.has(rawPointer)) filtered.add(rawPointer);
+			if (graph.nodes.has(rawPointer)) deps.add(rawPointer);
 		}
-		depsOf.set(pointer, filtered);
-	}
-	const inDegree = /* @__PURE__ */ new Map();
-	const dependents = /* @__PURE__ */ new Map();
-	for (const pointer of pointers) inDegree.set(pointer, 0);
-	for (const [pointer, deps] of depsOf) {
+		depsOf.set(pointer, deps);
 		inDegree.set(pointer, deps.size);
 		for (const d of deps) {
-			if (!dependents.has(d)) dependents.set(d, /* @__PURE__ */ new Set());
-			dependents.get(d).add(pointer);
+			let dep = dependents.get(d);
+			if (!dep) {
+				dep = /* @__PURE__ */ new Set();
+				dependents.set(d, dep);
+			}
+			dep.add(pointer);
 		}
-	}
-	const sortByDecl = (arr) => arr.sort((a, b) => declIndex.get(a) - declIndex.get(b));
-	const heap = new MinHeap(declIndex);
-	for (const pointer of pointers) if ((inDegree.get(pointer) ?? 0) === 0) heap.push(pointer);
+		if (deps.size === 0) heap.push(pointer);
+	});
 	const emitted = /* @__PURE__ */ new Set();
 	const order = [];
 	while (!heap.isEmpty()) {
@@ -1615,7 +1633,7 @@ const walkTopological = (graph, callback, options) => {
 		}
 	}
 	const remaining = pointers.filter((pointer) => !emitted.has(pointer));
-	sortByDecl(remaining);
+	remaining.sort((a, b) => declIndex.get(a) - declIndex.get(b));
 	for (const pointer of remaining) {
 		emitted.add(pointer);
 		order.push(pointer);
@@ -1634,16 +1652,27 @@ const walkTopological = (graph, callback, options) => {
 			}
 			return options.preferGroups.length;
 		};
+		const orderIndex = /* @__PURE__ */ new Map();
+		for (let i = 0; i < order.length; i++) orderIndex.set(order[i], i);
+		const groupCache = /* @__PURE__ */ new Map();
+		const getCachedGroup = (pointer) => {
+			let g = groupCache.get(pointer);
+			if (g === void 0) {
+				g = getGroup(pointer);
+				groupCache.set(pointer, g);
+			}
+			return g;
+		};
 		const proposed = [...order].sort((a, b) => {
-			const ga = getGroup(a);
-			const gb = getGroup(b);
-			return ga !== gb ? ga - gb : order.indexOf(a) - order.indexOf(b);
+			const ga = getCachedGroup(a);
+			const gb = getCachedGroup(b);
+			return ga !== gb ? ga - gb : orderIndex.get(a) - orderIndex.get(b);
 		});
 		const proposedIndex = /* @__PURE__ */ new Map();
 		for (let i = 0; i < proposed.length; i++) proposedIndex.set(proposed[i], i);
 		if (!(() => {
 			for (const [node, deps] of depsOf) for (const dep of deps) {
-				if (getGroup(dep) <= getGroup(node)) continue;
+				if (getCachedGroup(dep) <= getCachedGroup(node)) continue;
 				if (proposedIndex.get(dep) >= proposedIndex.get(node)) return true;
 			}
 			return false;
@@ -1719,15 +1748,12 @@ const getIrPointerPriority = (pointer) => {
 };
 //#endregion
 //#region src/utils/ref.ts
-const jsonPointerSlash = /~1/g;
-const jsonPointerTilde = /~0/g;
 /**
 * Returns the reusable component name from `$ref`.
 */
 function refToName($ref) {
 	const path = jsonPointerToPath($ref);
-	const name = path[path.length - 1];
-	return decodeURI(name);
+	return path[path.length - 1];
 }
 /**
 * Encodes a path segment for use in a JSON Pointer (RFC 6901).
@@ -1742,7 +1768,7 @@ function refToName($ref) {
 * @returns The encoded segment as a string.
 */
 function encodeJsonPointerSegment(segment) {
-	return String(segment).replace(/~/g, "~0").replace(/\//g, "~1");
+	return String(segment).replaceAll("~", "~0").replaceAll("/", "~1");
 }
 /**
 * Converts a JSON Pointer string (RFC 6901) to an array of path segments.
@@ -1760,7 +1786,7 @@ function jsonPointerToPath(pointer) {
 	if (clean.startsWith("#")) clean = clean.slice(1);
 	if (clean.startsWith("/")) clean = clean.slice(1);
 	if (!clean) return [];
-	return clean.split("/").map((part) => part.replace(jsonPointerSlash, "/").replace(jsonPointerTilde, "~"));
+	return clean.split("/").map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~"));
 }
 /**
 * Normalizes a JSON Pointer string to a canonical form.
@@ -1810,7 +1836,7 @@ function isTopLevelComponent(refOrPath) {
 	return false;
 }
 function resolveRef({ $ref, spec }) {
-	const path = jsonPointerToPath(decodeURI($ref));
+	const path = jsonPointerToPath($ref);
 	let current = spec;
 	for (const part of path) {
 		const segment = part;
@@ -2576,7 +2602,11 @@ function collectOperations({ filters, parameters, requestBodies, resourceMetadat
 				case "body": return !requestBodies.has(dependency);
 				case "parameter": return !parameters.has(dependency);
 				case "response": return !responses.has(dependency);
-				case "schema": return !schemas.has(dependency);
+				case "schema":
+					if (schemas.has(dependency)) return false;
+					if (filters.schemas.exclude.has(dependency)) return true;
+					schemas.add(dependency);
+					return false;
 				default: return false;
 			}
 		})) continue;
@@ -3261,24 +3291,25 @@ const propertiesRequiredByDefaultTransform = ({ spec }) => {
 */
 const deepEqual = (a, b) => {
 	if (a === b) return true;
-	if (a === null || b === null) return a === b;
-	const typeA = typeof a;
-	if (typeA !== typeof b) return false;
-	if (typeA !== "object") return false;
-	if (Array.isArray(a) || Array.isArray(b)) {
-		if (!Array.isArray(a) || !Array.isArray(b)) return false;
-		if (a.length !== b.length) return false;
-		for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
+	if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+	if (a.constructor !== b.constructor) return false;
+	if (Array.isArray(a)) {
+		const arrA = a;
+		const arrB = b;
+		let len = arrA.length;
+		if (len !== arrB.length) return false;
+		while (len--) if (!deepEqual(arrA[len], arrB[len])) return false;
 		return true;
 	}
 	const objA = a;
 	const objB = b;
-	const keysA = Object.keys(objA).sort();
-	const keysB = Object.keys(objB).sort();
-	if (keysA.length !== keysB.length) return false;
-	for (let i = 0; i < keysA.length; i++) if (keysA[i] !== keysB[i]) return false;
-	for (const key of keysA) if (!deepEqual(objA[key], objB[key])) return false;
-	return true;
+	let len = 0;
+	for (const key in objA) if (Object.hasOwn(objA, key)) {
+		++len;
+		if (!Object.hasOwn(objB, key)) return false;
+		if (!deepEqual(objA[key], objB[key])) return false;
+	}
+	return Object.keys(objB).length === len;
 };
 //#endregion
 //#region src/openApi/shared/utils/graph.ts
@@ -3356,85 +3387,35 @@ const collectPointerDependencies = ({ cache, graph, pointer, visited }) => {
 	};
 };
 /**
-* Propagates scopes through the graph using a worklist algorithm.
-* Each node's scopes will be updated to include any scopes inherited via $ref dependencies, combinator/child relationships, and parent relationships.
-* Handles cycles and deep chains efficiently.
+* Propagates scopes through the graph using a multi-pass linear scan.
+*
+* Nodes are visited in reverse DFS-pre-order (bottom-up): children tend to
+* appear before their parents so each node can push its scopes to its parent
+* within the same pass.  For typical OpenAPI specs (components declared after
+* paths) $ref targets also appear before $ref sources in this order, meaning
+* both tree propagation and $ref propagation usually converge in a single pass.
 *
-* Whenever a node's scopes change, all dependents are notified:
-*   - Its parent (if any)
-*   - All nodes that reference it via $ref (reverse dependencies)
-*   - Combinator parents (allOf/anyOf/oneOf) if applicable
+* The outer `while (changed)` loop guarantees correctness for any ordering:
+* it re-runs until no new scope values were added anywhere.  Because scopes
+* can only grow (at most 3 values: 'normal', 'read', 'write'), the loop
+* terminates in at most a handful of passes even for pathological specs.
 *
-* @param graph - The Graph structure containing nodes, dependencies, and reverseNodeDependencies.
+* @param graph - The Graph structure containing nodes and dependencies.
 */
 const propagateScopes = (graph) => {
-	const worklist = new Set(Array.from(graph.nodes.entries()).filter(([, nodeInfo]) => nodeInfo.scopes && nodeInfo.scopes.size > 0).map(([pointer]) => pointer));
-	/**
-	* Notifies all dependents of a node that its scopes may have changed.
-	* Dependents include:
-	*   - The parent node (if any)
-	*   - All nodes that reference this node via $ref (reverse dependencies)
-	*   - Combinator parents (allOf/anyOf/oneOf) if this node is a combinator child
-	*
-	* @param pointer - The JSON pointer of the node whose dependents to notify
-	* @param nodeInfo - The NodeInfo of the node
-	* @param childPointer - (Optional) The pointer of the child, used to detect combinator parents
-	*/
-	const notifyAllDependents = (pointer, nodeInfo, childPointer) => {
-		if (nodeInfo.parentPointer) worklist.add(nodeInfo.parentPointer);
-		const reverseNodeDependencies = graph.reverseNodeDependencies.get(pointer);
-		if (reverseNodeDependencies) for (const dependentPointer of reverseNodeDependencies) worklist.add(dependentPointer);
-		if (childPointer) {
-			const combinatorChildMatch = childPointer.match(/(.*)\/(allOf|anyOf|oneOf)\/\d+$/);
-			if (combinatorChildMatch) {
-				const combinatorParentPointer = combinatorChildMatch[1];
-				if (combinatorParentPointer) worklist.add(combinatorParentPointer);
-			}
-		}
-	};
-	/**
-	* Propagates scopes from a child node to its parent node.
-	* If the parent's scopes change, notifies all dependents.
-	*
-	* @param pointer - The parent node's pointer
-	* @param nodeInfo - The parent node's NodeInfo
-	* @param childPointer - The child node's pointer
-	*/
-	const propagateChildScopes = (pointer, nodeInfo, childPointer) => {
-		if (!nodeInfo?.scopes) return;
-		const childInfo = graph.nodes.get(childPointer);
-		if (!childInfo?.scopes) return;
-		if (propagateScopesToNode(childInfo, nodeInfo)) notifyAllDependents(pointer, nodeInfo, childPointer);
-	};
-	while (worklist.size > 0) {
-		const pointer = worklist.values().next().value;
-		worklist.delete(pointer);
-		const nodeInfo = graph.nodes.get(pointer);
-		if (!nodeInfo) continue;
-		if (!nodeInfo.scopes) nodeInfo.scopes = /* @__PURE__ */ new Set();
-		const node = nodeInfo.node;
-		for (const [keyword, type] of childSchemaRelationships) {
-			if (!node || typeof node !== "object" || !(keyword in node)) continue;
-			const value = node[keyword];
-			if (type === "array" && value instanceof Array) for (let index = 0; index < value.length; index++) propagateChildScopes(pointer, nodeInfo, `${pointer}/${keyword}/${index}`);
-			else if (type === "objectMap" && typeof value === "object" && value !== null && !(value instanceof Array)) for (const key of Object.keys(value)) propagateChildScopes(pointer, nodeInfo, `${pointer}/${keyword}/${key}`);
-			else if (type === "single" && typeof value === "object" && value !== null) propagateChildScopes(pointer, nodeInfo, `${pointer}/${keyword}`);
-			else if (type === "singleOrArray") {
-				if (value instanceof Array) for (let index = 0; index < value.length; index++) propagateChildScopes(pointer, nodeInfo, `${pointer}/${keyword}/${index}`);
-				else if (typeof value === "object" && value !== null) propagateChildScopes(pointer, nodeInfo, `${pointer}/${keyword}`);
+	const nodesBottomUp = [...graph.nodes].reverse();
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const [pointer, nodeInfo] of nodesBottomUp) {
+			const nodeDeps = graph.nodeDependencies.get(pointer);
+			if (nodeDeps) for (const depPointer of nodeDeps) {
+				const depInfo = graph.nodes.get(depPointer);
+				if (depInfo?.scopes && propagateScopesToNode(depInfo, nodeInfo)) changed = true;
 			}
-		}
-		const nodeDependencies = graph.nodeDependencies.get(pointer);
-		if (nodeDependencies) for (const depPointer of nodeDependencies) {
-			const depNode = graph.nodes.get(depPointer);
-			if (depNode?.scopes) {
-				if (propagateScopesToNode(depNode, nodeInfo)) notifyAllDependents(pointer, nodeInfo);
-			}
-		}
-		if (nodeInfo.parentPointer) {
-			const parentInfo = graph.nodes.get(nodeInfo.parentPointer);
-			if (parentInfo) {
-				if (propagateScopesToNode(nodeInfo, parentInfo)) notifyAllDependents(nodeInfo.parentPointer, parentInfo);
+			if (nodeInfo.scopes && nodeInfo.parentPointer) {
+				const parentInfo = graph.nodes.get(nodeInfo.parentPointer);
+				if (parentInfo && propagateScopesToNode(nodeInfo, parentInfo)) changed = true;
 			}
 		}
 	}
@@ -3459,52 +3440,29 @@ const propagateScopesToNode = (fromNodeInfo, toNodeInfo) => {
 	return changed;
 };
 /**
-* Seeds each node in the graph with its local access scope(s) based on its own properties.
-* - 'read' if readOnly: true
-* - 'write' if writeOnly: true
-* - 'normal' if node is an object property
-*
-* Only non-array objects are considered for scope seeding.
-*
-* @param nodes - Map of JSON Pointer to NodeInfo.
-*/
-const seedLocalScopes = (nodes) => {
-	for (const [pointer, nodeInfo] of nodes) {
-		const { node } = nodeInfo;
-		if (typeof node !== "object" || node === null || node instanceof Array) continue;
-		if ("readOnly" in node && node.readOnly === true) nodeInfo.scopes = new Set(["read"]);
-		else if ("writeOnly" in node && node.writeOnly === true) nodeInfo.scopes = new Set(["write"]);
-		else if (pointer.match(/\/properties\/[^/]+$/)) nodeInfo.scopes = new Set(["normal"]);
-	}
-};
-/**
 * Builds a graph of all nodes in an OpenAPI spec, indexed by normalized JSON Pointer,
 * and tracks all $ref dependencies and reverse dependencies between nodes.
 *
 * - All keys in the returned maps are normalized JSON Pointers (RFC 6901, always starting with '#').
 * - The `nodes` map allows fast lookup of any node and its parent/key context.
 * - The `dependencies` map records, for each node, the set of normalized pointers it references via $ref.
-* - The `reverseNodeDependencies` map records, for each node, the set of nodes that reference it via $ref.
 * - After construction, all nodes will have their local and propagated scopes annotated.
 *
 * @param root The root object (e.g., the OpenAPI spec)
 * @returns An object with:
 *   - nodes: Map from normalized JSON Pointer string to NodeInfo
 *   - dependencies: Map from normalized JSON Pointer string to Set of referenced normalized JSON Pointers
-*   - reverseNodeDependencies: Map from normalized JSON Pointer string to Set of referencing normalized JSON Pointers
 */
 function buildGraph(root, logger) {
 	const eventBuildGraph = logger.timeEvent("build-graph");
 	const graph = {
 		nodeDependencies: /* @__PURE__ */ new Map(),
 		nodes: /* @__PURE__ */ new Map(),
-		reverseNodeDependencies: /* @__PURE__ */ new Map(),
 		subtreeDependencies: /* @__PURE__ */ new Map(),
 		transitiveDependencies: /* @__PURE__ */ new Map()
 	};
-	const walk = ({ key, node, parentPointer, path }) => {
+	const walk = ({ key, node, parentPointer, pointer }) => {
 		if (typeof node !== "object" || node === null) return;
-		const pointer = pathToJsonPointer(path);
 		let deprecated;
 		let tags;
 		if (typeof node === "object" && node !== null) {
@@ -3514,7 +3472,7 @@ function buildGraph(root, logger) {
 				if (!graph.nodeDependencies.has(pointer)) graph.nodeDependencies.set(pointer, /* @__PURE__ */ new Set());
 				graph.nodeDependencies.get(pointer).add(refPointer);
 			}
-			if ("tags" in node && node.tags instanceof Array) tags = new Set(node.tags.filter((tag) => typeof tag === "string"));
+			if ("tags" in node && Array.isArray(node.tags)) tags = new Set(node.tags.filter((tag) => typeof tag === "string"));
 		}
 		graph.nodes.set(pointer, {
 			deprecated,
@@ -3523,24 +3481,24 @@ function buildGraph(root, logger) {
 			parentPointer,
 			tags
 		});
-		if (node instanceof Array) node.forEach((item, index) => walk({
+		if (Array.isArray(node)) node.forEach((item, index) => walk({
 			key: index,
 			node: item,
 			parentPointer: pointer,
-			path: [...path, index]
+			pointer: pointer + "/" + encodeJsonPointerSegment(index)
 		}));
 		else for (const [childKey, value] of Object.entries(node)) walk({
 			key: childKey,
 			node: value,
 			parentPointer: pointer,
-			path: [...path, childKey]
+			pointer: pointer + "/" + encodeJsonPointerSegment(childKey)
 		});
 	};
 	walk({
 		key: null,
 		node: root,
 		parentPointer: null,
-		path: []
+		pointer: "#"
 	});
 	const cache = {
 		parentToChildren: /* @__PURE__ */ new Map(),
@@ -3549,15 +3507,25 @@ function buildGraph(root, logger) {
 	};
 	for (const [pointer, nodeInfo] of graph.nodes) {
 		const parent = nodeInfo.parentPointer;
-		if (!parent) continue;
-		if (!cache.parentToChildren.has(parent)) cache.parentToChildren.set(parent, []);
-		cache.parentToChildren.get(parent).push(pointer);
-	}
-	for (const [pointerFrom, pointers] of graph.nodeDependencies) for (const pointerTo of pointers) {
-		if (!graph.reverseNodeDependencies.has(pointerTo)) graph.reverseNodeDependencies.set(pointerTo, /* @__PURE__ */ new Set());
-		graph.reverseNodeDependencies.get(pointerTo).add(pointerFrom);
+		if (parent) {
+			let arr = cache.parentToChildren.get(parent);
+			if (!arr) {
+				arr = [];
+				cache.parentToChildren.set(parent, arr);
+			}
+			arr.push(pointer);
+		}
+		const { node } = nodeInfo;
+		if (typeof node === "object" && node !== null && !Array.isArray(node)) if ("readOnly" in node && node.readOnly === true) nodeInfo.scopes = new Set(["read"]);
+		else if ("writeOnly" in node && node.writeOnly === true) nodeInfo.scopes = new Set(["write"]);
+		else {
+			const lastSlash = pointer.lastIndexOf("/");
+			if (lastSlash > 0) {
+				const prevSlash = pointer.lastIndexOf("/", lastSlash - 1);
+				if (prevSlash >= 0 && pointer.slice(prevSlash + 1, lastSlash) === "properties") nodeInfo.scopes = new Set(["normal"]);
+			}
+		}
 	}
-	seedLocalScopes(graph.nodes);
 	propagateScopes(graph);
 	annotateChildScopes(graph.nodes);
 	for (const pointer of graph.nodes.keys()) {
@@ -4616,7 +4584,7 @@ function parseRef$2({ context, schema, state }) {
 			return irSchema;
 		}
 	}
-	irSchema.$ref = decodeURI(schema.$ref);
+	irSchema.$ref = schema.$ref;
 	irSchema.$ref = irSchema.$ref.replace(/#\/definitions\/([^/]+)/g, "#/components/schemas/$1");
 	if (!state.circularReferenceTracker.has(schema.$ref)) {
 		const refSchema = context.resolveRef(schema.$ref);
@@ -5872,6 +5840,7 @@ function parseAnyOf$1({ context, schema, state }) {
 			logicalOperator: "and"
 		};
 	}
+	if (schema.discriminator && irSchema.logicalOperator === "or") irSchema.discriminator = { propertyName: schema.discriminator.propertyName };
 	return irSchema;
 }
 function parseEnum$1({ context, schema, state }) {
@@ -5964,6 +5933,7 @@ function parseOneOf$1({ context, schema, state }) {
 			logicalOperator: "and"
 		};
 	}
+	if (schema.discriminator && irSchema.logicalOperator === "or") irSchema.discriminator = { propertyName: schema.discriminator.propertyName };
 	return irSchema;
 }
 function parseRef$1({ context, schema, state }) {
@@ -5982,7 +5952,7 @@ function parseRef$1({ context, schema, state }) {
 		}
 	}
 	const irSchema = {};
-	irSchema.$ref = decodeURI(schema.$ref);
+	irSchema.$ref = schema.$ref;
 	if (!state.circularReferenceTracker.has(schema.$ref)) {
 		const refSchema = context.resolveRef(schema.$ref);
 		const originalRef = state.$ref;
@@ -7264,6 +7234,7 @@ function parseAnyOf({ context, schema, state }) {
 			logicalOperator: "and"
 		};
 	}
+	if (schema.discriminator && irSchema.logicalOperator === "or") irSchema.discriminator = { propertyName: schema.discriminator.propertyName };
 	return irSchema;
 }
 function parseEnum({ context, schema, state }) {
@@ -7359,6 +7330,7 @@ function parseOneOf({ context, schema, state }) {
 			logicalOperator: "and"
 		};
 	}
+	if (schema.discriminator && irSchema.logicalOperator === "or") irSchema.discriminator = { propertyName: schema.discriminator.propertyName };
 	return irSchema;
 }
 function parseRef({ context, schema, state }) {
@@ -7382,7 +7354,7 @@ function parseRef({ context, schema, state }) {
 		schema
 	});
 	const irRefSchema = {};
-	irRefSchema.$ref = decodeURI(schema.$ref);
+	irRefSchema.$ref = schema.$ref;
 	if (!state.circularReferenceTracker.has(schema.$ref)) {
 		const refSchema = context.resolveRef(schema.$ref);
 		const originalRef = state.$ref;
@@ -8508,6 +8480,36 @@ async function patchOpenApiSpec({ patchOptions, spec: _spec }) {
 	}
 }
 //#endregion
+//#region src/plugins/duplicate.ts
+function stableStringify(value) {
+	return JSON.stringify(value, (_, v) => {
+		if (typeof v === "function") return `[function:${v.toString()}]`;
+		if (v && typeof v === "object" && !Array.isArray(v)) return Object.fromEntries(Object.entries(v).sort(([a], [b]) => a.localeCompare(b)));
+		return v;
+	});
+}
+function normalizePluginEntry(plugin) {
+	if (typeof plugin === "string") return {
+		name: plugin,
+		serialized: "{}"
+	};
+	const { name, ...config } = plugin;
+	return {
+		name,
+		serialized: stableStringify(config)
+	};
+}
+function warnOnConflictingDuplicatePlugins(plugins) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const plugin of plugins) {
+		const { name, serialized } = normalizePluginEntry(plugin);
+		if (!name) continue;
+		const previous = seen.get(name);
+		if (previous !== void 0 && previous !== serialized) log.warn(`Plugin "${name}" is configured multiple times. Only the last instance will take effect.`);
+		seen.set(name, serialized);
+	}
+}
+//#endregion
 //#region src/plugins/shared/utils/config.ts
 const definePluginConfig = (defaultConfig) => (userConfig) => ({
 	...defaultConfig,
@@ -8711,9 +8713,9 @@ function pathToName(path, options) {
 		} else if (STRUCTURAL_SUFFIX[segment]) names.push(STRUCTURAL_SUFFIX[segment]);
 		index++;
 	}
-	return decodeURI(names.join("-"));
+	return names.join("-");
 }
 //#endregion
-export { ConfigError, ConfigValidationError, Context, HeyApiError, InputError, IntentContext, JobError, MinHeap, OperationPath, OperationStrategy, PluginInstance, addItemsToSchema, applyNaming, buildGraph, buildSymbolIn, checkNodeVersion, childContext, compileInputPath, createOperationKey, createSchemaProcessor, createSchemaWalker, debugTools, deduplicateSchema, defaultPaginationKeywords, definePluginConfig, dependencyFactory, encodeJsonPointerSegment, ensureDirSync, escapeComment, findPackageJson, findTsConfigPath, getInput, getInputError, getLogs, getParser, getSpec, hasOperationDataRequired, hasParameterGroupObjectRequired, hasParametersObjectRequired, heyApiRegistryBaseUrl, inputToApiRegistry, isEnvironment, isTopLevelComponent, jsonPointerToPath, loadPackageJson, logCrashReport, logInputPaths, mappers, normalizeJsonPointer, openGitHubIssueWithCrashReport, operationPagination, operationResponsesMap, outputHeaderToPrefix, parameterWithPagination, parseOpenApiSpec, parseUrl, parseV2_0_X, parseV3_0_X, parseV3_1_X, patchOpenApiSpec, pathToJsonPointer, pathToName, postprocessOutput, printCliIntro, printCrashReport, refToName, requestValidatorLayers, resolveNaming, resolveRef, resolveSource, resolveValidatorLayer, satisfies, shouldReportCrash, statusCodeToGroup, toCase, utils, valueToObject };
+export { ConfigError, ConfigValidationError, Context, HeyApiError, InputError, IntentContext, JobError, MinHeap, OperationPath, OperationStrategy, PluginInstance, addItemsToSchema, applyNaming, buildGraph, buildSymbolIn, checkNodeVersion, childContext, compileInputPath, createOperationKey, createSchemaProcessor, createSchemaWalker, debugTools, deduplicateSchema, defaultPaginationKeywords, definePluginConfig, dependencyFactory, encodeJsonPointerSegment, ensureDirSync, escapeComment, findPackageJson, findTsConfigPath, getInput, getInputError, getLogs, getParser, getSpec, hasOperationDataRequired, hasParameterGroupObjectRequired, hasParametersObjectRequired, heyApiRegistryBaseUrl, inputToApiRegistry, isEnvironment, isTopLevelComponent, jsonPointerToPath, loadPackageJson, logCrashReport, logInputPaths, mappers, normalizeJsonPointer, openGitHubIssueWithCrashReport, operationPagination, operationResponsesMap, outputHeaderToPrefix, parameterWithPagination, parseOpenApiSpec, parseUrl, parseV2_0_X, parseV3_0_X, parseV3_1_X, patchOpenApiSpec, pathToJsonPointer, pathToName, postprocessOutput, printCliIntro, printCrashReport, refToName, requestValidatorLayers, resolveNaming, resolveRef, resolveSource, resolveValidatorLayer, satisfies, shouldReportCrash, statusCodeToGroup, toCase, utils, valueToObject, warnOnConflictingDuplicatePlugins };
 
 //# sourceMappingURL=index.mjs.map