@workos/oagen 0.20.0 → 0.21.1

package/dist/cli/index.mjs

@@ -433,7 +433,7 @@ function qualifyInlineModelName(baseName, parentName) {
 function extractInlineModelsFromSchemas(schemas) {
 	if (!schemas) return [];
 	const inlineModels = [];
-	for (const [schemaName, schema] of Object.entries(schemas)) extractInlineModelsFromProperties(schema, inlineModels, cleanSchemaName(toPascalCase(schemaName)));
+	for (const [schemaName, schema] of Object.entries(schemas)) extractInlineModelsFromProperties(schema, inlineModels, resolveSchemaName(schemaName));
 	return inlineModels;
 }
 function extractInlineModelsFromProperties(schema, results, parentName) {
@@ -837,9 +837,10 @@ function collectLiteralStringConsts(variants) {
 function buildSyntheticEnumRef(values, contextName, parentModelName) {
 	const baseName = toPascalCase(contextName ?? "UnknownEnum");
 	const cleanParent = parentModelName ? stripListItemMarkers(parentModelName) : void 0;
+	const qualifiedName = cleanParent && !baseName.startsWith(cleanParent) ? `${cleanParent}${baseName}` : baseName;
 	return {
 		kind: "enum",
-		name: cleanParent && !baseName.startsWith(cleanParent) ? `${cleanParent}${baseName}` : baseName,
+		name: activeSchemaNameTransform ? activeSchemaNameTransform(qualifiedName) : qualifiedName,
 		values
 	};
 }
@@ -1047,6 +1048,36 @@ function extractAllOfModel(name, schema, schemas) {
 	};
 }
 /**
+* Walk through `allOf` wrappers to collect the effective top-level properties
+* of a schema. Stops at `oneOf` / `anyOf` boundaries — those are different
+* variant axes, not part of the same flat object.
+*
+* Used by `detectAllOfVariantDiscriminator` and `deriveDiscriminatedVariantName`
+* so a oneOf variant of the form `{ allOf: [{ properties: { … } }, { oneOf: […] }] }`
+* still surfaces its top-level `properties` (in particular its discriminator
+* `const`) instead of being treated as having none.
+*/
+function getEffectiveProperties(schema) {
+	const props = {};
+	const visit = (s) => {
+		if (s.properties) {
+			for (const [k, v] of Object.entries(s.properties)) if (!(k in props) && v) props[k] = v;
+		}
+		if (s.allOf) for (const sub of s.allOf) visit(sub);
+	};
+	visit(schema);
+	return props;
+}
+function getEffectiveConstPropertyValue(schema, property) {
+	const direct = getConstPropertyValue(schema, property);
+	if (direct !== null) return direct;
+	const effective = getEffectiveProperties(schema)[property];
+	if (!effective) return null;
+	if (typeof effective.const === "string") return effective.const;
+	if (Array.isArray(effective.enum) && effective.enum.length === 1 && typeof effective.enum[0] === "string") return effective.enum[0];
+	return null;
+}
+/**
 * Detect an implicit discriminator on an allOf+oneOf where every variant is an
 * object that pins the same property to a distinct const value. Unlike
 * detectConstPropertyDiscriminator (which requires $ref or title for variant
@@ -1054,13 +1085,17 @@ function extractAllOfModel(name, schema, schemas) {
 * using deriveDiscriminatedVariantName — matching how extractDiscriminatedAllOfVariantModels
 * names those models.
 *
+* Walks through allOf wrappers on each variant so a oneOf branch like
+*   { allOf: [{ properties: { type: { const: 'oauth' } } }, { oneOf: […] }] }
+* still surfaces `type` as a candidate discriminator.
+*
 * Returns null when no discriminator can be reliably detected.
 */
 function detectAllOfVariantDiscriminator(variants, fallbackName) {
 	if (variants.length < 2) return null;
-	const candidates = Object.keys(variants[0]?.properties ?? {});
+	const firstProps = getEffectiveProperties(variants[0] ?? {});
 	let candidateProperty = null;
-	for (const propName of candidates) if (variants.every((v) => getConstPropertyValue(v, propName) !== null)) {
+	for (const propName of Object.keys(firstProps)) if (variants.every((v) => getEffectiveConstPropertyValue(v, propName) !== null)) {
 		candidateProperty = propName;
 		break;
 	}
@@ -1068,7 +1103,7 @@ function detectAllOfVariantDiscriminator(variants, fallbackName) {
 	const mapping = {};
 	const seenModelNames = /* @__PURE__ */ new Set();
 	for (const v of variants) {
-		const value = getConstPropertyValue(v, candidateProperty);
+		const value = getEffectiveConstPropertyValue(v, candidateProperty);
 		if (value === null) return null;
 		const modelName = deriveDiscriminatedVariantName(v, fallbackName);
 		if (seenModelNames.has(modelName)) return null;
@@ -1083,10 +1118,28 @@ function detectAllOfVariantDiscriminator(variants, fallbackName) {
 function extractDiscriminatedAllOfVariantModels(schema, fallbackName) {
 	const models = [];
 	const seenNames = /* @__PURE__ */ new Set();
+	const baseProperties = {};
+	const baseRequired = /* @__PURE__ */ new Set();
+	for (const subSchema of schema.allOf ?? []) {
+		if (subSchema.oneOf) continue;
+		const flat = subSchema.allOf ? flattenVariantForExtraction(subSchema) : subSchema;
+		if (flat.properties) {
+			for (const [k, v] of Object.entries(flat.properties)) if (!(k in baseProperties) && v) baseProperties[k] = v;
+		}
+		if (flat.required) for (const r of flat.required) baseRequired.add(r);
+	}
 	for (const subSchema of schema.allOf ?? []) for (const variant of subSchema.oneOf ?? []) {
-		if (!variant.properties || variant.type !== void 0 && variant.type !== "object") continue;
+		const flat = flattenVariantForExtraction(variant);
+		if (!flat.properties || flat.type !== void 0 && flat.type !== "object") continue;
+		const mergedProperties = { ...baseProperties };
+		for (const [k, v] of Object.entries(flat.properties)) if (v) mergedProperties[k] = v;
+		const merged = {
+			type: "object",
+			properties: mergedProperties,
+			required: [...new Set([...baseRequired, ...flat.required ?? []])]
+		};
 		const variantName = deriveDiscriminatedVariantName(variant, fallbackName);
-		for (const model of extractInlineModelDeep(variantName, variant)) {
+		for (const model of extractInlineModelDeep(variantName, merged)) {
 			if (seenNames.has(model.name)) continue;
 			seenNames.add(model.name);
 			models.push(model);
@@ -1094,24 +1147,103 @@ function extractDiscriminatedAllOfVariantModels(schema, fallbackName) {
 	}
 	return models;
 }
+/**
+* Flatten a oneOf variant schema into a single object-shaped schema for
+* variant-model extraction. Recursively merges `allOf` members and folds
+* any nested `oneOf` into an inline-oneOf field group whose properties are
+* the union across sub-branches (required only when present in every
+* sub-branch). Returns the schema unchanged when no flattening is needed.
+*/
+function flattenVariantForExtraction(variant) {
+	if (!variant.allOf) return variant;
+	const mergedProperties = {};
+	const mergedRequired = /* @__PURE__ */ new Set();
+	const nestedOneOfs = [];
+	const collect = (s) => {
+		if (s.properties) {
+			for (const [k, v] of Object.entries(s.properties)) if (!(k in mergedProperties) && v) mergedProperties[k] = v;
+		}
+		if (s.required) for (const r of s.required) mergedRequired.add(r);
+		if (s.allOf) for (const sub of s.allOf) collect(sub);
+		if (s.oneOf) nestedOneOfs.push(s.oneOf);
+	};
+	collect(variant);
+	for (const branches of nestedOneOfs) {
+		const flatBranches = branches.map(flattenVariantForExtraction);
+		const branchKeys = /* @__PURE__ */ new Set();
+		for (const b of flatBranches) for (const k of Object.keys(b.properties ?? {})) branchKeys.add(k);
+		for (const key of branchKeys) {
+			const schemas = [];
+			for (const b of flatBranches) {
+				const s = b.properties?.[key];
+				if (s) schemas.push(s);
+			}
+			const merged = mergeBranchPropertySchemas(schemas);
+			if (!(key in mergedProperties)) mergedProperties[key] = merged;
+			if (flatBranches.every((b) => b.properties && key in b.properties) && flatBranches.every((b) => (b.required ?? []).includes(key))) mergedRequired.add(key);
+		}
+	}
+	return {
+		type: "object",
+		properties: mergedProperties,
+		required: [...mergedRequired]
+	};
+}
+/**
+* Merge same-named property schemas from across sub-variants. If every
+* occurrence is a boolean const, widen to plain boolean; if every occurrence
+* is a distinct string const, widen to plain string. Otherwise return the
+* first occurrence — emitters that build their own widened types (e.g. the
+* Node discriminated-models module) re-derive from the raw spec.
+*/
+function mergeBranchPropertySchemas(schemas) {
+	if (schemas.length === 0) return {};
+	if (schemas.length === 1) return schemas[0];
+	if (schemas.every((s) => s.type === "boolean" && typeof s.const === "boolean")) return {
+		type: "boolean",
+		description: schemas[0].description
+	};
+	if (schemas.every((s) => s.type === "string" && typeof s.const === "string")) {
+		const values = schemas.map((s) => s.const);
+		if (new Set(values).size === 1) return schemas[0];
+		return {
+			type: "string",
+			description: schemas[0].description
+		};
+	}
+	return schemas[0];
+}
 function deriveDiscriminatedVariantName(schema, fallbackName) {
-	if (!schema.properties) return fallbackName;
-	for (const name of [
+	const effective = getEffectiveProperties(schema);
+	if (Object.keys(effective).length === 0) return fallbackName;
+	const pickConst = (name) => {
+		const field = effective[name];
+		if (!field) return null;
+		if (typeof field.const === "string") return field.const;
+		if (field.enum && field.enum.length === 1 && typeof field.enum[0] === "string") return field.enum[0];
+		return null;
+	};
+	let constValue = null;
+	for (const preferred of [
 		"event",
 		"type",
 		"object"
 	]) {
-		const field = schema.properties[name];
-		if (!field) continue;
-		if (typeof field.const === "string") return toPascalCase(field.const);
-		if (field.enum && field.enum.length === 1 && typeof field.enum[0] === "string") return toPascalCase(field.enum[0]);
-	}
-	for (const field of Object.values(schema.properties)) {
-		if (!field) continue;
-		if (typeof field.const === "string") return toPascalCase(field.const);
-		if (field.enum && field.enum.length === 1 && typeof field.enum[0] === "string") return toPascalCase(field.enum[0]);
-	}
-	return fallbackName;
+		constValue = pickConst(preferred);
+		if (constValue) break;
+	}
+	if (constValue === null) for (const name of Object.keys(effective)) {
+		constValue = pickConst(name);
+		if (constValue) break;
+	}
+	if (constValue === null) return fallbackName;
+	const pascal = toPascalCase(constValue);
+	if (!pascal) return fallbackName;
+	if (splitWords(constValue).length >= 2) return pascal;
+	if (pascal === fallbackName) return pascal;
+	if (fallbackName.startsWith(pascal)) return fallbackName;
+	if (pascal.endsWith(fallbackName)) return pascal;
+	return `${fallbackName}${pascal}`;
 }
 function extractInlineModelDeep(name, schema) {
 	const requiredSet = new Set(schema.required ?? []);
@@ -1340,9 +1472,10 @@ function schemaToTypeRef(schema, contextName, parentModelName) {
 	if (schema.enum) {
 		const baseName = toPascalCase(contextName ?? "UnknownEnum");
 		const cleanParent = parentModelName ? stripListItemMarkers(parentModelName) : void 0;
+		const qualifiedName = cleanParent && !baseName.startsWith(cleanParent) ? `${cleanParent}${baseName}` : baseName;
 		return {
 			kind: "enum",
-			name: cleanParent && !baseName.startsWith(cleanParent) ? `${cleanParent}${baseName}` : baseName,
+			name: activeSchemaNameTransform ? activeSchemaNameTransform(qualifiedName) : qualifiedName,
 			values: schema.enum.map((v) => typeof v === "number" ? v : String(v))
 		};
 	}
@@ -2484,6 +2617,27 @@ function collapseJsonSuffixModels(models, services) {
 		rewriteModelRefs(normalizedModels, services, jsonModel.name, baseModel.name);
 		console.warn(`[oagen] Merged "${jsonModel.name}" into "${baseModel.name}" (${jsonModel.fields.length} fields, superset)`);
 	}
+	for (const { jsonModel, baseModel } of mergeCandidates) {
+		const jsonPrefix = jsonModel.name;
+		const basePrefix = baseModel.name;
+		for (const model of normalizedModels) {
+			if (toRemove.has(model.name)) continue;
+			if (model.name.length <= jsonPrefix.length) continue;
+			if (!model.name.startsWith(jsonPrefix)) continue;
+			const newName = basePrefix + model.name.slice(jsonPrefix.length);
+			const existing = byName.get(newName);
+			if (existing && !toRemove.has(existing.name)) {
+				toRemove.add(model.name);
+				rewriteModelRefs(normalizedModels, services, model.name, newName);
+				console.warn(`[oagen] Collapsed child "${model.name}" into existing "${newName}"`);
+			} else {
+				rewriteModelRefs(normalizedModels, services, model.name, newName);
+				model.name = newName;
+				byName.set(newName, model);
+				console.warn(`[oagen] Renamed child "${jsonPrefix}…" → "${newName}"`);
+			}
+		}
+	}
 	return normalizedModels.filter((m) => !toRemove.has(m.name));
 }
 //#endregion
@@ -2536,8 +2690,10 @@ async function parseSpec(specPath, options) {
 	if (!version.startsWith("3.")) throw new SpecParseError(`Unsupported OpenAPI version: ${version}. oagen requires OpenAPI 3.x`, `Update the spec to OpenAPI 3.0 or 3.1. If you are using Swagger 2.x, convert it first with \`npx swagger2openapi ${specPath}\`.`);
 	const { models, enums } = extractSchemas(spec.components?.schemas, { schemaNameTransform: options?.schemaNameTransform });
 	const { services, inlineModels } = extractOperations(spec.paths, options?.operationIdTransform, spec.components?.schemas);
+	const responseNormalizedModels = mergeInlineResponseModels(models, inlineModels);
+	const fieldInlineModels = extractInlineModelsFromSchemas(spec.components?.schemas);
 	clearSchemaNameTransform();
-	const finalModels = collapseJsonSuffixModels(mergeFieldInlineModels(mergeInlineResponseModels(models, inlineModels), extractInlineModelsFromSchemas(spec.components?.schemas)), services);
+	const finalModels = collapseJsonSuffixModels(mergeFieldInlineModels(responseNormalizedModels, fieldInlineModels), services);
 	collectInlineEnumsFromModels(finalModels, enums);
 	collectInlineEnumsFromOperations(services, enums);
 	const auth = extractAuthSchemes(spec.components?.securitySchemes);
@@ -4146,10 +4302,10 @@ async function extractClassEndLines(source, language) {
 	const tree = safeParse(await getParser(language), source);
 	const map = /* @__PURE__ */ new Map();
 	function processClassNode(node) {
-		const nameNode = node.childForFieldName("name");
+		const nameNode = node.childForFieldName("name") ?? node.children.find((c) => c.type === "type_identifier" || c.type === "identifier");
 		if (!nameNode) return;
 		const name = nameNode.text;
-		const body = node.childForFieldName("body");
+		const body = node.childForFieldName("body") ?? node.children.find((c) => c.type === "class_body" || c.type === "body");
 		const endRow = body ? body.endPosition.row : node.endPosition.row;
 		if (source[body ? body.endIndex - 1 : node.endIndex - 1] === "}") map.set(name, { bodyEndLine: endRow });
 		else map.set(name, { bodyEndLine: endRow + 1 });
@@ -4698,9 +4854,16 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 		if (!existingLines[i].includes("@oagen-ignore-start")) continue;
 		const startIdx = i;
 		while (i < existingLines.length && !existingLines[i].includes("@oagen-ignore-end")) i++;
+		let anchor = "";
+		for (let a = i + 1; a < existingLines.length; a++) if (existingLines[a].trim()) {
+			anchor = existingLines[a].trimStart();
+			break;
+		}
 		blocks.push({
 			containingClass: findContainingClass(existingLines, startIdx),
-			lines: existingLines.slice(startIdx, i + 1)
+			containingScope: findContainingDescribeScope(existingLines, startIdx),
+			lines: existingLines.slice(startIdx, i + 1),
+			anchor
 		});
 	}
 	if (blocks.length === 0) return generatedContent;
@@ -4710,15 +4873,19 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 	const blocksByClass = /* @__PURE__ */ new Map();
 	for (const b of blocks) {
 		if (!blocksByClass.has(b.containingClass)) blocksByClass.set(b.containingClass, []);
-		blocksByClass.get(b.containingClass).push(b.lines);
+		blocksByClass.get(b.containingClass).push({
+			containingScope: b.containingScope,
+			lines: b.lines,
+			anchor: b.anchor
+		});
 	}
 	const replacedClasses = /* @__PURE__ */ new Set();
 	const handledBlockKeys = /* @__PURE__ */ new Set();
 	const replacements = [];
 	for (const [className, classBlocks] of blocksByClass) {
 		let targetClass = className;
-		if (!targetClass) for (const blockLines of classBlocks) {
-			for (const l of blockLines) {
+		if (!targetClass) for (const entry of classBlocks) {
+			for (const l of entry.lines) {
 				const m = l.match(/^(?:export\s+)?class\s+(\w+)/);
 				if (m && classEndLines.has(m[1])) {
 					targetClass = m[1];
@@ -4728,7 +4895,7 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 			if (targetClass) break;
 		}
 		if (!targetClass) continue;
-		if (!classBlocks.some((blockLines) => blockLines.some((l) => {
+		if (!classBlocks.some((entry) => entry.lines.some((l) => {
 			return l.match(/^(?:export\s+)?class\s+(\w+)/)?.[1] === targetClass;
 		}))) continue;
 		const info = classEndLines.get(targetClass);
@@ -4736,9 +4903,9 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 		const startLine = findClassDeclarationStart(result, targetClass, info.bodyEndLine);
 		if (startLine < 0) continue;
 		const content = [];
-		for (const block of classBlocks) {
+		for (const entry of classBlocks) {
 			content.push("");
-			content.push(...block);
+			content.push(...entry.lines);
 		}
 		replacements.push({
 			startLine,
@@ -4753,22 +4920,46 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 	let effectiveClassEndLines = classEndLines;
 	if (replacedClasses.size > 0) effectiveClassEndLines = await extractClassEndLines(result.join("\n"), language);
 	const insertions = [];
+	let insertionOrder = 0;
 	for (const [className, classBlocks] of blocksByClass) {
 		if (handledBlockKeys.has(className) || replacedClasses.has(className)) continue;
 		const info = className ? effectiveClassEndLines.get(className) : void 0;
-		const insertLine = info ? info.bodyEndLine : result.length;
-		const content = [];
-		for (const block of classBlocks) {
-			content.push("");
-			content.push(...block);
+		for (const entry of classBlocks) {
+			let insertLine;
+			if (entry.anchor && !entry.anchor.includes("@oagen-ignore") && /[a-zA-Z]|^\/\*|^\/\//.test(entry.anchor)) {
+				for (let li = 0; li < result.length; li++) if (result[li].trimStart() === entry.anchor) {
+					insertLine = li;
+					break;
+				}
+			}
+			if (insertLine === void 0) if (info) insertLine = info.bodyEndLine;
+			else {
+				const scopeEndLine = entry.containingScope ? findDescribeScopeEndLine(result, entry.containingScope) : void 0;
+				const blockHasImportsFallback = entry.lines.some((l) => /^\s*(import|from)\s/.test(l));
+				if (scopeEndLine !== void 0) insertLine = scopeEndLine;
+				else if (blockHasImportsFallback || hasTopLevelDeclaration(entry.lines)) {
+					let lastImportLine = 0;
+					for (let li = 0; li < result.length; li++) {
+						const trimmed = result[li].trimStart();
+						if (/^(import|from)\s/.test(trimmed)) lastImportLine = li + 1;
+					}
+					insertLine = lastImportLine;
+				} else insertLine = result.length;
+			}
+			if (entry.lines.some((l) => /^\s*import\s/.test(l))) while (insertLine >= 2 && result[insertLine - 1]?.trim() === "" && /^\s*(import|using|from)\s/.test(result[insertLine - 2] ?? "")) insertLine--;
+			const prevLine = insertLine > 0 ? result[insertLine - 1]?.trimStart() ?? "" : "";
+			const blockContent = /^import\s/.test(prevLine) || /^using\s/.test(prevLine) || /^from\s/.test(prevLine) || insertLine > 0 && prevLine === "" ? [...entry.lines] : ["", ...entry.lines];
+			if ((result[insertLine]?.trimStart() ?? "").startsWith("///")) blockContent.push("");
+			insertions.push({
+				line: insertLine,
+				order: insertionOrder++,
+				content: blockContent
+			});
 		}
-		insertions.push({
-			line: insertLine,
-			content
-		});
 	}
-	insertions.sort((a, b) => b.line - a.line);
+	insertions.sort((a, b) => b.line - a.line || b.order - a.order);
 	for (const ins of insertions) result.splice(ins.line, 0, ...ins.content);
+	removeDuplicateImportsCoveredByIgnoreBlocks(result);
 	return result.join("\n");
 }
 /**
@@ -4796,12 +4987,47 @@ function stripIgnoreRegions(lines) {
 }
 /** Scan backwards from `lineIdx` to find the nearest class declaration name. */
 function findContainingClass(lines, lineIdx) {
+	if (/^\S/.test(lines[lineIdx] ?? "")) return "";
 	for (let j = lineIdx - 1; j >= 0; j--) {
-		const m = lines[j].match(/^\s*(?:export\s+)?class\s+(\w+)/);
+		const m = lines[j].match(/^\s*(?:(?:export|public|private|protected|internal|abstract|sealed|static|partial)\s+)*class\s+(\w+)/);
 		if (m) return m[1];
 	}
 	return "";
 }
+function findContainingDescribeScope(lines, lineIdx) {
+	const markerLine = lines[lineIdx] ?? "";
+	if (/^\S/.test(markerLine)) return "";
+	const markerIndent = leadingSpaces(markerLine);
+	for (let j = lineIdx - 1; j >= 0; j--) {
+		const line = lines[j];
+		if (leadingSpaces(line) >= markerIndent) continue;
+		const match = line.match(/^\s*describe\((['"`])(.+?)\1\s*,/);
+		if (match) return match[2];
+		if (/^\s*(?:export\s+)?class\s+\w+/.test(line)) return "";
+	}
+	return "";
+}
+function findDescribeScopeEndLine(lines, scopeName) {
+	for (let i = 0; i < lines.length; i++) {
+		const match = lines[i].match(/^\s*describe\((['"`])(.+?)\1\s*,/);
+		if (!match || match[2] !== scopeName) continue;
+		let depth = 0;
+		for (let j = i; j < lines.length; j++) {
+			depth += countChar(lines[j], "{");
+			depth -= countChar(lines[j], "}");
+			if (j > i && depth <= 0) return j;
+		}
+	}
+}
+function leadingSpaces(line) {
+	return line.match(/^\s*/)?.[0].length ?? 0;
+}
+function countChar(line, char) {
+	return [...line].filter((c) => c === char).length;
+}
+function hasTopLevelDeclaration(lines) {
+	return lines.some((line) => /^(?:export\s+)?(?:interface|type|class|function|const|let|var|enum)\s+\w+/.test(line.trim()));
+}
 /**
 * Find the start line of a class declaration (including decorators above it)
 * by scanning backwards from `beforeLine`.
@@ -4879,9 +5105,13 @@ function collectTsImports(lines) {
 			const mod = m[4];
 			if (defaultName) out.defaults.set(mod, defaultName);
 			const names = namesRaw.split(",").map((s) => s.trim().replace(/\s+as\s+\w+$/, "")).filter(Boolean);
-			const target = isTypeOnly ? out.typeOnly : out.named;
-			if (!target.has(mod)) target.set(mod, /* @__PURE__ */ new Set());
-			for (const n of names) target.get(mod).add(n);
+			for (const rawName of names) {
+				const isInlineTypeOnly = rawName.startsWith("type ");
+				const name = rawName.replace(/^type\s+/, "");
+				const target = isTypeOnly || isInlineTypeOnly ? out.typeOnly : out.named;
+				if (!target.has(mod)) target.set(mod, /* @__PURE__ */ new Set());
+				target.get(mod).add(name);
+			}
 			continue;
 		}
 		m = normalized.match(/^import\s+(?:type\s+)?(\w+)\s+from\s+['"]([^'"]+)['"]$/);
@@ -4904,12 +5134,99 @@ function collectTsImports(lines) {
 *
 * Mutates `resultLines` in place.
 */
+function filterOutIgnoreRegions(lines) {
+	const out = [];
+	let skipping = false;
+	for (const line of lines) {
+		if (!skipping && line.includes("@oagen-ignore-start")) {
+			skipping = true;
+			continue;
+		}
+		if (skipping) {
+			if (line.includes("@oagen-ignore-end")) skipping = false;
+			continue;
+		}
+		out.push(line);
+	}
+	return out;
+}
+function collectIgnoreRegionUsageText(lines) {
+	const out = [];
+	let skipping = false;
+	for (const line of lines) {
+		if (!skipping && line.includes("@oagen-ignore-start")) {
+			skipping = true;
+			continue;
+		}
+		if (!skipping) continue;
+		if (/^\s*(import|from)\s/.test(line)) continue;
+		out.push(line);
+		if (line.includes("@oagen-ignore-end")) skipping = false;
+	}
+	return out.join("\n");
+}
+function removeDuplicateImportsCoveredByIgnoreBlocks(lines) {
+	const ignoredImports = /* @__PURE__ */ new Set();
+	const importStatements = collectImportStatements(lines);
+	for (const stmt of importStatements) if (stmt.inIgnore) ignoredImports.add(normalizeImportStatement(stmt.lines));
+	if (ignoredImports.size === 0) return;
+	for (const stmt of [...importStatements].reverse()) {
+		if (stmt.inIgnore) continue;
+		if (ignoredImports.has(normalizeImportStatement(stmt.lines))) lines.splice(stmt.start, stmt.end - stmt.start + 1);
+	}
+}
+function collectImportStatements(lines) {
+	const statements = [];
+	let inIgnore = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (!inIgnore && line.includes("@oagen-ignore-start")) {
+			inIgnore = true;
+			continue;
+		}
+		if (inIgnore && line.includes("@oagen-ignore-end")) {
+			inIgnore = false;
+			continue;
+		}
+		if (!isImportLine(line)) continue;
+		const start = i;
+		let end = i;
+		const statementLines = [line];
+		if ((line.match(/[({]/g) ?? []).length > (line.match(/[)}]/g) ?? []).length) {
+			while (end + 1 < lines.length) {
+				end++;
+				statementLines.push(lines[end]);
+				if ((lines[end].match(/[)}]/g) ?? []).length > 0 && /\bfrom\b/.test(lines[end])) break;
+			}
+			i = end;
+		}
+		statements.push({
+			start,
+			end,
+			lines: statementLines,
+			inIgnore
+		});
+	}
+	return statements;
+}
+function normalizeImportStatement(lines) {
+	return lines.join("\n").replace(/,\s*}/g, " }").replace(/\s+/g, " ").trim();
+}
+function isImportLine(line) {
+	const trimmed = line.trim();
+	return /^import(\s|$)/.test(trimmed) || /^from\s+/.test(trimmed) || /^use\s+[\w\\]/.test(trimmed) || /^require(_relative)?\s+['"]/.test(trimmed);
+}
+function identifierUsed(source, identifier) {
+	return new RegExp(`\\b${identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(source);
+}
 function spliceExtraImports(existingLines, resultLines) {
+	const existingOutsideIgnore = filterOutIgnoreRegions(existingLines);
+	const ignoreRegionText = collectIgnoreRegionUsageText(existingLines);
 	const isPythonSimpleImport = (l) => /^import\s+\w/.test(l) && !/\sfrom\s/.test(l) && !/[{}]/.test(l);
-	const existingSimple = new Set(existingLines.filter(isPythonSimpleImport).map((l) => l.trim()));
+	const existingSimple = new Set(existingOutsideIgnore.filter(isPythonSimpleImport).map((l) => l.trim()));
 	const generatedSimple = new Set(resultLines.filter(isPythonSimpleImport).map((l) => l.trim()));
 	const extraSimple = [...existingSimple].filter((l) => !generatedSimple.has(l));
-	const existingFrom = collectFromImports(existingLines);
+	const existingFrom = collectFromImports(existingOutsideIgnore);
 	const generatedFrom = collectFromImports(resultLines);
 	const allGeneratedIds = /* @__PURE__ */ new Set();
 	for (const ids of generatedFrom.values()) for (const id of ids) allGeneratedIds.add(id);
@@ -4924,29 +5241,33 @@ function spliceExtraImports(existingLines, resultLines) {
 			if (extra.length > 0) extraFromLines.push(`from ${mod} import ${extra.join(", ")}`);
 		}
 	}
-	const existingTs = collectTsImports(existingLines);
+	const existingTs = collectTsImports(existingOutsideIgnore);
 	const generatedTs = collectTsImports(resultLines);
 	const extraTsLines = [];
 	for (const mod of existingTs.sideEffects) if (!generatedTs.sideEffects.has(mod)) extraTsLines.push(`import '${mod}';`);
 	for (const [mod, name] of existingTs.defaults) {
 		if (generatedTs.defaults.has(mod)) continue;
+		if (!identifierUsed(ignoreRegionText, name)) continue;
 		extraTsLines.push(`import ${name} from '${mod}';`);
 	}
-	for (const [mod, name] of existingTs.namespaces) if (!generatedTs.namespaces.has(mod)) extraTsLines.push(`import * as ${name} from '${mod}';`);
+	for (const [mod, name] of existingTs.namespaces) {
+		if (!identifierUsed(ignoreRegionText, name)) continue;
+		if (!generatedTs.namespaces.has(mod)) extraTsLines.push(`import * as ${name} from '${mod}';`);
+	}
 	for (const [mod, existIds] of existingTs.named) {
 		const genIds = generatedTs.named.get(mod) ?? /* @__PURE__ */ new Set();
 		const genTypeIds = generatedTs.typeOnly.get(mod) ?? /* @__PURE__ */ new Set();
-		const extra = [...existIds].filter((id) => !genIds.has(id) && !genTypeIds.has(id));
+		const extra = [...existIds].filter((id) => !genIds.has(id) && !genTypeIds.has(id) && identifierUsed(ignoreRegionText, id));
 		if (extra.length > 0) extraTsLines.push(`import { ${extra.join(", ")} } from '${mod}';`);
 	}
 	for (const [mod, existIds] of existingTs.typeOnly) {
 		const genIds = generatedTs.typeOnly.get(mod) ?? /* @__PURE__ */ new Set();
 		const genNamedIds = generatedTs.named.get(mod) ?? /* @__PURE__ */ new Set();
-		const extra = [...existIds].filter((id) => !genIds.has(id) && !genNamedIds.has(id));
+		const extra = [...existIds].filter((id) => !genIds.has(id) && !genNamedIds.has(id) && identifierUsed(ignoreRegionText, id));
 		if (extra.length > 0) extraTsLines.push(`import type { ${extra.join(", ")} } from '${mod}';`);
 	}
 	const isPhpUseImport = (l) => /^use\s+[\w\\]+\\[\w\\]*(\s+as\s+\w+)?\s*;?$/.test(l);
-	const existingPhpUse = new Set(existingLines.filter(isPhpUseImport).map((l) => l.trim()));
+	const existingPhpUse = new Set(existingOutsideIgnore.filter(isPhpUseImport).map((l) => l.trim()));
 	const generatedPhpUse = new Set(resultLines.filter(isPhpUseImport).map((l) => l.trim()));
 	const extraPhpUse = [...existingPhpUse].filter((l) => !generatedPhpUse.has(l));
 	const rubyRequireRe = /^(require(?:_relative)?)\s+['"]([^'"]+)['"]\s*$/;
@@ -4961,7 +5282,7 @@ function spliceExtraImports(existingLines, resultLines) {
 	}
 	const seenExistingKeys = /* @__PURE__ */ new Set();
 	const extraRubyRequire = [];
-	for (const l of existingLines) {
+	for (const l of existingOutsideIgnore) {
 		const key = rubyRequireKey(l);
 		if (!key) continue;
 		if (generatedRubyRequireKeys.has(key)) continue;
@@ -5174,7 +5495,11 @@ function collectReferencedNames(services, models) {
 		for (const err of op.errors) if (err.type) collectFromTypeRef(err.type);
 		if (op.successResponses) for (const sr of op.successResponses) collectFromTypeRef(sr.type);
 	}
-	for (const model of models) if (isDiscriminatedModel(model)) referencedModels.add(model.name);
+	for (const model of models) {
+		if (isDiscriminatedModel(model)) referencedModels.add(model.name);
+		const disc = model.discriminator;
+		if (disc?.mapping) for (const variantName of Object.values(disc.mapping)) referencedModels.add(variantName);
+	}
 	const modelsByName = new Map(models.map((m) => [m.name, m]));
 	const visited = /* @__PURE__ */ new Set();
 	const queue = [...referencedModels];
@@ -5489,6 +5814,7 @@ async function readManifest(dir) {
 }
 /** Write `.oagen-manifest.json` to a directory with sorted paths. */
 async function writeManifest(dir, opts) {
+	const manifestPath = path$1.join(dir, MANIFEST_FILENAME);
 	const manifest = {
 		version: MANIFEST_VERSION,
 		language: opts.language,
@@ -5503,10 +5829,16 @@ async function writeManifest(dir, opts) {
 		files: [...new Set(opts.files)].sort(),
 		...opts.operations !== void 0 ? { operations: opts.operations } : {}
 	};
-	const manifestPath = path$1.join(dir, MANIFEST_FILENAME);
+	const previous = await readManifest(dir);
+	if (previous && sameManifestExceptGeneratedAt(previous, manifest)) manifest.generatedAt = previous.generatedAt;
 	await fs.mkdir(dir, { recursive: true });
 	await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
 }
+function sameManifestExceptGeneratedAt(a, b) {
+	const { generatedAt: _aGeneratedAt, ...aComparable } = a;
+	const { generatedAt: _bGeneratedAt, ...bComparable } = b;
+	return JSON.stringify(aComparable) === JSON.stringify(bComparable);
+}
 /** Return the set of previous paths no longer present in the current emission. */
 function computeStalePaths(prev, currentPaths) {
 	const current = new Set(currentPaths);