@openmirai/typeforge 0.1.7

package/dist/init-BBNO0SYd.js

@@ -0,0 +1,2029 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, parse, relative, resolve } from "node:path";
+import chalk from "chalk";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+//#region src/json/types.ts
+function isJsonPrimitive(value) {
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isJsonValue(value) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return true;
+	if (Array.isArray(value)) return value.every(isJsonValue);
+	if (typeof value === "object" && value !== null) return Object.values(value).every(isJsonValue);
+	return false;
+}
+function isJsonObject(value) {
+	return isJsonValue(value) && typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJsonArray(value) {
+	return Array.isArray(value) && value.every(isJsonValue);
+}
+function parseJson(text) {
+	const parsed = JSON.parse(text);
+	if (!isJsonValue(parsed)) throw new TypeError("JSON text did not parse to a valid JSON value");
+	return parsed;
+}
+function readJsonObject(text) {
+	const parsed = parseJson(text);
+	if (!isJsonObject(parsed)) throw new TypeError("JSON text did not parse to a JSON object");
+	return parsed;
+}
+function readJsonPrimitives(values) {
+	if (!isJsonArray(values)) return [];
+	return values.filter(isJsonPrimitive);
+}
+//#endregion
+//#region src/config/load.ts
+function readOptionalJson(path) {
+	if (!existsSync(path)) return {};
+	try {
+		const raw = readJsonObject(readFileSync(path, "utf8"));
+		const config = {};
+		if (typeof raw["apiRoot"] === "string") config.apiRoot = raw["apiRoot"];
+		return config;
+	} catch {
+		return {};
+	}
+}
+function readPackageConfig(path) {
+	if (!existsSync(path)) return {};
+	try {
+		const raw = readJsonObject(readFileSync(path, "utf8"));
+		const typeforge = raw["typeforge"] ?? raw["openapiCodegen"];
+		if (typeof typeforge !== "object" || typeforge === null || Array.isArray(typeforge)) return {};
+		const config = {};
+		if (typeof typeforge["apiRoot"] === "string") config.apiRoot = typeforge["apiRoot"];
+		return config;
+	} catch {
+		return {};
+	}
+}
+function unwrapDefineSourceConfig(content) {
+	const match = content.match(/defineSourceConfig\s*(?:<[^>]*>)?\s*\(\s*\{([\s\S]*)\}\s*\)/);
+	if (match?.[1] !== void 0) return `{${match[1]}}`;
+	return content;
+}
+function parseSourceConfigContent(content) {
+	const normalized = unwrapDefineSourceConfig(content);
+	const config = {};
+	const pathPrefix = normalized.match(/pathPrefix:\s*["'`]([^"'`]+)["'`]/);
+	if (pathPrefix?.[1] !== void 0) config.pathPrefix = pathPrefix[1];
+	const functionsDir = normalized.match(/functionsDir:\s*["'`]([^"'`]+)["'`]/);
+	if (functionsDir?.[1] !== void 0) config.functionsDir = functionsDir[1];
+	const typesDir = normalized.match(/typesDir:\s*["'`]([^"'`]+)["'`]/);
+	if (typesDir?.[1] !== void 0) config.typesDir = typesDir[1];
+	const ignoreMatch = normalized.match(/ignorePaths:\s*\[([\s\S]*?)\]/);
+	if (ignoreMatch?.[1] !== void 0) {
+		const paths = [...ignoreMatch[1].matchAll(/["'`]([^"'`]+)["'`]/g)].map((match) => match[1]).filter((path) => path !== void 0);
+		if (paths.length > 0) config.ignorePaths = paths;
+	}
+	if (/stripApiPrefix:\s*true/.test(normalized)) config.stripApiPrefix = true;
+	const routeEnumName = normalized.match(/routeEnumName:\s*["'`]([^"'`]+)["'`]/);
+	if (routeEnumName?.[1] !== void 0) config.routeEnumName = routeEnumName[1];
+	const generationMode = normalized.match(/generationMode:\s*["'`](authoritative|merge)["'`]/);
+	if (generationMode?.[1] === "authoritative" || generationMode?.[1] === "merge") config.generationMode = generationMode[1];
+	const naming = normalized.match(/naming:\s*["'`](path|operationId)["'`]/);
+	if (naming?.[1] === "path" || naming?.[1] === "operationId") config.naming = naming[1];
+	if (/resolveMapKeyRefs:\s*false/.test(normalized)) config.resolveMapKeyRefs = false;
+	if (/unwrapResponseData:\s*true/.test(normalized)) config.unwrapResponseData = true;
+	if (/tanstackQuery:\s*true/.test(normalized)) config.tanstackQuery = true;
+	const importBase = normalized.match(/importBase:\s*["'`]([^"'`]+)["'`]/);
+	if (importBase?.[1] !== void 0) config.importBase = importBase[1];
+	const maxRenderDepth = normalized.match(/maxRenderDepth:\s*(\d+)/)?.[1];
+	if (maxRenderDepth !== void 0) config.maxRenderDepth = Number.parseInt(maxRenderDepth, 10);
+	const queryExtends = parseQueryExtends(normalized);
+	if (queryExtends !== void 0) config.queryExtends = queryExtends;
+	const spec = normalized.match(/spec:\s*["'`]([^"'`]+)["'`]/);
+	if (spec?.[1] !== void 0) config.spec = spec[1];
+	return config;
+}
+function parseQueryExtends(content) {
+	const block = content.match(/queryExtends:\s*\{([\s\S]*?)\}/)?.[1];
+	if (block === void 0) return;
+	const config = {};
+	const read = (key) => block.match(new RegExp(`${key}:\\s*["'\`]([^"'\`]+)["'\`]`))?.[1];
+	const page = read("page");
+	const limit = read("limit");
+	const sortBy = read("sortBy");
+	const sortOrder = read("sortOrder");
+	const paginationTypeName = read("paginationTypeName");
+	const paginationImportPath = read("paginationImportPath");
+	const sortTypeName = read("sortTypeName");
+	const sortImportPath = read("sortImportPath");
+	if (page !== void 0) config.page = page;
+	if (limit !== void 0) config.limit = limit;
+	if (sortBy !== void 0) config.sortBy = sortBy;
+	if (sortOrder !== void 0) config.sortOrder = sortOrder;
+	if (paginationTypeName !== void 0) config.paginationTypeName = paginationTypeName;
+	if (paginationImportPath !== void 0) config.paginationImportPath = paginationImportPath;
+	if (sortTypeName !== void 0) config.sortTypeName = sortTypeName;
+	if (sortImportPath !== void 0) config.sortImportPath = sortImportPath;
+	return Object.keys(config).length > 0 ? config : void 0;
+}
+function loadProjectConfig(cwd) {
+	const fromJson = readOptionalJson(resolve(cwd, "typeforge.json"));
+	const fromLegacyJson = readOptionalJson(resolve(cwd, "openapi-codegen.json"));
+	const fromPackage = readPackageConfig(resolve(cwd, "package.json"));
+	return { apiRoot: fromJson.apiRoot ?? fromLegacyJson.apiRoot ?? fromPackage.apiRoot ?? "src/api" };
+}
+function loadSourceConfig(cwd, apiRoot, sourceKey) {
+	const sourcePath = resolve(cwd, apiRoot, sourceKey, "source.ts");
+	if (!existsSync(sourcePath)) return {};
+	return parseSourceConfigContent(readFileSync(sourcePath, "utf8"));
+}
+function readModelsFile(cwd, apiRoot) {
+	const modelsPath = resolve(cwd, apiRoot, "models.ts");
+	if (!existsSync(modelsPath)) return;
+	return readFileSync(modelsPath, "utf8");
+}
+function hasQueryScopeFile(cwd, apiRoot) {
+	return existsSync(resolve(cwd, apiRoot, "query-scope.ts"));
+}
+function detectHttpMode(cwd, apiRoot) {
+	const httpPath = resolve(cwd, apiRoot, "http.ts");
+	if (!existsSync(httpPath)) return "injected";
+	const content = readFileSync(httpPath, "utf8");
+	if (/export\s+(const|function)\s+httpFetch\b/.test(content)) return "singleton";
+	if (/export\s*\{[^}]*\bhttpFetch\b/.test(content)) return "singleton";
+	return "injected";
+}
+function listSourceKeys(cwd, apiRoot) {
+	const apiRootPath = resolve(cwd, apiRoot);
+	if (!existsSync(apiRootPath)) return [];
+	return readdirSync(apiRootPath).filter((entry) => {
+		const entryPath = join(apiRootPath, entry);
+		if (!statSync(entryPath).isDirectory()) return false;
+		return existsSync(join(entryPath, "source.ts"));
+	});
+}
+//#endregion
+//#region src/utils/tsconfig-paths.ts
+/**
+* Strip line comments (//) and block comments from a JSON string, and
+* remove trailing commas before closing braces/brackets.
+* Handles tsconfig.json / jsonc format.
+*/
+function stripJsonComments(text) {
+	let result = "";
+	let i = 0;
+	const len = text.length;
+	let inString = false;
+	while (i < len) {
+		const ch = text[i];
+		if (inString) {
+			result += ch;
+			if (ch === "\\") {
+				i++;
+				if (i < len) result += text[i];
+			} else if (ch === "\"") inString = false;
+			i++;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = true;
+			result += ch;
+			i++;
+			continue;
+		}
+		if (ch === "/" && text[i + 1] === "/") {
+			while (i < len && text[i] !== "\n") i++;
+			continue;
+		}
+		if (ch === "/" && text[i + 1] === "*") {
+			i += 2;
+			while (i < len && !(text[i] === "*" && text[i + 1] === "/")) i++;
+			i += 2;
+			continue;
+		}
+		result += ch;
+		i++;
+	}
+	return result.replace(/,(\s*[}\]])/g, "$1");
+}
+/**
+* Load `compilerOptions.paths` and `baseUrl` from the nearest `tsconfig.json`
+* found at or above `startDir`. Returns `undefined` when no tsconfig has paths.
+*/
+function loadTsconfigPaths(startDir) {
+	let currentDir = resolve(startDir);
+	const rootDir = parse(currentDir).root;
+	while (true) {
+		const config = readTsconfigPaths(currentDir);
+		if (config !== void 0) return config;
+		if (currentDir === rootDir) return;
+		currentDir = dirname(currentDir);
+	}
+}
+function readTsconfigPaths(configDir) {
+	const tsconfigPath = resolve(configDir, "tsconfig.json");
+	if (!existsSync(tsconfigPath)) return;
+	try {
+		const raw = JSON.parse(stripJsonComments(readFileSync(tsconfigPath, "utf8")));
+		if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return;
+		const opts = raw["compilerOptions"];
+		if (typeof opts !== "object" || opts === null || Array.isArray(opts)) return;
+		const compilerOptions = opts;
+		const rawPaths = compilerOptions["paths"];
+		if (typeof rawPaths !== "object" || rawPaths === null || Array.isArray(rawPaths)) return;
+		const baseUrl = typeof compilerOptions["baseUrl"] === "string" ? compilerOptions["baseUrl"] : ".";
+		const normalizedPaths = {};
+		for (const [key, value] of Object.entries(rawPaths)) if (Array.isArray(value) && value.every((v) => typeof v === "string")) normalizedPaths[key] = value;
+		if (Object.keys(normalizedPaths).length === 0) return;
+		return {
+			baseDir: configDir,
+			paths: normalizedPaths,
+			resolvedBaseUrl: resolve(configDir, baseUrl)
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* Try to find a tsconfig path alias for `absoluteTarget`.
+*
+* Returns the alias import string (e.g. `@mirai/utils/api/v2/generated/runtime`)
+* when a match is found, or `undefined` when no alias covers the target.
+*
+* Supports:
+* - Wildcard patterns: `"@foo/*"` → `["packages/foo/src/*"]`
+* - Exact patterns: `"@foo/bar"` → `["packages/foo/src/bar"]`
+*/
+function resolveAliasImport(absoluteTarget, config) {
+	for (const [alias, mappings] of Object.entries(config.paths)) for (const mapping of mappings) if (alias.endsWith("/*") && mapping.endsWith("/*")) {
+		const aliasBase = alias.slice(0, -2);
+		const mappingBase = mapping.slice(0, -2);
+		const resolvedBase = resolve(config.resolvedBaseUrl, mappingBase);
+		if (absoluteTarget.startsWith(`${resolvedBase}/`)) return `${aliasBase}/${absoluteTarget.slice(resolvedBase.length + 1)}`;
+		if (absoluteTarget === resolvedBase) return aliasBase;
+	} else if (!alias.includes("*") && !mapping.includes("*")) {
+		const resolvedMapping = resolve(config.resolvedBaseUrl, mapping);
+		if (stripTsExtension(absoluteTarget) === stripTsExtension(resolvedMapping)) return alias;
+	}
+}
+function stripTsExtension(p) {
+	return p.replace(/\.(d\.ts|ts|js)$/, "");
+}
+//#endregion
+//#region src/utils/imports.ts
+function stripTypeScriptExtension(filePath) {
+	return filePath.replace(/\.d\.ts$/, "").replace(/\.ts$/, "");
+}
+function relativeImportPath(fromFilePath, toPathWithoutExtension) {
+	const fromDir = dirname(stripTypeScriptExtension(fromFilePath));
+	const toPath = stripTypeScriptExtension(toPathWithoutExtension);
+	const rel = relative(fromDir, toPath).replace(/\\/g, "/");
+	if (rel.startsWith(".")) return rel;
+	return `./${rel}`;
+}
+/**
+* Minimum number of `../` segments before we prefer an alias import over a
+* relative one.  Paths with fewer segments are already concise.
+*/
+const MIN_DOTDOT_FOR_ALIAS = 3;
+/**
+* Resolve the best import path from `fromAbsolutePath` to `toAbsolutePath`.
+*
+* Resolution priority:
+* 1. `importBase` explicit override (e.g. `@mirai/utils/src/api/v2/generated`)
+* 2. tsconfig path alias auto-detection (when relative has ≥3 `../` segments)
+* 3. Relative fallback
+*/
+function resolveAliasAwareImport(options) {
+	const { fromAbsolutePath, toAbsolutePath, importBase, generatedDir, tsconfigPaths } = options;
+	if (importBase !== void 0 && generatedDir !== void 0) {
+		const strippedGenDir = generatedDir.replace(/\/$/, "");
+		const strippedTarget = stripTypeScriptExtension(toAbsolutePath);
+		if (strippedTarget.startsWith(`${strippedGenDir}/`)) return `${importBase}/${strippedTarget.slice(strippedGenDir.length + 1)}`;
+		if (strippedTarget === strippedGenDir) return importBase;
+	}
+	const rel = relativeImportPath(fromAbsolutePath, toAbsolutePath);
+	if (tsconfigPaths !== void 0) {
+		if ((rel.match(/\.\.\//g) ?? []).length >= MIN_DOTDOT_FOR_ALIAS) {
+			const aliasImport = resolveAliasImport(toAbsolutePath, tsconfigPaths);
+			if (aliasImport !== void 0) return aliasImport;
+		}
+	}
+	return rel;
+}
+/**
+* Compute the absolute path of a generated function file.
+*
+* @param functionsDir - absolute path to the `functions/` directory
+* @param cleanPath    - path segment like `api/v2/auth/email/validate`
+* @param method       - HTTP method in uppercase, e.g. `GET`
+*/
+function functionFileAbsPath(functionsDir, cleanPath, method) {
+	return join(functionsDir, cleanPath, `${method}.ts`);
+}
+//#endregion
+//#region src/utils/naming.ts
+function pathToEnumName(routePath) {
+	return routePath.split("/").filter(Boolean).map((segment) => {
+		return segment.replace(/[{}]/g, "").replace(/[^a-zA-Z0-9]/g, "_").toUpperCase();
+	}).join("_");
+}
+function pathToRouteValue(routePath, stripApiPrefix = false) {
+	return (stripApiPrefix ? routePath.replace(/^\/api\//, "/") : routePath).replace(/\{(\w+)\}/g, ":$1");
+}
+function pathToFunctionName(cleanPath, method) {
+	const resourceName = cleanPath.split("/").filter(Boolean).map((segment) => segment.replace(/[{[\]}/]/g, "").split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("")).join("");
+	return `${method === "get" ? "get" : method}${resourceName}`;
+}
+function schemaKindLabel(schema) {
+	if (schema.kind === "array") return "array";
+	if (schema.kind === "object") return "object";
+	if (schema.kind === "ref") return `ref:${schema.ref ?? "unknown"}`;
+	if (schema.kind === "oneOf" || schema.kind === "anyOf" || schema.kind === "allOf") return schema.kind;
+	if (schema.enum !== void 0 && schema.enum.length > 0) return "enum";
+	return schema.kind;
+}
+function isSuccessStatusCode(statusCode) {
+	const code = Number.parseInt(statusCode, 10);
+	return !Number.isNaN(code) && code >= 200 && code < 300;
+}
+//#endregion
+//#region src/utils/path-params.ts
+function renderPathParamTypeFromSchema(schema) {
+	if (schema.enum !== void 0 && schema.enum.length > 0) return schema.enum.map((value) => JSON.stringify(value)).join(" | ");
+	if (schema.kind === "number") return "number";
+	if (schema.kind === "boolean") return "boolean";
+	return "string";
+}
+function resolvePathParamSchemas(pathItem) {
+	const schemas = /* @__PURE__ */ new Map();
+	for (const operation of pathItem.operations) for (const param of operation.pathParams) if (!schemas.has(param.name)) schemas.set(param.name, param.schema);
+	return schemas;
+}
+function renderPathParamType(schemas, param) {
+	const schema = schemas.get(param);
+	if (schema === void 0) return "string";
+	return renderPathParamTypeFromSchema(schema);
+}
+//#endregion
+//#region src/utils/type-names.ts
+function getFunctionTypeName(cleanPath, method) {
+	const parts = cleanPath.split("/").filter(Boolean).map((segment) => segment.replace(/[{[\]}/]/g, "").split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("")).join("");
+	return `${method.toUpperCase()}${parts}`;
+}
+function hasMeaningfulRequestBody(operation) {
+	const schema = operation.requestBody?.schema;
+	if (schema === void 0) return false;
+	return !isEmptySchema(schema);
+}
+function isEmptySchema(schema) {
+	if (schema.kind === "unknown") return true;
+	if (schema.kind === "object") {
+		if (schema.properties === void 0) return true;
+		return Object.keys(schema.properties).length === 0;
+	}
+	return false;
+}
+function getSuccessResponseSchema(operation) {
+	return operation.responses.find((response) => isSuccessStatusCode(response.statusCode) && response.schema !== void 0)?.schema;
+}
+//#endregion
+//#region src/emitters/functions/index.ts
+function extractPathParams(routePath) {
+	return (routePath.match(/\{([^}]+)\}/g) ?? []).map((match) => match.slice(1, -1));
+}
+function getTypeImportPath(cleanPath, method, options) {
+	const normalizedPath = cleanPath.replace(/\{([^}]+)\}/g, "[$1]").split("/").filter(Boolean).join("/");
+	const fromAbs = functionFileAbsPath(options.functionsDir, cleanPath, method.toUpperCase());
+	const toAbs = join(options.typesDir, normalizedPath, method.toUpperCase());
+	return resolveAliasAwareImport({
+		fromAbsolutePath: fromAbs,
+		generatedDir: options.generatedDir,
+		toAbsolutePath: toAbs,
+		...options.importBase !== void 0 ? { importBase: options.importBase } : {},
+		...options.tsconfigPaths !== void 0 ? { tsconfigPaths: options.tsconfigPaths } : {}
+	});
+}
+function getRuntimeImportPath(cleanPath, options, method) {
+	const fromAbs = functionFileAbsPath(options.functionsDir, cleanPath, method.toUpperCase());
+	const toAbs = join(options.generatedDir, "runtime");
+	return resolveAliasAwareImport({
+		fromAbsolutePath: fromAbs,
+		generatedDir: options.generatedDir,
+		toAbsolutePath: toAbs,
+		...options.importBase !== void 0 ? { importBase: options.importBase } : {},
+		...options.tsconfigPaths !== void 0 ? { tsconfigPaths: options.tsconfigPaths } : {}
+	});
+}
+function renderOperationPathParamType(operation, schemas, param) {
+	const pathParam = operation.pathParams.find((entry) => entry.name === param);
+	if (pathParam !== void 0) return renderPathParamType(/* @__PURE__ */ new Map([[param, pathParam.schema]]), param);
+	return renderPathParamType(schemas, param);
+}
+function emitFunctionFiles(options) {
+	const files = [];
+	for (const pathItem of options.paths) for (const operation of pathItem.operations) files.push({
+		content: renderFunctionFile(pathItem, operation, options),
+		relativePath: `${pathItem.cleanPath}/${operation.method.toUpperCase()}.ts`
+	});
+	return files;
+}
+function renderFunctionFile(pathItem, operation, options) {
+	const method = operation.method;
+	const functionName = pathToFunctionName(pathItem.cleanPath, method);
+	const enumName = pathToEnumName(pathItem.path);
+	const typeName = getFunctionTypeName(pathItem.cleanPath, method);
+	const pathParams = extractPathParams(pathItem.path);
+	const pathParamSchemas = resolvePathParamSchemas(pathItem);
+	const propsTypeName = `${capitalize(functionName)}Props`;
+	const queryOptionsPropsTypeName = `${capitalize(functionName)}QueryOptionsProps`;
+	const hasRequestBody = method !== "get" && hasMeaningfulRequestBody(operation);
+	const queryParamsPresent = operation.queryParams.length > 0;
+	const typeImportPath = getTypeImportPath(pathItem.cleanPath, method, options);
+	const runtimeImportPath = getRuntimeImportPath(pathItem.cleanPath, options, method);
+	const lines = [
+		"// Auto-generated from OpenAPI spec",
+		`// Path: ${method.toUpperCase()} ${pathItem.path}`,
+		"// DO NOT EDIT - This file is automatically generated",
+		""
+	];
+	lines.push("import type {");
+	lines.push(`  ${typeName}Response,`);
+	if (queryParamsPresent) lines.push(`  ${typeName}Params,`);
+	if (hasRequestBody) lines.push(`  ${typeName}Body,`);
+	lines.push(`} from "${typeImportPath}";`);
+	lines.push("");
+	const routeTargetsImport = options.hasQueryScope ? ", RouteTargets" : "";
+	if (options.httpMode === "singleton") lines.push(`import { httpFetch, Routes${routeTargetsImport}${options.hasQueryScope ? ", getQueryScopeKey, queryOptions" : ""} } from "${runtimeImportPath}";`);
+	else lines.push(`import { Routes${routeTargetsImport}${options.hasQueryScope ? ", getQueryScopeKey, queryOptions" : ""} } from "${runtimeImportPath}";`);
+	const httpFetchTypeImport = options.httpMode === "injected" ? "HTTPFetch, " : "";
+	const queryParamsTypeImport = queryParamsPresent ? "" : ", QueryParams";
+	lines.push(`import type { ${httpFetchTypeImport}HTTPFetchConfig${queryParamsTypeImport}${options.hasQueryScope ? ", QueryScope" : ""} } from "${runtimeImportPath}";`);
+	lines.push("");
+	lines.push(`export interface ${propsTypeName} {`);
+	if (options.httpMode === "injected") lines.push("  http: HTTPFetch;");
+	for (const param of pathParams) lines.push(`  ${param}: ${renderOperationPathParamType(operation, pathParamSchemas, param)};`);
+	if (queryParamsPresent) {
+		const optional = operation.queryParams.some((param) => param.required) ? "" : "?";
+		lines.push(`  params${optional}: ${typeName}Params;`);
+	}
+	if (hasRequestBody) lines.push(`  body: ${typeName}Body;`);
+	const configType = queryParamsPresent ? `Omit<HTTPFetchConfig<${typeName}Params, ${typeName}Response>, "params" | "signal">` : `Omit<HTTPFetchConfig<QueryParams, ${typeName}Response>, "params" | "signal">`;
+	lines.push(`  config?: ${configType};`);
+	lines.push("  signal?: AbortSignal;");
+	lines.push("}");
+	lines.push("");
+	if (method === "get" && options.hasQueryScope) {
+		lines.push(`export interface ${queryOptionsPropsTypeName} extends ${propsTypeName} {`);
+		lines.push("  queryScope: QueryScope;");
+		lines.push("}");
+		lines.push("");
+	}
+	const httpClient = options.httpMode === "singleton" ? "httpFetch" : "props.http";
+	const destructuredProps = [
+		...options.httpMode === "injected" ? ["http"] : [],
+		...pathParams.map((param) => param),
+		...queryParamsPresent ? ["params"] : [],
+		...hasRequestBody ? ["body"] : [],
+		"config",
+		"signal"
+	];
+	lines.push(`export async function ${functionName}(props: ${propsTypeName}): Promise<${typeName}Response> {`);
+	if (destructuredProps.length > 0) {
+		lines.push(`  const { ${destructuredProps.join(", ")} } = props;`);
+		lines.push("");
+	}
+	let routeCall = `Routes.${enumName}`;
+	if (pathParams.length > 0) routeCall = `Routes.${enumName}({ ${pathParams.map((param) => `${param}`).join(", ")} })`;
+	const fetchConfig = queryParamsPresent ? `{ ...config, params, signal }` : "{ ...config, signal }";
+	const getGeneric = queryParamsPresent ? `<${typeName}Response, ${typeName}Params>` : `<${typeName}Response>`;
+	const mutationGeneric = `<${typeName}Response, ${hasRequestBody ? `${typeName}Body` : "undefined"}${queryParamsPresent ? `, ${typeName}Params` : ""}>`;
+	const mutationBody = hasRequestBody ? "body" : "undefined";
+	const mutationConfig = queryParamsPresent ? "{ ...config, params, signal }" : "{ ...config, signal }";
+	switch (method) {
+		case "get":
+			lines.push(`  const { data } = await ${httpClient}.get${getGeneric}(${routeCall}, ${fetchConfig});`);
+			break;
+		case "post":
+			lines.push(`  const { data } = await ${httpClient}.post${mutationGeneric}(${routeCall}, ${mutationBody}, ${mutationConfig});`);
+			break;
+		case "put":
+			lines.push(`  const { data } = await ${httpClient}.put${mutationGeneric}(${routeCall}, ${mutationBody}, ${mutationConfig});`);
+			break;
+		case "patch":
+			lines.push(`  const { data } = await ${httpClient}.patch${mutationGeneric}(${routeCall}, ${mutationBody}, ${mutationConfig});`);
+			break;
+		case "delete": {
+			let deleteConfig = fetchConfig;
+			if (hasRequestBody) deleteConfig = queryParamsPresent ? "{ ...config, data: body, params, signal }" : "{ ...config, data: body, signal }";
+			lines.push(`  const { data } = await ${httpClient}.delete${getGeneric}(${routeCall}, ${deleteConfig});`);
+			break;
+		}
+	}
+	lines.push("  return data;");
+	lines.push("}");
+	if (method === "get" && options.hasQueryScope) {
+		const queryOptionsName = `${functionName}QueryOptions`;
+		lines.push("");
+		lines.push(`export function ${queryOptionsName}(props: ${queryOptionsPropsTypeName}) {`);
+		lines.push(`  const { ${queryParamsPresent ? "params, " : ""}queryScope } = props;`);
+		lines.push("  return queryOptions({");
+		lines.push(`    queryKey: [RouteTargets.${enumName}, ...getQueryScopeKey(queryScope)${pathParams.length > 0 ? `, ${pathParams.map((param) => `props.${param}`).join(", ")}` : ""}${queryParamsPresent ? ", params" : ""}],`);
+		lines.push(`    queryFn: ({ signal }) => ${functionName}({ ...props, signal }).then((data) => data),`);
+		if (pathParams.length > 0) lines.push(`    enabled: [${pathParams.map((param) => `props.${param}`).join(", ")}].every(Boolean),`);
+		lines.push("  });");
+		lines.push("}");
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+function capitalize(value) {
+	return value.charAt(0).toUpperCase() + value.slice(1);
+}
+//#endregion
+//#region src/emitters/runtime/index.ts
+function emitRuntimeFile(options) {
+	const lines = [
+		"// Auto-generated from OpenAPI spec",
+		"// DO NOT EDIT - This file is automatically generated",
+		"",
+		`export type { HTTPFetch, HTTPFetchConfig, QueryParams } from "../../http";`
+	];
+	if (options.httpMode === "singleton") lines.push(`export { httpFetch } from "../../http";`);
+	lines.push(`export { Routes, RouteTargets, buildRoute } from "./routes";`);
+	if (options.hasQueryScope) {
+		lines.push(`export type { QueryScope } from "../../query-scope";`);
+		lines.push(`export { getQueryScopeKey } from "../../query-scope";`);
+		lines.push(`export { queryOptions } from "@tanstack/react-query";`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/emitters/routes/index.ts
+function extractPathParamNames(routePath) {
+	return (routePath.match(/\{([^}]+)\}/g) ?? []).map((match) => match.slice(1, -1));
+}
+function collectRouteEntries(options) {
+	const seen = /* @__PURE__ */ new Set();
+	const entries = [];
+	for (const pathItem of options.paths) {
+		const enumName = pathToEnumName(pathItem.path);
+		if (seen.has(enumName)) continue;
+		seen.add(enumName);
+		entries.push({
+			enumName,
+			pathParamNames: extractPathParamNames(pathItem.path),
+			pathParamSchemas: resolvePathParamSchemas(pathItem),
+			routeValue: pathToRouteValue(pathItem.path, options.stripApiPrefix === true)
+		});
+	}
+	return entries;
+}
+function renderRouteParamsType(entries) {
+	const lines = ["export type RouteParams = {"];
+	for (const entry of entries) {
+		if (entry.pathParamNames.length === 0) {
+			lines.push(`  ${entry.enumName}: undefined;`);
+			continue;
+		}
+		lines.push(`  ${entry.enumName}: {`);
+		for (const param of entry.pathParamNames) lines.push(`    ${param}: ${renderPathParamType(entry.pathParamSchemas, param)};`);
+		lines.push("  };");
+	}
+	lines.push("};", "export type RouteKey = keyof RouteParams;", "");
+	return lines;
+}
+function emitRoutesFile(options) {
+	const entries = collectRouteEntries(options);
+	const lines = [
+		"// Auto-generated from OpenAPI spec",
+		"// DO NOT EDIT - This file is automatically generated",
+		"",
+		"import {",
+		"  buildRouteFromHandlers,",
+		"  createRouteHandlers,",
+		"} from \"@openmirai/typeforge/routes\";",
+		"",
+		...renderRouteParamsType(entries),
+		`export enum ${options.routeEnumName} {`
+	];
+	for (const entry of entries) lines.push(`  ${entry.enumName} = "${entry.routeValue}",`);
+	lines.push("}", "");
+	if (options.routeEnumName !== "RouteTargets") {
+		lines.push(`export { ${options.routeEnumName} as RouteTargets };`);
+		lines.push("");
+	}
+	lines.push(`export const Routes = createRouteHandlers<RouteParams>(${options.routeEnumName});`);
+	lines.push("export const buildRoute = buildRouteFromHandlers<RouteParams>(Routes);", "");
+	return lines.join("\n");
+}
+function mergeRoutesFile(existingContent, newContent, routeEnumName, pathPrefix) {
+	const existingEntries = parseEnumEntries(existingContent, routeEnumName);
+	const newEntries = parseEnumEntries(newContent, routeEnumName);
+	if (pathPrefix !== void 0) {
+		for (const [name, value] of existingEntries.entries()) if (value.startsWith(pathPrefix) && !newEntries.has(name)) existingEntries.delete(name);
+	}
+	return emitRoutesFile({
+		paths: [...new Map([...existingEntries, ...newEntries]).entries()].map(([, value]) => ({
+			cleanPath: value.replace(/:[^/]+/g, (match) => `{${match.slice(1)}}`),
+			operations: [],
+			path: value.includes(":") ? value.replace(/:([^/]+)/g, "{$1}") : value
+		})),
+		routeEnumName,
+		stripApiPrefix: false
+	});
+}
+function parseEnumEntries(content, enumName) {
+	const entries = /* @__PURE__ */ new Map();
+	const enumStart = content.indexOf(`export enum ${enumName} {`);
+	if (enumStart === -1) return entries;
+	const enumBody = content.slice(enumStart);
+	const enumEnd = enumBody.indexOf("}");
+	if (enumEnd === -1) return entries;
+	const enumContent = enumBody.slice(0, enumEnd);
+	const staticRegex = /(\w+)\s*=\s*"([^"]+)"/g;
+	let match;
+	while ((match = staticRegex.exec(enumContent)) !== null) {
+		const name = match[1];
+		const value = match[2];
+		if (name !== void 0 && value !== void 0) entries.set(name, value);
+	}
+	return entries;
+}
+//#endregion
+//#region src/emitters/resolve-schema.ts
+function resolveRef(schema, components) {
+	if (schema.kind !== "ref" || schema.ref === void 0) return schema;
+	const refName = schema.ref.split("/").pop();
+	if (refName === void 0 || components[refName] === void 0) return { kind: "unknown" };
+	return components[refName];
+}
+/**
+* Resolve an object schema through component references and `allOf` composition.
+* The returned object is a new flattened view; component schemas are never mutated.
+*/
+function resolveObjectSchema$1(schema, components, visitedRefs = /* @__PURE__ */ new Set()) {
+	if (schema.kind === "object") return schema;
+	if (schema.kind === "ref") {
+		const refName = refNameFromSchema(schema);
+		if (refName === void 0 || visitedRefs.has(refName)) return;
+		const resolved = components[refName];
+		if (resolved === void 0) return;
+		return resolveObjectSchema$1(resolved, components, /* @__PURE__ */ new Set([...visitedRefs, refName]));
+	}
+	if (schema.kind !== "allOf" || schema.allOf === void 0) return;
+	const properties = {};
+	const required = /* @__PURE__ */ new Set();
+	for (const member of schema.allOf) {
+		const resolved = resolveObjectSchema$1(member, components, visitedRefs);
+		if (resolved?.properties === void 0) return;
+		for (const [name, property] of Object.entries(resolved.properties)) {
+			const existing = properties[name];
+			properties[name] = existing === void 0 ? { ...property } : {
+				required: existing.required || property.required,
+				schema: JSON.stringify(existing.schema) === JSON.stringify(property.schema) ? existing.schema : {
+					allOf: [existing.schema, property.schema],
+					kind: "allOf"
+				}
+			};
+			if (property.required) required.add(name);
+		}
+	}
+	return {
+		kind: "object",
+		properties,
+		required: [...required]
+	};
+}
+function refNameFromSchema(schema) {
+	if (schema.kind !== "ref" || schema.ref === void 0) return;
+	return schema.ref.split("/").pop();
+}
+//#endregion
+//#region src/envelope-guard/index.ts
+function resolveSchema(schema, components) {
+	if (schema.kind === "ref") return resolveRef(schema, components);
+	return schema;
+}
+function extractEnvelopeShape(schema, components) {
+	if (schema === void 0) return;
+	const resolved = resolveObjectSchema$1(schema, components);
+	if (resolved?.properties === void 0) return;
+	const fields = [];
+	for (const [name, property] of Object.entries(resolved.properties)) fields.push({
+		kind: name === "data" ? "generic" : schemaKindLabel(resolveSchema(property.schema, components)),
+		name,
+		required: property.required
+	});
+	fields.sort((a, b) => a.name.localeCompare(b.name));
+	return {
+		fields,
+		schema: resolved
+	};
+}
+function fingerprint(shape) {
+	return JSON.stringify(shape.fields.map((field) => ({
+		kind: field.kind,
+		name: field.name,
+		required: field.required
+	})));
+}
+function matchesEnvelopeShape(schema, components, expected) {
+	const actual = extractEnvelopeShape(schema, components);
+	return actual !== void 0 && fingerprint(actual) === fingerprint(expected);
+}
+const ENVELOPE_METADATA_FIELDS = /* @__PURE__ */ new Set([
+	"error",
+	"message",
+	"requestId",
+	"success",
+	"timestamp"
+]);
+function looksLikeEnvelope(shape) {
+	const names = new Set(shape.fields.map((field) => field.name));
+	if (names.has("data")) return true;
+	if (!names.has("success")) return false;
+	return [...names].every((name) => ENVELOPE_METADATA_FIELDS.has(name));
+}
+function isEnvelopeSchema(schema, components) {
+	const shape = extractEnvelopeShape(schema, components);
+	return shape !== void 0 && looksLikeEnvelope(shape);
+}
+function collectOperationEnvelopes(source) {
+	const envelopes = [];
+	for (const pathItem of source.paths) for (const operation of pathItem.operations) {
+		const success = operation.responses.find((response) => isSuccessStatusCode(response.statusCode) && response.schema !== void 0);
+		if (success?.schema === void 0) continue;
+		const shape = extractEnvelopeShape(success.schema, source.components.schemas);
+		if (shape === void 0) continue;
+		envelopes.push({
+			method: operation.method.toUpperCase(),
+			path: pathItem.path,
+			shape
+		});
+	}
+	return envelopes;
+}
+function analyzeEnvelope(source) {
+	const operations = collectOperationEnvelopes(source);
+	const groups = /* @__PURE__ */ new Map();
+	for (const operation of operations) {
+		const key = fingerprint(operation.shape);
+		const existing = groups.get(key) ?? [];
+		existing.push(operation);
+		groups.set(key, existing);
+	}
+	if (operations.length === 0) return {
+		groups,
+		mode: "raw",
+		operations
+	};
+	if (groups.size === 1) {
+		const shared = operations[0]?.shape;
+		if (shared !== void 0 && looksLikeEnvelope(shared)) return {
+			groups,
+			mode: "shared",
+			operations,
+			shared
+		};
+		return {
+			groups,
+			mode: "raw",
+			operations
+		};
+	}
+	const envelopeGroups = [...groups.entries()].filter(([, items]) => {
+		const first = items[0];
+		return first !== void 0 && looksLikeEnvelope(first.shape);
+	});
+	if (envelopeGroups.length === 0) return {
+		groups,
+		mode: "raw",
+		operations
+	};
+	if (envelopeGroups.length === 1) {
+		const group = envelopeGroups[0];
+		const firstOperation = group?.[1][0];
+		if (group !== void 0 && group[1].length === operations.length && firstOperation !== void 0) return {
+			groups,
+			mode: "shared",
+			operations,
+			shared: firstOperation.shape
+		};
+	}
+	return {
+		groups,
+		mode: "mixed",
+		operations
+	};
+}
+/** Largest envelope group that includes a `data` field; used for mixed-mode base.ts. */
+function getPrimaryEnvelopeShape(analysis) {
+	if (analysis.shared !== void 0) return analysis.shared;
+	if (analysis.mode !== "mixed") return;
+	let best;
+	let bestCount = 0;
+	for (const items of analysis.groups.values()) {
+		const first = items[0];
+		if (first === void 0 || !looksLikeEnvelope(first.shape)) continue;
+		if (!first.shape.fields.some((field) => field.name === "data")) continue;
+		if (items.length > bestCount) {
+			bestCount = items.length;
+			best = first.shape;
+		}
+	}
+	return best;
+}
+function parseUserBaseResponse(content) {
+	const match = content.match(/export\s+interface\s+BaseResponse\s*<[^>]*>\s*\{([\s\S]*?)\}/);
+	if (match === null) {
+		const plain = content.match(/export\s+interface\s+BaseResponse\s*\{([\s\S]*?)\}/);
+		if (plain === null) return;
+		return parseBaseResponseBody(plain[1]);
+	}
+	return parseBaseResponseBody(match[1]);
+}
+function parseBaseResponseBody(body) {
+	const fields = [];
+	const lineRegex = /^\s*(\w+)(\?)?:\s*([^;]+);/gm;
+	let match;
+	while ((match = lineRegex.exec(body)) !== null) {
+		const [, name, optional, rawType] = match;
+		if (name === void 0 || rawType === void 0) continue;
+		fields.push({
+			kind: rawType.trim().replace(/\s+/g, " "),
+			name,
+			required: optional === void 0
+		});
+	}
+	fields.sort((a, b) => a.name.localeCompare(b.name));
+	return {
+		fields,
+		sourcePath: "models.ts"
+	};
+}
+function diffEnvelopeFields(spec, user) {
+	const diffs = [];
+	const specMap = new Map(spec.fields.filter((field) => field.name !== "data").map((field) => [field.name, field]));
+	const userMap = new Map(user.fields.filter((field) => field.name !== "data" && field.name !== "T").map((field) => [field.name, field]));
+	for (const [name, specField] of specMap.entries()) {
+		const userField = userMap.get(name);
+		if (userField === void 0) {
+			diffs.push({
+				field: name,
+				issue: "missing",
+				spec: specField
+			});
+			continue;
+		}
+		if (specField.required !== userField.required) diffs.push({
+			field: name,
+			issue: "required-changed",
+			spec: specField,
+			user: userField
+		});
+		if (specField.kind !== userField.kind && name !== "data") diffs.push({
+			field: name,
+			issue: "type-changed",
+			spec: specField,
+			user: userField
+		});
+	}
+	for (const [name, userField] of userMap.entries()) if (!specMap.has(name)) diffs.push({
+		field: name,
+		issue: "extra",
+		user: userField
+	});
+	return diffs;
+}
+function formatEnvelopeFieldType(field, property, genericName) {
+	if (property === void 0) return "unknown";
+	if (field.kind === "generic") return genericName;
+	return field.kind;
+}
+function buildBaseResponseInterface(shape, genericName = "T") {
+	const lines = [`export interface BaseResponse<${genericName}> {`];
+	for (const field of shape.fields) {
+		if (field.name === "data") {
+			lines.push(`  data?: ${genericName};`);
+			continue;
+		}
+		const optional = field.required ? "" : "?";
+		const property = shape.schema.properties?.[field.name];
+		const type = formatEnvelopeFieldType(field, property, genericName);
+		lines.push(`  ${field.name}${optional}: ${type};`);
+	}
+	lines.push("}");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/parser/index.ts
+const HTTP_METHODS = [
+	"get",
+	"post",
+	"put",
+	"patch",
+	"delete"
+];
+function readObjectArray(value) {
+	if (!isJsonArray(value)) return [];
+	return value.filter(isJsonObject);
+}
+function extractRefName(ref) {
+	return ref.split("/").at(-1) ?? ref;
+}
+function toCleanPath(pathStr) {
+	return pathStr.replace(/^\//, "").replace(/\{([^}]+)\}/g, "[$1]");
+}
+function parseSchema(raw) {
+	if (!isJsonObject(raw)) return { kind: "unknown" };
+	if (typeof raw["$ref"] === "string") return {
+		kind: "ref",
+		ref: extractRefName(raw["$ref"])
+	};
+	if (isJsonArray(raw["oneOf"]) && raw["oneOf"].length > 0) return {
+		kind: "oneOf",
+		oneOf: raw["oneOf"].map(parseSchema)
+	};
+	if (isJsonArray(raw["anyOf"]) && raw["anyOf"].length > 0) return {
+		anyOf: raw["anyOf"].map(parseSchema),
+		kind: "anyOf"
+	};
+	if (isJsonArray(raw["allOf"]) && raw["allOf"].length > 0) return {
+		allOf: raw["allOf"].map(parseSchema),
+		kind: "allOf"
+	};
+	const rawType = typeof raw["type"] === "string" ? raw["type"] : void 0, nullable = raw["nullable"] === true;
+	if (rawType === "array") {
+		const schema = { kind: "array" };
+		if (raw["items"] !== void 0) schema.items = parseSchema(raw["items"]);
+		if (nullable) schema.nullable = true;
+		return schema;
+	}
+	if (rawType === "object" || rawType === void 0 && (isJsonObject(raw["properties"]) || raw["additionalProperties"] !== void 0)) return buildObjectSchema(raw, nullable);
+	if (rawType === "integer" || rawType === "number") {
+		const schema = { kind: "number" };
+		if (typeof raw["format"] === "string") schema.format = raw["format"];
+		if (nullable) schema.nullable = true;
+		if (Array.isArray(raw["enum"])) schema.enum = readJsonPrimitives(raw["enum"]);
+		if (typeof raw["x-map-key-ref"] === "string") schema["x-map-key-ref"] = raw["x-map-key-ref"];
+		return schema;
+	}
+	if (rawType === "string") {
+		const schema = { kind: "string" };
+		if (typeof raw["format"] === "string") schema.format = raw["format"];
+		if (nullable) schema.nullable = true;
+		if (Array.isArray(raw["enum"])) schema.enum = readJsonPrimitives(raw["enum"]);
+		if (typeof raw["x-map-key-ref"] === "string") schema["x-map-key-ref"] = raw["x-map-key-ref"];
+		return schema;
+	}
+	if (rawType === "boolean") {
+		const schema = { kind: "boolean" };
+		if (nullable) schema.nullable = true;
+		return schema;
+	}
+	if (rawType === "null") return { kind: "null" };
+	return { kind: "unknown" };
+}
+function buildObjectSchema(raw, nullable) {
+	const schema = { kind: "object" };
+	if (nullable) schema.nullable = true;
+	if (isJsonObject(raw["properties"])) {
+		const requiredList = isJsonArray(raw["required"]) ? raw["required"].filter((entry) => typeof entry === "string") : [], properties = {};
+		for (const [key, propRaw] of Object.entries(raw["properties"])) properties[key] = {
+			required: requiredList.includes(key),
+			schema: parseSchema(propRaw)
+		};
+		schema.properties = properties;
+		if (requiredList.length > 0) schema.required = requiredList;
+	}
+	if (raw["additionalProperties"] !== void 0) {
+		if (typeof raw["additionalProperties"] === "boolean") schema.additionalProperties = raw["additionalProperties"];
+		else schema.additionalProperties = parseSchema(raw["additionalProperties"]);
+	}
+	if (typeof raw["x-map-key-ref"] === "string") schema["x-map-key-ref"] = raw["x-map-key-ref"];
+	return schema;
+}
+/**
+* Convert a Swagger 2 parameter's inline type attributes to an IRSchema.
+* Swagger 2 parameters carry `type`, `format`, `enum` directly (no `schema` sub-object
+* unless `in: body`).
+*/
+function swaggerParamToSchema(param) {
+	if (isJsonObject(param["schema"])) return parseSchema(param["schema"]);
+	const paramSchema = {};
+	if (param["enum"] !== void 0) paramSchema.enum = param["enum"];
+	if (typeof param["format"] === "string") paramSchema.format = param["format"];
+	if (typeof param["type"] === "string") paramSchema.type = param["type"];
+	return parseSchema(paramSchema);
+}
+function parseSwagger2(raw, opts) {
+	const schemas = {}, definitions = isJsonObject(raw["definitions"]) ? raw["definitions"] : {};
+	for (const [name, def] of Object.entries(definitions)) schemas[name] = parseSchema(def);
+	const paths = parsePaths(raw, "swagger2", opts);
+	return {
+		components: { schemas },
+		key: "",
+		paths
+	};
+}
+function parseOpenAPI3(raw, opts) {
+	const schemas = {}, components = isJsonObject(raw["components"]) ? raw["components"] : {}, compSchemas = isJsonObject(components["schemas"]) ? components["schemas"] : {};
+	for (const [name, def] of Object.entries(compSchemas)) schemas[name] = parseSchema(def);
+	const paths = parsePaths(raw, "openapi3", opts);
+	return {
+		components: { schemas },
+		key: "",
+		paths
+	};
+}
+function parsePaths(raw, version, opts) {
+	const result = [], rawPaths = raw["paths"];
+	if (!isJsonObject(rawPaths)) return result;
+	for (const [pathStr, pathItemRaw] of Object.entries(rawPaths)) {
+		if (opts.pathPrefix !== void 0 && !pathStr.startsWith(opts.pathPrefix)) continue;
+		if (opts.ignorePaths?.includes(pathStr)) continue;
+		if (!isJsonObject(pathItemRaw)) continue;
+		const pathLevelParams = readObjectArray(pathItemRaw["parameters"]), operations = [];
+		for (const method of HTTP_METHODS) {
+			const opRaw = pathItemRaw[method];
+			if (!isJsonObject(opRaw)) continue;
+			const op = parseOperation(method, opRaw, pathLevelParams, version);
+			operations.push(op);
+		}
+		if (operations.length > 0) result.push({
+			cleanPath: toCleanPath(pathStr),
+			operations,
+			path: pathStr
+		});
+	}
+	return result;
+}
+function mergeParams(pathLevel, opLevel) {
+	const map = /* @__PURE__ */ new Map();
+	for (const p of pathLevel) if (typeof p["name"] === "string") map.set(p["name"], p);
+	for (const p of opLevel) if (typeof p["name"] === "string") map.set(p["name"], p);
+	return [...map.values()];
+}
+function resolveOpenAPI3ParamSchema(param) {
+	if (isJsonObject(param["schema"])) return parseSchema(param["schema"]);
+	return { kind: "unknown" };
+}
+function resolveParamSchema(param, version) {
+	if (version === "openapi3") return resolveOpenAPI3ParamSchema(param);
+	return swaggerParamToSchema(param);
+}
+function parseOperation(method, opRaw, pathLevelParams, version) {
+	const params = mergeParams(pathLevelParams, readObjectArray(opRaw["parameters"])), pathParams = [], queryParams = [];
+	for (const param of params) {
+		if (typeof param["name"] !== "string") continue;
+		if (param["in"] === "path") pathParams.push({
+			name: param["name"],
+			schema: resolveParamSchema(param, version)
+		});
+		else if (param["in"] === "query") queryParams.push({
+			name: param["name"],
+			required: param["required"] === true,
+			schema: resolveParamSchema(param, version)
+		});
+	}
+	const requestBody = version === "swagger2" ? parseSwagger2Body(params) : parseOpenAPI3Body(opRaw), operation = {
+		method,
+		pathParams,
+		queryParams,
+		responses: parseResponses(opRaw, version)
+	};
+	if (typeof opRaw["operationId"] === "string") operation.operationId = opRaw["operationId"];
+	if (requestBody !== void 0) operation.requestBody = requestBody;
+	return operation;
+}
+function parseSwagger2Body(params) {
+	const bodyParam = params.find((p) => p["in"] === "body");
+	if (bodyParam === void 0) return;
+	const schema = isJsonObject(bodyParam["schema"]) ? parseSchema(bodyParam["schema"]) : { kind: "unknown" };
+	return {
+		required: bodyParam["required"] === true,
+		schema
+	};
+}
+function parseOpenAPI3Body(opRaw) {
+	if (!isJsonObject(opRaw["requestBody"])) return;
+	const reqBodyRaw = opRaw["requestBody"], content = isJsonObject(reqBodyRaw["content"]) ? reqBodyRaw["content"] : {}, jsonContent = isJsonObject(content["application/json"]) ? content["application/json"] : {}, schema = isJsonObject(jsonContent["schema"]) ? parseSchema(jsonContent["schema"]) : { kind: "unknown" };
+	return {
+		required: reqBodyRaw["required"] === true,
+		schema
+	};
+}
+function parseResponses(opRaw, version) {
+	const result = [];
+	if (!isJsonObject(opRaw["responses"])) return result;
+	for (const [statusCode, respRaw] of Object.entries(opRaw["responses"])) {
+		if (!isJsonObject(respRaw)) {
+			result.push({ statusCode });
+			continue;
+		}
+		const irResp = { statusCode };
+		if (version === "swagger2") {
+			if (isJsonObject(respRaw["schema"])) irResp.schema = parseSchema(respRaw["schema"]);
+		} else {
+			const content = isJsonObject(respRaw["content"]) ? respRaw["content"] : {}, jsonContent = isJsonObject(content["application/json"]) ? content["application/json"] : {};
+			if (isJsonObject(jsonContent["schema"])) irResp.schema = parseSchema(jsonContent["schema"]);
+		}
+		result.push(irResp);
+	}
+	return result;
+}
+function parseSpec(raw, opts) {
+	if (!isJsonObject(raw)) return {
+		components: { schemas: {} },
+		key: "",
+		paths: []
+	};
+	const parseOpts = {};
+	if (opts.pathPrefix !== void 0) parseOpts.pathPrefix = opts.pathPrefix;
+	if (opts.ignorePaths !== void 0) parseOpts.ignorePaths = opts.ignorePaths;
+	if (raw["swagger"] === "2.0") return parseSwagger2(raw, parseOpts);
+	if (typeof raw["openapi"] === "string" && raw["openapi"].startsWith("3.")) return parseOpenAPI3(raw, parseOpts);
+	return {
+		components: { schemas: {} },
+		key: "",
+		paths: []
+	};
+}
+//#endregion
+//#region src/color/index.ts
+function isColorEnabled() {
+	if (process.env["NO_COLOR"] !== void 0) return false;
+	return process.stdout.isTTY === true;
+}
+function paint(formatter, text) {
+	return isColorEnabled() ? formatter(text) : text;
+}
+function bold(text) {
+	return paint(chalk.bold, text);
+}
+function red(text) {
+	return paint(chalk.red, text);
+}
+function dim(text) {
+	return paint(chalk.dim, text);
+}
+function cyan(text) {
+	return paint(chalk.cyan, text);
+}
+function yellow(text) {
+	return paint(chalk.yellow, text);
+}
+function white(text) {
+	return paint(chalk.white, text);
+}
+//#endregion
+//#region src/emitters/recursive-ref-error.ts
+var RecursiveRefError = class extends Error {
+	cycle;
+	schemaPath;
+	sourceKey;
+	constructor(sourceKey, cycle, schemaPath) {
+		super(formatRecursiveRefError(sourceKey, cycle, schemaPath));
+		this.name = "RecursiveRefError";
+		this.cycle = cycle;
+		this.schemaPath = schemaPath;
+		this.sourceKey = sourceKey;
+	}
+};
+function formatRecursiveRefError(sourceKey, cycle, schemaPath) {
+	return [
+		bold(red(`typeforge: recursive schema reference in source "${sourceKey}"`)),
+		"",
+		bold("Cycle:"),
+		`  ${cycle.join(" → ")}`,
+		"",
+		bold("At:"),
+		dim(`  ${schemaPath}`),
+		"",
+		bold("Fix:"),
+		"  • Add a known-type override in known-types.ts for this shape, or",
+		"  • Simplify the OpenAPI schema to remove the circular reference",
+		cyan(`  • typeforge generate --source ${sourceKey} --spec <path>`)
+	].join("\n");
+}
+//#endregion
+//#region src/plugins/known-types/matchers.ts
+function resolveObjectSchema(schema, components) {
+	const resolved = schema.kind === "ref" ? resolveRef(schema, components) : schema;
+	return resolved.kind === "object" ? resolved : void 0;
+}
+function sortedStrings(values) {
+	return values.slice().toSorted((left, right) => left.localeCompare(right));
+}
+function matchesExactProperties(schema, components, exactProperties) {
+	const objectSchema = resolveObjectSchema(schema, components);
+	if (objectSchema?.properties === void 0) return false;
+	const keys = sortedStrings(Object.keys(objectSchema.properties));
+	const expected = sortedStrings(exactProperties);
+	return keys.length === expected.length && keys.every((key, index) => key === expected[index]);
+}
+function matchesDeclarativeRule(schema, components, rule) {
+	const objectSchema = resolveObjectSchema(schema, components);
+	if (objectSchema?.properties === void 0) return false;
+	const keys = Object.keys(objectSchema.properties);
+	if (rule.maxPropertyCount !== void 0 && keys.length > rule.maxPropertyCount) return false;
+	if (rule.exactProperties !== void 0 && !matchesExactProperties(schema, components, rule.exactProperties)) return false;
+	if (rule.requireProperties !== void 0) {
+		for (const required of rule.requireProperties) if (!(required in objectSchema.properties)) return false;
+	}
+	if (rule.excludeProperties !== void 0) {
+		for (const excluded of rule.excludeProperties) if (excluded in objectSchema.properties) return false;
+	}
+	return rule.exactProperties !== void 0 || rule.requireProperties !== void 0;
+}
+//#endregion
+//#region src/plugins/known-types/load.ts
+function parseStringArray(block) {
+	if (block === void 0) return;
+	const values = [...block.matchAll(/["'`]([^"'`]+)["'`]/g)].map((match) => match[1]);
+	return values.length > 0 ? values : void 0;
+}
+function parseDeclarativeRules(content) {
+	const rules = [];
+	const objectBlocks = content.matchAll(/\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g);
+	for (const block of objectBlocks) {
+		const body = block[1];
+		if (body === void 0 || !body.includes("typeName")) continue;
+		const name = body.match(/name:\s*["'`]([^"'`]+)["'`]/)?.[1];
+		const typeName = body.match(/typeName:\s*["'`]([^"'`]+)["'`]/)?.[1];
+		if (name === void 0 || typeName === void 0) continue;
+		const rule = {
+			name,
+			typeName
+		};
+		const importPath = body.match(/importPath:\s*(null|["'`]([^"'`]*)["'`])/)?.[2];
+		if (body.includes("importPath: null")) rule.importPath = null;
+		else if (importPath !== void 0) rule.importPath = importPath;
+		const exactProperties = parseStringArray(body.match(/exactProperties:\s*\[([\s\S]*?)\]/)?.[1]);
+		if (exactProperties !== void 0) rule.exactProperties = exactProperties;
+		const requireProperties = parseStringArray(body.match(/requireProperties:\s*\[([\s\S]*?)\]/)?.[1]);
+		if (requireProperties !== void 0) rule.requireProperties = requireProperties;
+		const excludeProperties = parseStringArray(body.match(/excludeProperties:\s*\[([\s\S]*?)\]/)?.[1]);
+		if (excludeProperties !== void 0) rule.excludeProperties = excludeProperties;
+		const maxPropertyCount = body.match(/maxPropertyCount:\s*(\d+)/)?.[1];
+		if (maxPropertyCount !== void 0) rule.maxPropertyCount = Number.parseInt(maxPropertyCount, 10);
+		rules.push(rule);
+	}
+	return rules;
+}
+function loadUserKnownTypes(cwd, apiRoot) {
+	const knownTypesPath = resolve(cwd, apiRoot, "known-types.ts");
+	if (!existsSync(knownTypesPath)) return [];
+	return parseDeclarativeRules(readFileSync(knownTypesPath, "utf8")).map((rule) => ({
+		importPath: rule.importPath ?? null,
+		matcher: (schema, components) => matchesDeclarativeRule(schema, components, rule),
+		name: rule.name,
+		typeName: rule.typeName
+	}));
+}
+//#endregion
+//#region src/plugins/known-types/index.ts
+function loadKnownTypeRules(cwd, apiRoot) {
+	return loadUserKnownTypes(cwd, apiRoot);
+}
+function matchKnownType(schema, components, rules) {
+	for (const rule of rules) if (rule.matcher(schema, components)) return {
+		importPath: rule.importPath,
+		rule,
+		typeName: rule.typeName
+	};
+}
+//#endregion
+//#region src/emitters/schema-renderer.ts
+const DEFAULT_MAX_DEPTH = 50;
+function indent(level) {
+	return "  ".repeat(level);
+}
+function formatEnumLiteral(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (value === null) return "null";
+	return "unknown";
+}
+function formatEnumUnion(enumValues) {
+	return [...new Set(enumValues.map(formatEnumLiteral))].join(" | ");
+}
+function withNullable(type, schema) {
+	if (schema.nullable === true) return `${type} | null`;
+	return type;
+}
+function decodeJsonPointerSegment(segment) {
+	return decodeURIComponent(segment.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function readJsonPointerValue(value, segment) {
+	if (Array.isArray(value)) {
+		const index = Number(segment);
+		if (!Number.isInteger(index) || index < 0 || index >= value.length) return;
+		return value[index];
+	}
+	if (isJsonObject(value) && segment in value) return value[segment];
+}
+function resolveOpenApiPointer(spec, pointer) {
+	if (!pointer.startsWith("#/")) return;
+	let value = spec;
+	for (const part of pointer.slice(2).split("/").map(decodeJsonPointerSegment)) {
+		value = value === void 0 ? void 0 : readJsonPointerValue(value, part);
+		if (value === void 0) return;
+	}
+	return parseSchema(value);
+}
+function getMapKeyType(schema, ctx) {
+	const keyRef = schema["x-map-key-ref"];
+	if (keyRef === void 0) return "string";
+	if (ctx.rawSpec !== void 0) {
+		const referenced = resolveOpenApiPointer(ctx.rawSpec, keyRef);
+		if (referenced !== void 0) return renderSchemaType(referenced, {
+			...ctx,
+			depth: (ctx.depth ?? 0) + 1
+		});
+	}
+	const refName = keyRef.split("/").pop();
+	if (refName !== void 0 && ctx.components[refName] !== void 0) return renderSchemaType(ctx.components[refName], {
+		...ctx,
+		depth: (ctx.depth ?? 0) + 1
+	});
+	return "string";
+}
+function throwRecursiveError(ctx, refName) {
+	const cycle = [...ctx.refStack ?? [], refName];
+	throw new RecursiveRefError(ctx.sourceKey ?? "unknown", cycle, ctx.schemaPath ?? refName);
+}
+function childContext(ctx, segment) {
+	const basePath = ctx.schemaPath ?? "schema";
+	return {
+		...ctx,
+		schemaPath: `${basePath}.${segment}`
+	};
+}
+function renderSchemaType(schema, ctx) {
+	const depth = ctx.depth ?? 0;
+	const maxDepth = ctx.maxDepth ?? DEFAULT_MAX_DEPTH;
+	if (depth > maxDepth) throw new RecursiveRefError(ctx.sourceKey ?? "unknown", ctx.refStack ?? [], `${ctx.schemaPath ?? "schema"} (max depth ${maxDepth} exceeded)`);
+	const nextCtx = {
+		...ctx,
+		depth: depth + 1
+	};
+	const knownRules = ctx.knownTypes ?? [];
+	if (knownRules.length > 0) {
+		const known = matchKnownType(schema, ctx.components, knownRules);
+		if (known !== void 0) {
+			if (ctx.knownTypeImports !== void 0 && !ctx.knownTypeImports.has(known.typeName)) ctx.knownTypeImports.set(known.typeName, known.importPath);
+			return withNullable(known.typeName, schema);
+		}
+	}
+	if (schema.enum !== void 0 && schema.enum.length > 0) return withNullable(formatEnumUnion(schema.enum), schema);
+	if (schema.kind === "ref") {
+		const refName = refNameFromSchema(schema);
+		if (refName === void 0) return "unknown";
+		const visited = ctx.visitedRefs ?? /* @__PURE__ */ new Set();
+		const refStack = ctx.refStack ?? [];
+		if (visited.has(refName)) throwRecursiveError(ctx, refName);
+		return renderSchemaType(resolveRef(schema, ctx.components), {
+			...nextCtx,
+			refStack: [...refStack, refName],
+			visitedRefs: /* @__PURE__ */ new Set([...visited, refName])
+		});
+	}
+	switch (schema.kind) {
+		case "string": return withNullable("string", schema);
+		case "number": return withNullable("number", schema);
+		case "boolean": return withNullable("boolean", schema);
+		case "null": return "null";
+		case "unknown": return "unknown";
+		case "array": {
+			const itemType = schema.items === void 0 ? "unknown" : renderSchemaType(schema.items, childContext(nextCtx, "[]"));
+			if (itemType === "TiptapDocument") return withNullable("TiptapDocument", schema);
+			return withNullable(`${itemType.includes(" | ") ? `(${itemType})` : itemType}[]`, schema);
+		}
+		case "object": {
+			if (schema.properties === void 0) {
+				if (schema.additionalProperties === true) return withNullable("Record<string, unknown>", schema);
+				if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null) return withNullable(`Record<${ctx.resolveMapKeyRefs !== false && schema["x-map-key-ref"] !== void 0 ? getMapKeyType(schema, ctx) : "string"}, ${renderSchemaType(schema.additionalProperties, childContext(nextCtx, "value"))}>`, schema);
+				return withNullable("Record<string, unknown>", schema);
+			}
+			const lines = ["{"];
+			for (const [name, property] of Object.entries(schema.properties)) {
+				const optional = property.required ? "" : "?";
+				const type = renderSchemaType(property.schema, childContext(nextCtx, name));
+				lines.push(`${indent(depth + 1)}${name}${optional}: ${type};`);
+			}
+			lines.push(`${indent(depth)}}`);
+			return withNullable(lines.join("\n"), schema);
+		}
+		case "oneOf":
+		case "anyOf": {
+			const variants = schema[schema.kind];
+			if (variants === void 0 || variants.length === 0) return "unknown";
+			const renderedVariants = variants.map((variant) => renderSchemaType(variant, nextCtx));
+			const specificVariants = renderedVariants.filter((variant) => variant !== "Record<string, unknown>");
+			return withNullable((specificVariants.length > 0 ? specificVariants : renderedVariants).join(" | "), schema);
+		}
+		case "allOf": {
+			const parts = schema.allOf;
+			if (parts === void 0 || parts.length === 0) return "unknown";
+			return withNullable(parts.map((part) => renderSchemaType(part, nextCtx)).join(" & "), schema);
+		}
+		default: return "unknown";
+	}
+}
+//#endregion
+//#region src/emitters/types/index.ts
+function createRenderContext(options, schemaPath, knownTypeImports) {
+	const ctx = {
+		components: options.source.components.schemas,
+		knownTypeImports,
+		knownTypes: options.knownTypes ?? [],
+		maxDepth: options.maxRenderDepth ?? 50,
+		resolveMapKeyRefs: options.resolveMapKeyRefs !== false,
+		schemaPath
+	};
+	if (options.sourceKey !== void 0) ctx.sourceKey = options.sourceKey;
+	if (options.rawSpec !== void 0) ctx.rawSpec = options.rawSpec;
+	return ctx;
+}
+function formatImportLines(knownTypeImports) {
+	const lines = [];
+	const byPath = /* @__PURE__ */ new Map();
+	for (const [typeName, importPath] of knownTypeImports.entries()) {
+		const existing = byPath.get(importPath) ?? [];
+		existing.push(typeName);
+		byPath.set(importPath, existing);
+	}
+	for (const [importPath, typeNames] of byPath.entries()) {
+		if (importPath === null) continue;
+		lines.push(`import type { ${typeNames.join(", ")} } from "${importPath}";`);
+	}
+	return lines;
+}
+function renderParamsInterface(typeName, operation, options, knownTypeImports) {
+	if (operation.queryParams.length === 0) return;
+	const queryExtends = options.queryExtends;
+	const pageName = queryExtends?.page ?? "page";
+	const limitName = queryExtends?.limit ?? "limit";
+	const sortByName = queryExtends?.sortBy ?? "sortBy";
+	const sortOrderName = queryExtends?.sortOrder ?? "sortOrder";
+	const hasPage = operation.queryParams.some((param) => param.name === pageName);
+	const hasLimit = operation.queryParams.some((param) => param.name === limitName);
+	const sortByParam = operation.queryParams.find((param) => param.name === sortByName);
+	const hasSortOrder = operation.queryParams.some((param) => param.name === sortOrderName);
+	const hasOffsetLimitQuery = hasPage && hasLimit;
+	const hasSortParams = sortByParam !== void 0 && hasSortOrder;
+	const commonParamNames = new Set([
+		hasOffsetLimitQuery ? pageName : void 0,
+		hasOffsetLimitQuery ? limitName : void 0,
+		hasSortParams ? sortByName : void 0,
+		hasSortParams ? sortOrderName : void 0
+	].filter((name) => name !== void 0));
+	const nonCommonParams = operation.queryParams.filter((param) => !commonParamNames.has(param.name));
+	const extendsParts = [];
+	if (hasSortParams && sortByParam !== void 0 && sortByParam.schema.enum !== void 0 && sortByParam.schema.enum.length > 0 && queryExtends?.sortTypeName !== void 0) {
+		const sortOptions = [...new Set(sortByParam.schema.enum.map((value) => JSON.stringify(value)))].join(" | ");
+		extendsParts.push(`${queryExtends.sortTypeName}<${sortOptions}>`);
+		if (queryExtends.sortImportPath !== void 0) knownTypeImports.set(queryExtends.sortTypeName, queryExtends.sortImportPath);
+	}
+	if (hasOffsetLimitQuery && queryExtends?.paginationTypeName !== void 0) {
+		extendsParts.push(queryExtends.paginationTypeName);
+		if (queryExtends.paginationImportPath !== void 0) knownTypeImports.set(queryExtends.paginationTypeName, queryExtends.paginationImportPath);
+	}
+	if (extendsParts.length > 0 && nonCommonParams.length === 0) return `export type ${typeName}Params = ${extendsParts.join(" & ")};`;
+	const lines = [];
+	if (extendsParts.length > 0) lines.push(`export interface ${typeName}Params extends ${extendsParts.join(", ")} {`);
+	else lines.push(`export interface ${typeName}Params {`);
+	for (const param of nonCommonParams) appendQueryParam(param, lines, options, knownTypeImports, typeName);
+	lines.push("}");
+	return lines.join("\n");
+}
+function appendQueryParam(param, lines, options, knownTypeImports, typeName) {
+	const optional = param.required ? "" : "?";
+	const type = renderSchemaType(param.schema, createRenderContext(options, `${typeName}Params.${param.name}`, knownTypeImports));
+	lines.push(`  ${param.name}${optional}: ${type};`);
+}
+function renderBodyInterface(typeName, operation, options, knownTypeImports) {
+	if (!hasMeaningfulRequestBody(operation) || operation.requestBody === void 0) return;
+	const bodyType = renderSchemaType(operation.requestBody.schema, createRenderContext(options, `${typeName}Body`, knownTypeImports));
+	if (bodyType.startsWith("{")) return `export interface ${typeName}Body ${bodyType}`;
+	return `export type ${typeName}Body = ${bodyType};`;
+}
+function resolveSuccessResponseSchema(schema, components) {
+	return resolveObjectSchema$1(schema, components) ?? schema;
+}
+function renderResponseType(typeName, operation, options, _envelopeMode, knownTypeImports, baseImportPath) {
+	const schema = getSuccessResponseSchema(operation);
+	if (schema === void 0) return `export type ${typeName}Response = unknown;`;
+	const resolved = resolveSuccessResponseSchema(schema, options.source.components.schemas);
+	const dataSchema = resolved.kind === "object" && resolved.properties?.data !== void 0 ? resolved.properties.data.schema : void 0;
+	const isSuccessEnvelope = resolved.kind === "object" && resolved.properties?.success !== void 0 && isEnvelopeSchema(schema, options.source.components.schemas);
+	if (options.unwrapResponseData === true && isSuccessEnvelope) {
+		if (dataSchema === void 0) return `export type ${typeName}Response = null;`;
+		return `export type ${typeName}Response = ${renderSchemaType(dataSchema, createRenderContext(options, `${typeName}Response.data`, knownTypeImports))};`;
+	}
+	if (dataSchema !== void 0) {
+		if (!(_envelopeMode === "shared" || _envelopeMode === "mixed" && options.sharedEnvelope !== void 0 && matchesEnvelopeShape(schema, options.source.components.schemas, options.sharedEnvelope))) return `export type ${typeName}Response = ${renderSchemaType(schema, createRenderContext(options, `${typeName}Response`, knownTypeImports))};`;
+		return `export type ${typeName}Response = import("${baseImportPath}").BaseResponse<${renderSchemaType(dataSchema, createRenderContext(options, `${typeName}Response.data`, knownTypeImports))}> & Omit<${renderSchemaType(schema, createRenderContext(options, `${typeName}Response`, knownTypeImports))}, "data">;`;
+	}
+	return `export type ${typeName}Response = ${renderSchemaType(schema, createRenderContext(options, `${typeName}Response`, knownTypeImports))};`;
+}
+function emitTypeFiles(options) {
+	const files = [];
+	for (const pathItem of options.source.paths) for (const operation of pathItem.operations) {
+		const typeName = getFunctionTypeName(pathItem.cleanPath, operation.method);
+		const knownTypeImports = /* @__PURE__ */ new Map();
+		const blocks = [
+			"// Auto-generated from OpenAPI spec",
+			`// Path: ${operation.method.toUpperCase()} ${pathItem.path}`,
+			"// DO NOT EDIT - This file is automatically generated",
+			""
+		];
+		const paramsBlock = renderParamsInterface(typeName, operation, options, knownTypeImports);
+		if (paramsBlock !== void 0) blocks.push(paramsBlock, "");
+		const bodyBlock = renderBodyInterface(typeName, operation, options, knownTypeImports);
+		if (bodyBlock !== void 0) blocks.push(bodyBlock, "");
+		const baseImportPath = resolveAliasAwareImport({
+			fromAbsolutePath: `${options.typesDir}/${pathItem.cleanPath}/${operation.method.toUpperCase()}.d.ts`,
+			toAbsolutePath: options.baseFile.replace(/\.d\.ts$/, "").replace(/\.ts$/, ""),
+			...options.tsconfigPaths === void 0 ? {} : { tsconfigPaths: options.tsconfigPaths }
+		});
+		blocks.push(renderResponseType(typeName, operation, options, options.envelopeMode, knownTypeImports, baseImportPath));
+		const importLines = formatImportLines(knownTypeImports);
+		const content = [
+			...importLines,
+			...importLines.length > 0 ? [""] : [],
+			...blocks
+		].join("\n").trimEnd();
+		files.push({
+			content: `${content}\n`,
+			relativePath: `${pathItem.cleanPath}/${operation.method.toUpperCase()}.d.ts`
+		});
+	}
+	return files;
+}
+function emitBaseFile(sharedEnvelope) {
+	return [
+		"// Auto-generated from OpenAPI spec",
+		"// DO NOT EDIT - This file is automatically generated",
+		"",
+		buildBaseResponseInterface(sharedEnvelope),
+		""
+	].join("\n");
+}
+//#endregion
+//#region src/envelope-guard/diagnostic.ts
+function formatDriftError(sourceKey, spec, userSource, userBlock, diffs, outliers = []) {
+	const lines = [bold(red(`typeforge: base response mismatch in source "${sourceKey}"`)), ""];
+	lines.push(bold("Spec envelope:"));
+	for (const field of spec.fields) lines.push(`  ${field.name}${field.required ? "" : "?"}: ${field.kind}`);
+	lines.push("");
+	lines.push(bold(`Your ${userSource} BaseResponse:`));
+	lines.push(userBlock);
+	lines.push("");
+	lines.push(bold("Conflicts:"));
+	for (const diff of diffs) if (diff.issue === "missing") lines.push(yellow(`  • ${diff.field}: present in spec, missing in your type`));
+	else if (diff.issue === "extra") lines.push(yellow(`  • ${diff.field}: extra field in your type`));
+	else if (diff.issue === "type-changed") lines.push(yellow(`  • ${diff.field}: spec is ${diff.spec?.kind}, your type is ${diff.user?.kind}`));
+	else lines.push(yellow(`  • ${diff.field}: required/optional mismatch`));
+	if (outliers.length > 0) {
+		lines.push("");
+		lines.push(dim("Also not matching the spec envelope:"));
+		for (const outlier of outliers.slice(0, 3)) lines.push(dim(`  ${outlier.method} ${outlier.path}`));
+	}
+	lines.push("");
+	lines.push(bold("Fix:"));
+	lines.push("  • Update models.ts to match the spec, or");
+	lines.push(cyan(`  • typeforge generate --source ${sourceKey} --spec <path> --accept-base`));
+	return lines.join("\n");
+}
+//#endregion
+//#region src/color/diagnostic.ts
+function formatCaretLine(column, highlightStart, highlightEnd, label) {
+	const caret = `${" ".repeat(column + 1)}:${`${" ".repeat(Math.max(highlightEnd - highlightStart, 1))}|`}`;
+	if (label === void 0) return caret;
+	return `${caret}\n${" ".repeat(column + highlightEnd + 3)}\`${dim(`-- ${label}`)}`;
+}
+function formatSnippet(snippet) {
+	return [
+		dim(`    ,-[${snippet.file}:${snippet.line}:${snippet.column}]`),
+		white(`${String(snippet.line).padStart(4, " ")} | ${snippet.source}`),
+		formatCaretLine(7 + snippet.highlightStart, snippet.highlightStart, snippet.highlightEnd, snippet.label),
+		dim("    `----")
+	].join("\n");
+}
+function formatDiagnostic(options) {
+	const lines = [`  ${(options.severity ?? "error") === "error" ? red("×") : yellow("!")} ${bold(`${options.code}`)}: ${options.message}`];
+	if (options.snippet !== void 0) lines.push(formatSnippet(options.snippet));
+	if (options.help !== void 0) lines.push(`  ${dim("help:")} ${options.help}`);
+	return lines.join("\n");
+}
+function formatHelpList(title, items) {
+	return [bold(title), ...items.map((item) => `  ${cyan(item)}`)].join("\n");
+}
+//#endregion
+//#region src/parser/loader.ts
+async function loadSpec(source) {
+	let filePath;
+	switch (source.kind) {
+		case "file":
+			filePath = resolve(source.path);
+			break;
+		case "local-override":
+			filePath = resolve(source.path);
+			break;
+		case "env": {
+			const envValue = process.env[source.varName];
+			if (envValue === void 0) throw new Error(`Environment variable ${source.varName} is not set`);
+			filePath = resolve(envValue);
+			break;
+		}
+	}
+	return parseJson(await readFile(filePath, "utf8"));
+}
+/**
+* Resolution priority:
+*   1. --spec CLI flag
+*   2. OPENAPI_SPEC_<UPPER_KEY> env var
+*   3. source.ts `spec` property (project-relative path from config)
+*   4. typeforge.local.json (gitignored per-machine override)
+*   5. committed snapshot at snapshotPath
+*
+* Throws a human-readable error (no stack trace as first line) when nothing is found.
+*/
+function resolveSpecSource(sourceKey, opts) {
+	if (opts.specFlag !== void 0) return {
+		kind: "file",
+		path: opts.specFlag
+	};
+	const envVarName = `OPENAPI_SPEC_${sourceKey.toUpperCase().replace(/-/g, "_")}`;
+	if (process.env[envVarName] !== void 0) return {
+		kind: "env",
+		varName: envVarName
+	};
+	if (opts.sourceConfigSpec !== void 0) return {
+		kind: "file",
+		path: opts.sourceConfigSpec
+	};
+	const defaultLocalPath = "./typeforge.local.json";
+	const legacyLocalPath = "./openapi-codegen.local.json";
+	const localPath = opts.localOverridePath ?? (existsSync(defaultLocalPath) || !existsSync(legacyLocalPath) ? defaultLocalPath : legacyLocalPath);
+	if (existsSync(localPath)) try {
+		const specPath = readJsonObject(readFileSync(localPath, "utf8"))[sourceKey];
+		if (typeof specPath === "string") return {
+			kind: "local-override",
+			path: specPath
+		};
+	} catch {}
+	if (opts.snapshotPath !== void 0 && existsSync(opts.snapshotPath)) return {
+		kind: "file",
+		path: opts.snapshotPath
+	};
+	throw new Error(buildNotFoundMessage(sourceKey, envVarName, opts, localPath));
+}
+function formatSnapshotNote(snapshotPath) {
+	if (snapshotPath === void 0) return dim("not configured");
+	if (existsSync(snapshotPath)) return dim(`found at ${snapshotPath}`);
+	return dim(`not found at ${snapshotPath}`);
+}
+function buildNotFoundMessage(sourceKey, envVarName, opts, localPath) {
+	const specFlagNote = opts.specFlag !== void 0 ? opts.specFlag : dim("not provided"), envNote = dim("not set"), sourceConfigNote = opts.sourceConfigSpec !== void 0 ? opts.sourceConfigSpec : dim("not set in source.ts"), localNote = existsSync(localPath) ? dim(`found at ${localPath} (no entry for "${sourceKey}")`) : dim(`not found at ${localPath}`), { snapshotPath } = opts;
+	const snapshotNote = formatSnapshotNote(snapshotPath), tried = [
+		`  --spec flag:                ${specFlagNote}`,
+		`  ${envVarName} env:   ${envNote}`,
+		`  source.ts spec:             ${sourceConfigNote}`,
+		`  local override:             ${localNote}`,
+		`  committed snapshot:         ${snapshotNote}`
+	].join("\n"), fixCommands = [`typeforge generate --source ${sourceKey} --spec ./path/to/swagger.json`, `export ${envVarName}=./path/to/swagger.json`];
+	return [
+		formatDiagnostic({
+			code: "typeforge/spec-not-found",
+			help: "Provide one of the resolution paths above, for example with --spec or an env var.",
+			message: `No OpenAPI spec found for source "${sourceKey}"`,
+			severity: "error"
+		}),
+		"",
+		bold("Tried:"),
+		tried,
+		"",
+		formatHelpList("Fix:", fixCommands)
+	].join("\n");
+}
+//#endregion
+//#region src/utils/output.ts
+async function writeOutputFiles(files, check = false) {
+	const changed = [];
+	for (const file of files) {
+		await mkdir(dirname(file.path), { recursive: true });
+		let existing;
+		try {
+			existing = await readFile(file.path, "utf8");
+		} catch {
+			existing = void 0;
+		}
+		if (existing === file.content) continue;
+		changed.push(file.path);
+		if (!check) await writeFile(file.path, file.content, "utf8");
+	}
+	return {
+		changed,
+		written: check ? 0 : changed.length
+	};
+}
+//#endregion
+//#region src/generate/index.ts
+function buildGenerateContext(cwd, sourceKey) {
+	const apiRoot = loadProjectConfig(cwd).apiRoot ?? "src/api";
+	const sourceConfig = loadSourceConfig(cwd, apiRoot, sourceKey);
+	const sourceDir = resolve(cwd, apiRoot, sourceKey);
+	const generatedDir = join(sourceDir, "generated");
+	const functionsDir = sourceConfig.functionsDir === void 0 ? join(generatedDir, "functions") : resolve(cwd, sourceConfig.functionsDir);
+	const typesDir = sourceConfig.typesDir === void 0 ? join(generatedDir, "types") : resolve(cwd, sourceConfig.typesDir);
+	return {
+		apiRoot,
+		baseFile: sourceConfig.typesDir === void 0 ? join(generatedDir, "base.ts") : join(dirname(typesDir), "base.d.ts"),
+		cwd,
+		functionsDir,
+		generatedDir,
+		hasQueryScope: sourceConfig.tanstackQuery === true && hasQueryScopeFile(cwd, apiRoot),
+		httpMode: detectHttpMode(cwd, apiRoot),
+		routesFile: join(generatedDir, "routes.ts"),
+		snapshotPath: join(sourceDir, "spec.json"),
+		sourceConfig,
+		sourceDir,
+		sourceKey,
+		typesDir
+	};
+}
+function validateEnvelope(context, source, acceptBase) {
+	const analysis = analyzeEnvelope(source);
+	if (analysis.mode !== "shared" || analysis.shared === void 0) return { mode: analysis.mode };
+	const modelsContent = readModelsFile(context.cwd, context.apiRoot);
+	if (modelsContent === void 0) return { mode: analysis.mode };
+	const userBase = parseUserBaseResponse(modelsContent);
+	if (userBase === void 0) return { mode: analysis.mode };
+	const diffs = diffEnvelopeFields(analysis.shared, userBase);
+	if (diffs.length === 0) return { mode: analysis.mode };
+	if (acceptBase) return { mode: analysis.mode };
+	const userBlock = userBase.fields.map((field) => `  ${field.name}${field.required ? "" : "?"}: ${field.kind};`).join("\n");
+	return {
+		error: formatDriftError(context.sourceKey, analysis.shared, userBase.sourcePath, userBlock, diffs),
+		mode: analysis.mode
+	};
+}
+function patchModelsBaseResponse(cwd, apiRoot, newInterface) {
+	const modelsPath = resolve(cwd, apiRoot, "models.ts");
+	if (!existsSync(modelsPath)) return;
+	const patched = readFileSync(modelsPath, "utf8").replace(/export\s+interface\s+BaseResponse\s*<[^>]*>\s*\{[\s\S]*?\}/, newInterface);
+	writeFileSync(modelsPath, patched, "utf8");
+}
+async function generateForSource(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const context = buildGenerateContext(cwd, options.sourceKey);
+	const specResolveOptions = { snapshotPath: context.snapshotPath };
+	if (options.specFlag !== void 0) specResolveOptions.specFlag = options.specFlag;
+	if (context.sourceConfig.spec !== void 0) specResolveOptions.sourceConfigSpec = context.sourceConfig.spec;
+	const rawSpec = await loadSpec(resolveSpecSource(options.sourceKey, specResolveOptions));
+	const parseOptions = {};
+	if (context.sourceConfig.ignorePaths !== void 0) parseOptions.ignorePaths = context.sourceConfig.ignorePaths;
+	if (context.sourceConfig.pathPrefix !== void 0) parseOptions.pathPrefix = context.sourceConfig.pathPrefix;
+	const source = parseSpec(rawSpec, parseOptions);
+	source.key = options.sourceKey;
+	const envelopeCheck = validateEnvelope(context, source, options.acceptBase === true);
+	if (envelopeCheck.error !== void 0) throw new Error(envelopeCheck.error);
+	const analysis = analyzeEnvelope(source);
+	const outputFiles = [];
+	const primaryEnvelope = getPrimaryEnvelopeShape(analysis);
+	if (primaryEnvelope !== void 0) {
+		outputFiles.push({
+			content: emitBaseFile(primaryEnvelope),
+			path: context.baseFile
+		});
+		if (options.acceptBase === true) patchModelsBaseResponse(cwd, context.apiRoot, buildBaseResponseInterface(primaryEnvelope));
+	}
+	const typeEmitterOptions = {
+		baseFile: context.baseFile,
+		envelopeMode: analysis.mode,
+		knownTypes: loadKnownTypeRules(cwd, context.apiRoot),
+		source,
+		sourceKey: options.sourceKey,
+		typesDir: context.typesDir
+	};
+	if (context.sourceConfig.resolveMapKeyRefs !== void 0) typeEmitterOptions.resolveMapKeyRefs = context.sourceConfig.resolveMapKeyRefs;
+	if (context.sourceConfig.unwrapResponseData !== void 0) typeEmitterOptions.unwrapResponseData = context.sourceConfig.unwrapResponseData;
+	if (primaryEnvelope !== void 0) typeEmitterOptions.sharedEnvelope = primaryEnvelope;
+	const typesTsconfigPaths = loadTsconfigPaths(context.typesDir);
+	if (typesTsconfigPaths !== void 0) typeEmitterOptions.tsconfigPaths = typesTsconfigPaths;
+	if (context.sourceConfig.maxRenderDepth !== void 0) typeEmitterOptions.maxRenderDepth = context.sourceConfig.maxRenderDepth;
+	if (context.sourceConfig.queryExtends !== void 0) typeEmitterOptions.queryExtends = context.sourceConfig.queryExtends;
+	if (isJsonObject(rawSpec)) typeEmitterOptions.rawSpec = rawSpec;
+	const typeFiles = emitTypeFiles(typeEmitterOptions);
+	for (const file of typeFiles) outputFiles.push({
+		content: file.content,
+		path: join(context.typesDir, file.relativePath)
+	});
+	const routeEnumName = context.sourceConfig.routeEnumName ?? "RouteTargets";
+	const routesOptions = {
+		paths: source.paths,
+		routeEnumName
+	};
+	if (context.sourceConfig.stripApiPrefix === true) routesOptions.stripApiPrefix = true;
+	const routesContent = emitRoutesFile(routesOptions);
+	let finalRoutes = routesContent;
+	if (context.sourceConfig.generationMode === "merge" && existsSync(context.routesFile)) finalRoutes = mergeRoutesFile(readFileSync(context.routesFile, "utf8"), routesContent, routeEnumName, context.sourceConfig.pathPrefix);
+	outputFiles.push({
+		content: finalRoutes,
+		path: context.routesFile
+	});
+	outputFiles.push({
+		content: emitRuntimeFile({
+			hasQueryScope: context.hasQueryScope,
+			httpMode: context.httpMode
+		}),
+		path: join(context.generatedDir, "runtime.ts")
+	});
+	const tsconfigPaths = loadTsconfigPaths(context.functionsDir);
+	const functionEmitterOptions = {
+		functionsDir: context.functionsDir,
+		generatedDir: context.generatedDir,
+		hasQueryScope: context.hasQueryScope,
+		httpMode: context.httpMode,
+		paths: source.paths,
+		routeEnumName,
+		typesDir: context.typesDir
+	};
+	if (context.sourceConfig.importBase !== void 0) functionEmitterOptions.importBase = context.sourceConfig.importBase;
+	else if (tsconfigPaths !== void 0) functionEmitterOptions.tsconfigPaths = tsconfigPaths;
+	const functionFiles = emitFunctionFiles(functionEmitterOptions);
+	for (const file of functionFiles) outputFiles.push({
+		content: file.content,
+		path: join(context.functionsDir, file.relativePath)
+	});
+	return {
+		changed: (await writeOutputFiles(outputFiles, options.check === true)).changed,
+		check: options.check === true,
+		files: outputFiles.length,
+		sourceKey: options.sourceKey
+	};
+}
+//#endregion
+//#region src/init/index.ts
+const AXIOS_HTTP_TEMPLATE = `import axiosBase from "axios";
+import { createAxiosAdapter } from "@openmirai/typeforge/adapters/axios";
+
+const axios = axiosBase.create({
+  baseURL: process.env.NEXT_PUBLIC_API_URL,
+});
+
+axios.interceptors.request.use(
+  async (config) => {
+    // Add auth headers, tracing, or Content-Type defaults here.
+    return config;
+  },
+  (error) => Promise.reject(error),
+);
+
+axios.interceptors.response.use(
+  (response) => response,
+  (error) => Promise.reject(error),
+);
+
+export const httpFetch = createAxiosAdapter(axios);
+export { axios };
+export type { HTTPFetch, HTTPFetchConfig } from "@openmirai/typeforge/adapters/axios";
+`;
+const FETCH_HTTP_TEMPLATE = `import { createFetchAdapter } from "@openmirai/typeforge/adapters/fetch";
+
+export const httpFetch = createFetchAdapter({
+  baseURL: process.env.NEXT_PUBLIC_API_URL,
+});
+
+export type { HTTPFetch, HTTPFetchConfig } from "@openmirai/typeforge/adapters/fetch";
+`;
+const CUSTOM_HTTP_TEMPLATE = `import type { HTTPFetch, HTTPFetchConfig } from "@openmirai/typeforge/http";
+
+export type { HTTPFetch, HTTPFetchConfig };
+
+export const httpFetch: HTTPFetch = {
+  delete: async <TResponse>(
+    _route: string,
+    _config?: HTTPFetchConfig
+  ): Promise<{ data: TResponse }> => {
+    throw new Error("Implement httpFetch.delete");
+  },
+  get: async <TResponse>(
+    _route: string,
+    _config?: HTTPFetchConfig
+  ): Promise<{ data: TResponse }> => {
+    throw new Error("Implement httpFetch.get");
+  },
+  patch: async <TResponse, TBody = unknown>(
+    _route: string,
+    _body: TBody,
+    _config?: HTTPFetchConfig
+  ): Promise<{ data: TResponse }> => {
+    throw new Error("Implement httpFetch.patch");
+  },
+  post: async <TResponse, TBody = unknown>(
+    _route: string,
+    _body: TBody,
+    _config?: HTTPFetchConfig
+  ): Promise<{ data: TResponse }> => {
+    throw new Error("Implement httpFetch.post");
+  },
+  put: async <TResponse, TBody = unknown>(
+    _route: string,
+    _body: TBody,
+    _config?: HTTPFetchConfig
+  ): Promise<{ data: TResponse }> => {
+    throw new Error("Implement httpFetch.put");
+  },
+};
+`;
+const SOURCE_TEMPLATE = `import { defineSourceConfig } from "@openmirai/typeforge";
+
+export default defineSourceConfig({
+  // Path to the OpenAPI spec file, relative to the project root.
+  // Set this so \`typeforge generate --source <key>\` (or --all) works
+  // without a per-invocation --spec flag.
+  // spec: "./specs/acme.json",
+  pathPrefix: "/api/acme/v3",
+  stripApiPrefix: true,
+  routeEnumName: "RouteTargets",
+  generationMode: "authoritative",
+  naming: "path",
+  ignorePaths: [],
+  maxRenderDepth: 50,
+  resolveMapKeyRefs: true,
+  queryExtends: {
+    page: "page",
+    limit: "limit",
+    sortBy: "sortBy",
+    sortOrder: "sortOrder",
+    paginationTypeName: "OffsetLimitQuery",
+    paginationImportPath: "./pagination",
+    sortTypeName: "SortParams",
+    sortImportPath: "./pagination",
+  },
+});
+`;
+const KNOWN_TYPES_TEMPLATE = `/** Map OpenAPI object shapes to your own TypeScript types by property pattern. */
+export const knownTypes = [
+  // {
+  //   name: "BlobAsset",
+  //   typeName: "BlobAsset",
+  //   importPath: "./blob/types",
+  //   exactProperties: ["id", "url", "file"],
+  // },
+  // {
+  //   name: "TiptapNode",
+  //   typeName: "TiptapNode",
+  //   importPath: "./tiptap/types",
+  //   requireProperties: ["type"],
+  //   excludeProperties: ["courseCount"],
+  // },
+];
+`;
+function defaultApiRoot(layout) {
+	return layout === "packages" ? "packages/utils/src/api" : "src/api";
+}
+function writeIfMissing(path, content) {
+	if (existsSync(path)) return "skipped";
+	mkdirSync(join(path, ".."), { recursive: true });
+	writeFileSync(path, content, "utf8");
+	return "created";
+}
+function initProject(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const layout = options.layout ?? "monolith";
+	const configPath = resolve(cwd, "typeforge.json");
+	const legacyConfigPath = resolve(cwd, "openapi-codegen.json");
+	const projectConfig = loadProjectConfig(cwd);
+	const apiRoot = existsSync(configPath) || existsSync(legacyConfigPath) ? projectConfig.apiRoot ?? "src/api" : defaultApiRoot(layout);
+	const apiRootPath = resolve(cwd, apiRoot);
+	const sourceDir = join(apiRootPath, options.sourceKey);
+	let httpTemplate = CUSTOM_HTTP_TEMPLATE;
+	if (options.client === "axios") httpTemplate = AXIOS_HTTP_TEMPLATE;
+	else if (options.client === "fetch") httpTemplate = FETCH_HTTP_TEMPLATE;
+	const created = [];
+	const skipped = [];
+	const httpPath = join(apiRootPath, "http.ts");
+	if (writeIfMissing(httpPath, httpTemplate) === "created") created.push(httpPath);
+	else skipped.push(httpPath);
+	const sourcePath = join(sourceDir, "source.ts");
+	if (writeIfMissing(sourcePath, SOURCE_TEMPLATE) === "created") created.push(sourcePath);
+	else skipped.push(sourcePath);
+	const knownTypesPath = join(apiRootPath, "known-types.ts");
+	if (writeIfMissing(knownTypesPath, KNOWN_TYPES_TEMPLATE) === "created") created.push(knownTypesPath);
+	else skipped.push(knownTypesPath);
+	const configWritePath = resolve(cwd, "typeforge.json");
+	if (!existsSync(configWritePath) && !existsSync(legacyConfigPath)) {
+		writeFileSync(configWritePath, `${JSON.stringify({ apiRoot }, null, 2)}\n`, "utf8");
+		created.push(configWritePath);
+	}
+	mkdirSync(join(sourceDir, "generated"), { recursive: true });
+	return {
+		created,
+		skipped
+	};
+}
+//#endregion
+export { resolveSpecSource as a, RecursiveRefError as c, analyzeEnvelope as d, buildBaseResponseInterface as f, loadProjectConfig as g, listSourceKeys as h, loadSpec as i, parseSchema as l, parseUserBaseResponse as m, buildGenerateContext as n, loadKnownTypeRules as o, diffEnvelopeFields as p, generateForSource as r, matchKnownType as s, initProject as t, parseSpec as u };
+
+//# sourceMappingURL=init-BBNO0SYd.js.map