orval 8.19.0 → 8.20.0

package/dist/bin/orval.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { c as description, i as startWatcher, l as name, n as loadConfigFile, r as generateSpec, s as normalizeOptions, t as findConfigFile, u as version } from "../config-D-TQRn-G.mjs";
+import { c as description, i as startWatcher, l as name, n as loadConfigFile, r as generateSpec, s as normalizeOptions, t as findConfigFile, u as version } from "../config-C8B9Lol2.mjs";
 import path from "node:path";
 import { Option, program } from "@commander-js/extra-typings";
 import { ErrorWithTag, OutputClient, OutputMode, SupportedFormatter, getWarningCount, isString, log, logError, resetWarnings, setVerbose, startMessage } from "@orval/core";

package/dist/{config-D-TQRn-G.mjs → config-C8B9Lol2.mjs}

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 import path from "node:path";
 import { DefaultTag, FormDataArrayHandling, GetterPropType, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SupportedFormatter, asyncReduce, buildDynamicScope, buildSchemaTagMap, collectReferencedComponents, conventionName, createSuccessMessage, dynamicImport, fixCrossDirectoryImports, fixRegularSchemaImports, generateComponentDefinition, generateDependencyImports, generateMutator, generateParameterDefinition, generateSchemasDefinition, generateVerbsOptions, getBaseUrlRuntimeImports, getFileInfo, getFullRoute, getImportExtension, getMockFileExtensionByTypeName, getRefInfo, getRoute, isBoolean, isComponentRef, isFunction, isNullish, isObject, isReference, isString, isUrl, jsDoc, kebab, log, logError, logVerbose, logWarning, pascal, removeFilesAndEmptyFolders, resolveInstalledVersions, resolveRef, resolveValue, splitSchemasByType, upath, writeGeneratedFile, writeSchemas, writeSchemasTagsSplit, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode } from "@orval/core";
 import { bundle } from "@scalar/json-magic/bundle";
@@ -15,20 +16,20 @@ import mcp from "@orval/mcp";
 import query from "@orval/query";
 import solidStart from "@orval/solid-start";
 import swr from "@orval/swr";
-import zod, { dereference, generateFormDataZodSchema, generateZodValidationSchemaDefinition, parseZodValidationSchemaDefinition, resolveIsZodV4 } from "@orval/zod";
+import zod, { assertZodTarget, dereference, generateFormDataZodSchema, generateZodValidationSchemaDefinition, getZodImportSource, getZodTypeName, parseZodValidationSchemaDefinition, resolveIsZodV4 } from "@orval/zod";
 import { ExecaError, execa } from "execa";
 import fs from "fs-extra";
 import fs$1, { access } from "node:fs/promises";
 import { styleText } from "node:util";
 import { parseArgsStringToArgv } from "string-argv";
+import fs$2, { existsSync } from "node:fs";
 import { findUp, findUpMultiple } from "find-up";
 import yaml from "js-yaml";
 import { parseTsconfig } from "get-tsconfig";
-import fs$2 from "node:fs";
 import { createJiti } from "jiti";
 //#region package.json
 var name = "orval";
-var version = "8.19.0";
+var version = "8.20.0";
 var description = "A swagger client generator for typescript";
 //#endregion
 //#region src/client.ts
@@ -909,6 +910,29 @@ function validatePackageSpecifier(value, fieldName) {
 	if (value.startsWith(".")) throw new Error(`\`${fieldName}\` must be a package specifier (e.g. '@acme/models'), not a relative path. Received: "${value}"`);
 	if (path.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\")) throw new Error(`\`${fieldName}\` must be a package specifier (e.g. '@acme/models'), not an absolute path. Received: "${value}"`);
 }
+function looksLikePackageSpecifier(value) {
+	return !!value && value.trim() === value && !value.startsWith(".") && !path.isAbsolute(value) && !/^[A-Za-z]:[\\/]/.test(value) && !value.startsWith("\\\\");
+}
+function resolvePackageSpecifier(workspace, value) {
+	try {
+		return createRequire(path.join(workspace, "package.json")).resolve(value);
+	} catch {
+		return;
+	}
+}
+function isPackageSpecifierCandidate(workspace, value) {
+	if (!looksLikePackageSpecifier(value)) return false;
+	if (existsSync(path.resolve(workspace, value))) return false;
+	if (value.startsWith("@")) return true;
+	const [packageName] = value.split("/");
+	if (!value.includes("/")) return true;
+	for (let dir = workspace;;) {
+		if (existsSync(path.join(dir, "node_modules", packageName))) return true;
+		const parent = path.dirname(dir);
+		if (parent === dir) return false;
+		dir = parent;
+	}
+}
 function normalizeEffectOptions(effect) {
 	return {
 		strict: {
@@ -1096,6 +1120,7 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 						...outputOptions.override?.zod?.preprocess?.response ? { response: normalizeMutator(outputWorkspace, outputOptions.override.zod.preprocess.response) } : {}
 					},
 					...outputOptions.override?.zod?.params ? { params: normalizeMutator(outputWorkspace, outputOptions.override.zod.params) } : {},
+					variant: outputOptions.override?.zod?.variant ?? "classic",
 					version: outputOptions.override?.zod?.version ?? "auto",
 					generateEachHttpStatus: outputOptions.override?.zod?.generateEachHttpStatus ?? false,
 					useBrandedTypes: outputOptions.override?.zod?.useBrandedTypes ?? false,
@@ -1161,8 +1186,10 @@ function normalizeMutator(workspace, mutator) {
 	if (isObject(mutator)) {
 		const m = mutator;
 		if (!m.path) throw new Error(styleText("red", `Mutator requires a path.`));
+		const resolvedPath = looksLikePackageSpecifier(m.path) ? resolvePackageSpecifier(workspace, m.path) : void 0;
 		return {
-			path: path.resolve(workspace, m.path),
+			path: !!resolvedPath || isPackageSpecifierCandidate(workspace, m.path) ? m.path : path.resolve(workspace, m.path),
+			...resolvedPath ? { resolvedPath } : {},
 			name: m.name,
 			default: m.default ?? !m.name,
 			alias: m.alias,
@@ -1170,10 +1197,14 @@ function normalizeMutator(workspace, mutator) {
 			extension: m.extension
 		};
 	}
-	if (isString(mutator)) return {
-		path: path.resolve(workspace, mutator),
-		default: true
-	};
+	if (isString(mutator)) {
+		const resolvedPath = looksLikePackageSpecifier(mutator) ? resolvePackageSpecifier(workspace, mutator) : void 0;
+		return {
+			path: !!resolvedPath || isPackageSpecifierCandidate(workspace, mutator) ? mutator : path.resolve(workspace, mutator),
+			...resolvedPath ? { resolvedPath } : {},
+			default: true
+		};
+	}
 }
 async function resolveFirstValidTarget(targets, workspace, parserOptions) {
 	for (const target of targets) {
@@ -1238,6 +1269,7 @@ function normalizePath(path$1, workspace) {
 function normalizeOperationsAndTags(operationsOrTags, workspace, global, source) {
 	const unsupportedZodKeys = [
 		"version",
+		"variant",
 		"dateTimeOptions",
 		"timeOptions",
 		"generateEachHttpStatus",
@@ -1494,13 +1526,14 @@ const generateReusableSchemaSet = (refs, context, options) => {
 			operationId: "",
 			location: "schema",
 			schemaName: name
-		} : void 0);
+		} : void 0, options.variant);
 		entries.push({
 			ref,
 			name,
 			zod: parsed.zod,
 			consts: parsed.consts,
-			usedRefs: parsed.usedRefs
+			usedRefs: parsed.usedRefs,
+			variant: options.variant
 		});
 		for (const usedName of parsed.usedRefs) {
 			const usedRef = nameToRef.get(usedName);
@@ -1596,7 +1629,7 @@ const rewriteReusableSchemas = (entries) => {
 	else if (lazyEdges.has(edgeKey(scc[0], scc[0]))) recursiveNames.add(scc[0]);
 	const rewritten = new Map(entries.map((entry) => {
 		const newZod = entry.zod.replaceAll(SENTINEL_PATTERN, (_match, refName) => {
-			return lazyEdges.has(edgeKey(entry.name, refName)) ? `zod.lazy(() => ${refName})` : refName;
+			return lazyEdges.has(edgeKey(entry.name, refName)) ? `${entry.variant === "mini" ? "/*#__PURE__*/ " : ""}zod.lazy(() => ${refName})` : refName;
 		});
 		return [entry.name, {
 			...entry,
@@ -1613,6 +1646,7 @@ const rewriteReusableSchemas = (entries) => {
 };
 //#endregion
 //#region src/write-zod-specs.ts
+const getZodSchemaImportStatement = (variant) => variant === "mini" ? `import * as zod from '${getZodImportSource(variant)}';` : `import { z as zod } from '${getZodImportSource(variant)}';`;
 /**
 * Render the `import { ... } from '...'` line for a resolved
 * `GeneratorMutator`. Mirrors the format produced by
@@ -1647,9 +1681,9 @@ function adjustMutatorPathForDir(mutatorPath, tagDir) {
 function bodyReferencesMutator(body, mutator) {
 	return new RegExp(String.raw`\b${mutator.name}\b`).test(body);
 }
-function generateZodSchemaFileContent(header, schemas, includeZodImport = true) {
+function generateZodSchemaFileContent(header, schemas, zodVariant, includeZodImport = true) {
 	const refImports = [...new Set(schemas.flatMap((s) => s.importStatements ?? []))].toSorted();
-	const importBlock = [...includeZodImport ? [`import { z as zod } from 'zod';`] : [], ...refImports].join("\n");
+	const importBlock = [...includeZodImport ? [getZodSchemaImportStatement(zodVariant)] : [], ...refImports].join("\n");
 	const schemaContent = schemas.map(({ schemaName, consts, zodExpression }) => {
 		return `${consts ? `${consts}\n` : ""}export const ${schemaName} = ${zodExpression}
 
@@ -1658,7 +1692,7 @@ export type ${schemaName}Output = zod.output<typeof ${schemaName}>;`;
 	}).join("\n\n");
 	return `${header}${importBlock ? `${importBlock}\n\n` : ""}${schemaContent}\n`;
 }
-function renderReusableSchemaEntry(entry, context) {
+function renderReusableSchemaEntry(entry, context, zodVariant) {
 	const consts = entry.consts ? `${entry.consts}\n\n` : "";
 	if (entry.isRecursive) {
 		const rawName = isComponentRef(entry.ref) ? getRefInfo(entry.ref, context).originalName : void 0;
@@ -1669,10 +1703,18 @@ function renderReusableSchemaEntry(entry, context) {
 			context
 		}) : void 0;
 		const typeBody = resolved ? resolved.value : "unknown";
+		const seenSubModels = /* @__PURE__ */ new Set();
+		const subModels = (resolved?.schemas ?? []).filter((s) => {
+			if (seenSubModels.has(s.name)) return false;
+			seenSubModels.add(s.name);
+			return true;
+		});
+		const subModelBlock = subModels.length ? `${subModels.map((s) => s.model.trimEnd()).join("\n")}\n\n` : "";
+		const localNames = new Set(subModels.map((s) => s.name));
 		const seen = /* @__PURE__ */ new Set();
 		const extraImports = [];
 		for (const imp of resolved?.imports ?? []) {
-			if (!imp.name || imp.name === entry.name) continue;
+			if (!imp.name || imp.name === entry.name || localNames.has(imp.name)) continue;
 			const bindingKey = imp.alias ?? imp.name;
 			if (seen.has(bindingKey)) continue;
 			seen.add(bindingKey);
@@ -1682,7 +1724,7 @@ function renderReusableSchemaEntry(entry, context) {
 			});
 		}
 		return {
-			content: `${consts}export type ${entry.name} = ${typeBody};\n\nexport const ${entry.name}: zod.ZodType<${entry.name}> = ${entry.zod};\n\nexport type ${entry.name}Output = zod.output<typeof ${entry.name}>;`,
+			content: `${consts}${subModelBlock}export type ${entry.name} = ${typeBody};\n\nexport const ${entry.name}: zod.${getZodTypeName(zodVariant)}<${entry.name}> = ${entry.zod};\n\nexport type ${entry.name}Output = zod.output<typeof ${entry.name}>;`,
 			extraImports
 		};
 	}
@@ -1791,6 +1833,10 @@ function generateZodSchemasInline(builder, output, includeZodImport = true, para
 	const schemasWithOpenApiDef = builder.schemas.filter((s) => s.schema);
 	if (schemasWithOpenApiDef.length === 0) return "";
 	const isZodV4 = resolveIsZodV4(output.override.zod.version, output.packageJson);
+	assertZodTarget({
+		variant: output.override.zod.variant,
+		isZodV4
+	});
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	const schemas = [];
@@ -1805,7 +1851,7 @@ function generateZodSchemasInline(builder, output, includeZodImport = true, para
 		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(dereference(schemaObject, context), context, name, strict, isZodV4, {
 			required: true,
 			emitMeta: output.override.zod.generateMeta
-		}), context, coerce, strict, isZodV4);
+		}), context, coerce, strict, isZodV4, void 0, void 0, output.override.zod.variant);
 		schemas.push({
 			schemaName: name,
 			consts: parsedZodDefinition.consts,
@@ -1813,10 +1859,14 @@ function generateZodSchemasInline(builder, output, includeZodImport = true, para
 		});
 	}
 	if (schemas.length === 0) return "";
-	return generateZodSchemaFileContent("", schemas, includeZodImport);
+	return generateZodSchemaFileContent("", schemas, output.override.zod.variant, includeZodImport);
 }
 function generateZodSchemasInlineReusable(builder, output, includeZodImport = true, paramsMutator, includeParamsImport = false) {
 	const isZodV4 = resolveIsZodV4(output.override.zod.version, output.packageJson);
+	assertZodTarget({
+		variant: output.override.zod.variant,
+		isZodV4
+	});
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	const context = {
@@ -1833,10 +1883,11 @@ function generateZodSchemasInlineReusable(builder, output, includeZodImport = tr
 		strict,
 		isZodV4,
 		coerce,
+		variant: output.override.zod.variant,
 		generateMeta: output.override.zod.generateMeta,
 		paramsMutator
-	})).map((entry) => renderReusableSchemaEntry(entry, context).content).join("\n\n");
-	const zodImport = includeZodImport ? `import { z as zod } from 'zod';\n` : "";
+	})).map((entry) => renderReusableSchemaEntry(entry, context, output.override.zod.variant).content).join("\n\n");
+	const zodImport = includeZodImport ? `${getZodSchemaImportStatement(output.override.zod.variant)}\n` : "";
 	const paramsImport = paramsMutator && includeParamsImport && bodyReferencesMutator(body, paramsMutator) ? `${buildMutatorImportStatement(paramsMutator)}\n` : "";
 	return `${zodImport || paramsImport ? `${zodImport}${paramsImport}\n` : ""}${body}\n`;
 }
@@ -1846,6 +1897,10 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 	const schemasWithOpenApiDef = builder.schemas.filter((s) => s.schema);
 	const schemasToWrite = [];
 	const isZodV4 = resolveIsZodV4(output.override.zod.version, output.packageJson);
+	assertZodTarget({
+		variant: output.override.zod.variant,
+		isZodV4
+	});
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	for (const generatorSchema of schemasWithOpenApiDef) {
@@ -1863,7 +1918,7 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(dereference(schemaObject, context), context, name, strict, isZodV4, {
 			required: true,
 			emitMeta: output.override.zod.generateMeta
-		}), context, coerce, strict, isZodV4);
+		}), context, coerce, strict, isZodV4, void 0, void 0, output.override.zod.variant);
 		schemasToWrite.push({
 			schemaName: name,
 			filePath,
@@ -1873,7 +1928,7 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 	}
 	const groupedSchemasToWrite = groupSchemasByFilePath(schemasToWrite);
 	for (const schemaGroup of groupedSchemasToWrite) {
-		const fileContent = generateZodSchemaFileContent(header, schemaGroup);
+		const fileContent = generateZodSchemaFileContent(header, schemaGroup, output.override.zod.variant);
 		await fs.outputFile(schemaGroup[0].filePath, fileContent);
 	}
 	const writtenSchemaNames = groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName);
@@ -1892,6 +1947,10 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 async function writeZodSchemasReusable(builder, schemasPath, fileExtension, header, output, paramsMutator, schemaTagMap) {
 	const isSplit = !!schemaTagMap;
 	const isZodV4 = resolveIsZodV4(output.override.zod.version, output.packageJson);
+	assertZodTarget({
+		variant: output.override.zod.variant,
+		isZodV4
+	});
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	const context = {
@@ -1907,6 +1966,7 @@ async function writeZodSchemasReusable(builder, schemasPath, fileExtension, head
 		strict,
 		isZodV4,
 		coerce,
+		variant: output.override.zod.variant,
 		generateMeta: output.override.zod.generateMeta,
 		paramsMutator
 	}));
@@ -1916,7 +1976,7 @@ async function writeZodSchemasReusable(builder, schemasPath, fileExtension, head
 		const tagDir = getSchemaDir(schemaTagMap, entry.name);
 		const filePath = isSplit ? path.join(schemasPath, tagDir, `${fileName}${fileExtension}`) : path.join(schemasPath, `${fileName}${fileExtension}`);
 		const importExt = getImportExtension(fileExtension, output.tsconfig);
-		const rendered = renderReusableSchemaEntry(entry, context);
+		const rendered = renderReusableSchemaEntry(entry, context, output.override.zod.variant);
 		const refImports = buildSiblingImports({
 			usedRefs: entry.usedRefs,
 			extraImports: rendered.extraImports,
@@ -1935,7 +1995,7 @@ async function writeZodSchemasReusable(builder, schemasPath, fileExtension, head
 			path: isSplit ? adjustMutatorPathForDir(paramsMutator.path, tagDir) : paramsMutator.path
 		}) : void 0;
 		const imports = [...mutatorImportStr ? [mutatorImportStr] : [], ...refImports ? [refImports] : []].join("\n");
-		const fileContent = `${header}import { z as zod } from 'zod';\n` + (imports ? `${imports}\n\n` : "\n") + `${rendered.content}\n`;
+		const fileContent = `${header}${getZodSchemaImportStatement(output.override.zod.variant)}\n` + (imports ? `${imports}\n\n` : "\n") + `${rendered.content}\n`;
 		await fs.outputFile(filePath, fileContent);
 	}
 	if (output.indexFiles && !isSplit && rewritten.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, rewritten.map((e) => e.name), output.namingConvention, true, output.tsconfig);
@@ -1956,6 +2016,10 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 	const verbOptionsArray = Object.values(verbOptions);
 	if (verbOptionsArray.length === 0) return /* @__PURE__ */ new Map();
 	const isZodV4 = resolveIsZodV4(output.override.zod.version, output.packageJson);
+	assertZodTarget({
+		variant: output.override.zod.variant,
+		isZodV4
+	});
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	const useReusableSchemas = output.override.zod.generateReusableSchemas === true;
@@ -2032,7 +2096,7 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 		const parsedZodDefinition = parseZodValidationSchemaDefinition("bodyContentType" in entry && entry.bodyContentType === "multipart/form-data" ? generateFormDataZodSchema(schema, zodContext, name, strict, isZodV4, "encoding" in entry ? entry.encoding : void 0, useReusableSchemas) : generateZodValidationSchemaDefinition(schema, zodContext, name, strict, isZodV4, {
 			required: true,
 			useReusableSchemas
-		}), zodContext, coerce, strict, isZodV4);
+		}), zodContext, coerce, strict, isZodV4, void 0, void 0, output.override.zod.variant);
 		let zodExpression = parsedZodDefinition.zod;
 		let importStatements;
 		if (useReusableSchemas && parsedZodDefinition.usedRefs.size > 0) {
@@ -2053,7 +2117,7 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 	}
 	const groupedSchemasToWrite = groupSchemasByFilePath(schemasToWrite);
 	for (const schemaGroup of groupedSchemasToWrite) {
-		const fileContent = generateZodSchemaFileContent(header, schemaGroup);
+		const fileContent = generateZodSchemaFileContent(header, schemaGroup, output.override.zod.variant);
 		await fs.outputFile(schemaGroup[0].filePath, fileContent);
 	}
 	const writtenSchemaNames = groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName);
@@ -2100,6 +2164,23 @@ async function runFormatter(formatter, paths, projectTitle) {
 			break;
 	}
 }
+function getComparableFilePath(filePath) {
+	const resolvedPath = path.resolve(filePath);
+	let comparablePath = resolvedPath;
+	try {
+		comparablePath = fs.realpathSync(resolvedPath);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	return process.platform === "win32" || process.platform === "darwin" ? comparablePath.toLowerCase() : comparablePath;
+}
+function excludeFilePath(filePaths, filePathToExclude) {
+	const comparablePathToExclude = getComparableFilePath(filePathToExclude);
+	return filePaths.map((filePath) => ({
+		filePath,
+		comparablePath: getComparableFilePath(filePath)
+	})).filter(({ comparablePath }) => comparablePath !== comparablePathToExclude).map(({ filePath }) => filePath);
+}
 function getHeader(option, info) {
 	if (!option) return "";
 	const header = option(info);
@@ -2223,6 +2304,13 @@ function shouldGenerateZodSchemasInline(output, hasOperations) {
 function shouldGenerateSchemas(output, hasOperations) {
 	return !output.schemas && !isSchemaValidatorClient(output.client) || shouldGenerateZodSchemasInline(output, hasOperations);
 }
+function getImplementationPathsForIndex(output, implementationPaths, indexFile) {
+	const shouldExcludeSelf = output.indexFiles;
+	const paths = shouldExcludeSelf ? excludeFilePath(implementationPaths, indexFile) : implementationPaths;
+	if (!(shouldExcludeSelf && output.mode === OutputMode.SPLIT && getComparableFilePath(output.target) === getComparableFilePath(indexFile))) return paths;
+	const targetInfo = getFileInfo(output.target, { extension: output.fileExtension });
+	return excludeFilePath(paths, path.join(targetInfo.dirname, `${targetInfo.filename}.schemas${output.fileExtension}`));
+}
 async function writeSpecs(builder, workspace, options, projectName) {
 	const { info, schemas, target } = builder;
 	const { output } = options;
@@ -2357,7 +2445,8 @@ async function writeSpecs(builder, workspace, options, projectName) {
 		const indexFile = path.join(workspacePath, "index.ts");
 		const mockExtensions = output.mock.generators.map((g) => getMockFileExtensionByTypeName(g));
 		const importExtension = getImportExtension(output.fileExtension, output.tsconfig);
-		const imports = implementationPaths.filter((p) => mockExtensions.length === 0 || !mockExtensions.some((ext) => p.endsWith(`.${ext}.ts`))).map((p) => {
+		const implementationPathsForIndex = getImplementationPathsForIndex(output, implementationPaths, indexFile);
+		const imports = implementationPathsForIndex.filter((p) => mockExtensions.length === 0 || !mockExtensions.some((ext) => p.endsWith(`.${ext}.ts`))).map((p) => {
 			const relative = upath.getRelativeImportPath(indexFile, p, true);
 			return (relative.endsWith(output.fileExtension) ? relative.slice(0, -output.fileExtension.length) : relative.replace(/\.[^/.]+$/, "")) + importExtension;
 		});
@@ -2369,10 +2458,10 @@ async function writeSpecs(builder, workspace, options, projectName) {
 		if (output.indexFiles) {
 			if (await fs.pathExists(indexFile)) {
 				const data = await fs.readFile(indexFile, "utf8");
-				const importsNotDeclared = imports.filter((imp) => !data.includes(imp));
+				const importsNotDeclared = imports.filter((imp) => !data.includes(`export * from '${imp}'`));
 				await fs.appendFile(indexFile, unique(importsNotDeclared).map((imp) => `export * from '${imp}';\n`).join(""));
 			} else await fs.outputFile(indexFile, unique(imports).map((imp) => `export * from '${imp}';`).join("\n") + "\n");
-			implementationPaths = [indexFile, ...implementationPaths];
+			implementationPaths = [indexFile, ...implementationPathsForIndex];
 		}
 	}
 	if (builder.extraFiles.length > 0) {
@@ -2512,4 +2601,4 @@ async function loadConfigFile(configFilePath) {
 //#endregion
 export { defineConfig as a, description as c, startWatcher as i, name as l, loadConfigFile as n, defineTransformer as o, generateSpec as r, normalizeOptions as s, findConfigFile as t, version as u };
 
-//# sourceMappingURL=config-D-TQRn-G.mjs.map
+//# sourceMappingURL=config-C8B9Lol2.mjs.map