@workos/oagen 0.5.0 → 0.7.0

package/dist/{diff-CSy3g-Bq.mjs → diff-BYadQQV7.mjs}

@@ -94,7 +94,7 @@ function deriveMethodName(op, _service) {
 		const termIdx = segments.lastIndexOf(staticSegments[staticSegments.length - 1]);
 		if (segments.slice(penIdx + 1, termIdx).some((s) => s.startsWith("{"))) resource = `${toSnake(singularize(penultimate))}_${resource}`;
 	}
-	const noun = trailingParam ? singularize(resource) : resource;
+	const noun = trailingParam || verb === "create" ? singularize(resource) : resource;
 	return `${verb}_${verb === "list" ? resource : noun}`;
 }
 /**
@@ -120,7 +120,7 @@ function resolveOperations(spec, hints, mountRules) {
 			defaults: sh.defaults ?? {},
 			inferFromClient: sh.inferFromClient ?? [],
 			exposedParams: sh.exposedParams ?? [],
-			optionalParams: [],
+			optionalParams: sh.optionalParams ?? [],
 			responseModelName: resolveResponseModelName(op)
 		}));
 		resolved.push({
@@ -130,7 +130,8 @@ function resolveOperations(spec, hints, mountRules) {
 			mountOn,
 			wrappers,
 			defaults: hint?.defaults ?? {},
-			inferFromClient: hint?.inferFromClient ?? []
+			inferFromClient: hint?.inferFromClient ?? [],
+			urlBuilder: hint?.urlBuilder ?? false
 		});
 	}
 	return resolved;
@@ -675,6 +676,41 @@ function findPrecedingKdoc(children, index, source) {
 	}
 	return null;
 }
+function extractKotlinClassMembers(classBody, source) {
+	const members = [];
+	const children = classBody.namedChildren;
+	for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		let memberName = null;
+		if (child.type === "property_declaration") memberName = child.children.find((c) => c.type === "variable_declaration")?.children.find((c) => c.type === "simple_identifier")?.text ?? null;
+		else if (child.type === "function_declaration") memberName = child.children.find((c) => c.type === "simple_identifier")?.text ?? null;
+		else if (child.type === "companion_object") memberName = "companion";
+		if (!memberName) continue;
+		let endIdx = child.endIndex;
+		if (child.type === "property_declaration") while (i + 1 < children.length) {
+			const next = children[i + 1];
+			if (next.type === "getter" || next.type === "setter") {
+				endIdx = next.endIndex;
+				i++;
+			} else break;
+		}
+		let startIdx = child.startIndex;
+		for (let k = i - 1; k >= 0; k--) {
+			const prev = children[k];
+			if (prev.type === "multiline_comment") {
+				if (source.slice(prev.startIndex, prev.endIndex).startsWith("/**")) startIdx = prev.startIndex;
+				break;
+			}
+			if (prev.type === "line_comment") continue;
+			break;
+		}
+		members.push({
+			key: memberName,
+			text: source.slice(startIdx, endIdx)
+		});
+	}
+	return members;
+}
 const kotlinMergeAdapter = {
 	language: "kotlin",
 	grammarModule: "tree-sitter-kotlin",
@@ -715,6 +751,33 @@ const kotlinMergeAdapter = {
 	renderImports(imports) {
 		return imports.map((entry) => entry.text);
 	},
+	shouldSkipDeepMerge(_symbolName, existingMemberKeys, newMembers) {
+		const newText = newMembers.map((m) => m.text).join("\n");
+		for (const match of newText.matchAll(/this\.(\w+)/g)) {
+			const propName = match[1];
+			if (propName && !existingMemberKeys.has(propName)) return true;
+		}
+		return false;
+	},
+	extractMembers(tree, source) {
+		const result = /* @__PURE__ */ new Map();
+		for (const child of tree.rootNode.children) {
+			if (child.type !== "class_declaration") continue;
+			const nameNode = child.children.find((c) => c.type === "type_identifier");
+			if (!nameNode) continue;
+			const body = child.children.find((c) => c.type === "class_body");
+			if (!body) continue;
+			const members = extractKotlinClassMembers(body, source);
+			const firstMember = body.firstNamedChild;
+			const memberIndent = firstMember ? " ".repeat(firstMember.startPosition.column) : void 0;
+			result.set(nameNode.text, {
+				members,
+				bodyEndLine: body.endPosition.row,
+				memberIndent
+			});
+		}
+		return result;
+	},
 	extractDocstrings(tree, source) {
 		const result = /* @__PURE__ */ new Map();
 		const rootChildren = tree.rootNode.children;
@@ -897,6 +960,7 @@ const nodeMergeAdapter = {
 		const newText = newMembers.map((m) => m.text).join("\n");
 		for (const match of newText.matchAll(/this\.(\w+)/g)) {
 			const propName = match[1];
+			if (propName === "workos") continue;
 			if (propName && !existingMemberKeys.has(propName)) return true;
 		}
 		return false;
@@ -1546,6 +1610,40 @@ function buildIgnoredSymbolNames(docstrings, regions) {
 	for (const [name, info] of docstrings) if (regions.some((r) => info.declStartIndex >= r.startIndex && info.declStartIndex <= r.endIndex)) ignored.add(name);
 	return ignored;
 }
+function clampIndex(value, contentLength) {
+	if (!Number.isFinite(value)) return 0;
+	if (value < 0) return 0;
+	if (value > contentLength) return contentLength;
+	return value;
+}
+/**
+* Resolve the declaration line start for insertion using the current content,
+* instead of relying on parser column arithmetic. This avoids misplaced inserts
+* when parser columns/offsets drift.
+*/
+function declarationLineStart(content, declStartIndex) {
+	const idx = clampIndex(declStartIndex, content.length);
+	const prevNewline = content.lastIndexOf("\n", Math.max(0, idx - 1));
+	return prevNewline === -1 ? 0 : prevNewline + 1;
+}
+/**
+* Resolve a docstring range by searching for the nearest matching text before
+* the declaration start. Falls back to parser-provided offsets when search fails.
+*/
+function resolveDocRange(content, docText, declStartIndex, fallbackStart, fallbackEnd) {
+	const safeDecl = clampIndex(declStartIndex, content.length);
+	const safeFallbackStart = clampIndex(fallbackStart, content.length);
+	const safeFallbackEnd = clampIndex(fallbackEnd, content.length);
+	const found = content.lastIndexOf(docText, safeDecl);
+	if (found !== -1) return {
+		start: found,
+		end: found + docText.length
+	};
+	return {
+		start: safeFallbackStart,
+		end: safeFallbackEnd
+	};
+}
 /**
 * Check if a tree-sitter grammar is configured for the given language.
 */
@@ -1594,15 +1692,17 @@ async function extractClassEndLines(source, language) {
 		if (source[body ? body.endIndex - 1 : node.endIndex - 1] === "}") map.set(name, { bodyEndLine: endRow });
 		else map.set(name, { bodyEndLine: endRow + 1 });
 	}
-	for (const child of tree.rootNode.children) {
-		if (child.type === "class_definition" || child.type === "class_declaration") processClassNode(child);
-		if (child.type === "decorated_definition") {
-			for (const inner of child.namedChildren) if (inner.type === "class_definition") processClassNode(inner);
+	function walk(node) {
+		if (node.type === "class" || node.type === "class_definition" || node.type === "class_declaration") processClassNode(node);
+		if (node.type === "decorated_definition") {
+			for (const inner of node.namedChildren) if (inner.type === "class_definition") processClassNode(inner);
 		}
-		if (child.type === "export_statement") {
-			for (const inner of child.namedChildren) if (inner.type === "class_declaration") processClassNode(inner);
+		if (node.type === "export_statement") {
+			for (const inner of node.namedChildren) if (inner.type === "class_declaration") processClassNode(inner);
 		}
+		for (const child of node.namedChildren) walk(child);
 	}
+	for (const child of tree.rootNode.children) walk(child);
 	return map;
 }
 /**
@@ -1757,10 +1857,10 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 			if (newMembers.length > 0) {
 				if (adapter.shouldSkipDeepMerge?.(symbolName, existingMemberKeys, newMembers)) continue;
 				const indent = existSymbol.memberIndent ?? "  ";
-				const insertText = newMembers.map((m) => indent + m.text).join("\n");
+				const insertText = newMembers.map((m) => indent + m.text).join("\n\n");
 				insertions.push({
 					line: existSymbol.bodyEndLine,
-					text: insertText
+					text: "\n" + insertText
 				});
 				deepAdded += newMembers.length;
 			}
@@ -1822,15 +1922,16 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 			if (genDoc) if (existInfo.docstring) {
 				if (!existInfo.docstring.text.includes("@oagen-ignore") && existInfo.docstring.text !== genDoc.text) {
 					const newText = preserveDeprecatedTags(existInfo.docstring.text, genDoc.text);
+					const range = resolveDocRange(result, existInfo.docstring.text, existInfo.declStartIndex, existInfo.docstring.startIndex, existInfo.docstring.endIndex);
 					edits.push({
-						start: existInfo.docstring.startIndex,
-						end: existInfo.docstring.endIndex,
+						start: range.start,
+						end: range.end,
 						newText
 					});
 					docstringUpdates++;
 				}
 			} else {
-				const lineStart = existInfo.declStartIndex - existInfo.declColumn;
+				const lineStart = declarationLineStart(result, existInfo.declStartIndex);
 				const indent = " ".repeat(existInfo.declColumn);
 				edits.push({
 					start: lineStart,
@@ -1848,15 +1949,16 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 				if (existMember.docstring) {
 					if (!existMember.docstring.text.includes("@oagen-ignore") && existMember.docstring.text !== genMember.docstring.text) {
 						const newText = preserveDeprecatedTags(existMember.docstring.text, genMember.docstring.text);
+						const range = resolveDocRange(result, existMember.docstring.text, existMember.declStartIndex, existMember.docstring.startIndex, existMember.docstring.endIndex);
 						edits.push({
-							start: existMember.docstring.startIndex,
-							end: existMember.docstring.endIndex,
+							start: range.start,
+							end: range.end,
 							newText
 						});
 						docstringUpdates++;
 					}
 				} else {
-					const lineStart = existMember.declStartIndex - existMember.declColumn;
+					const lineStart = declarationLineStart(result, existMember.declStartIndex);
 					const indent = " ".repeat(existMember.declColumn);
 					edits.push({
 						start: lineStart,
@@ -1901,15 +2003,16 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 					if (existMember.docstring.text.includes("@oagen-ignore")) continue;
 					if (existMember.docstring.text !== genMember.docstring.text) {
 						const newText = preserveDeprecatedTags(existMember.docstring.text, genMember.docstring.text);
+						const range = resolveDocRange(result, existMember.docstring.text, existMember.declStartIndex, existMember.docstring.startIndex, existMember.docstring.endIndex);
 						edits.push({
-							start: existMember.docstring.startIndex,
-							end: existMember.docstring.endIndex,
+							start: range.start,
+							end: range.end,
 							newText
 						});
 						docstringUpdates++;
 					}
 				} else {
-					const lineStart = existMember.declStartIndex - existMember.declColumn;
+					const lineStart = declarationLineStart(result, existMember.declStartIndex);
 					const indent = " ".repeat(existMember.declColumn);
 					edits.push({
 						start: lineStart,
@@ -2082,7 +2185,7 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 		});
 	}
 	if (blocks.length === 0) return generatedContent;
-	const result = [...generatedLines];
+	const result = stripIgnoreRegions(generatedLines);
 	spliceExtraImports(existingLines, result);
 	const classEndLines = await extractClassEndLines(result.join("\n"), language);
 	const blocksByClass = /* @__PURE__ */ new Map();
@@ -2149,10 +2252,33 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 	for (const ins of insertions) result.splice(ins.line, 0, ...ins.content);
 	return result.join("\n");
 }
+/**
+* Remove every `@oagen-ignore-start`..`@oagen-ignore-end` region from the
+* supplied lines, collapsing stretches of blank lines that get left behind.
+* Used to drop generator-emitted seed blocks before splicing the on-disk
+* versions back in — otherwise every regen doubles up.
+*/
+function stripIgnoreRegions(lines) {
+	const out = [];
+	let skipping = false;
+	for (const line of lines) {
+		if (!skipping && line.includes("@oagen-ignore-start")) {
+			skipping = true;
+			while (out.length > 0 && out[out.length - 1].trim() === "") out.pop();
+			continue;
+		}
+		if (skipping) {
+			if (line.includes("@oagen-ignore-end")) skipping = false;
+			continue;
+		}
+		out.push(line);
+	}
+	return out;
+}
 /** Scan backwards from `lineIdx` to find the nearest class declaration name. */
 function findContainingClass(lines, lineIdx) {
 	for (let j = lineIdx - 1; j >= 0; j--) {
-		const m = lines[j].match(/^(?:export\s+)?class\s+(\w+)/);
+		const m = lines[j].match(/^\s*(?:export\s+)?class\s+(\w+)/);
 		if (m) return m[1];
 	}
 	return "";
@@ -2162,7 +2288,7 @@ function findContainingClass(lines, lineIdx) {
 * by scanning backwards from `beforeLine`.
 */
 function findClassDeclarationStart(lines, className, beforeLine) {
-	const classPattern = new RegExp(`^(?:export\\s+)?class\\s+${className}\\b`);
+	const classPattern = new RegExp(`^\\s*(?:export\\s+)?class\\s+${className}\\b`);
 	for (let i = beforeLine - 1; i >= 0; i--) {
 		if (!classPattern.test(lines[i])) continue;
 		let start = i;
@@ -2241,7 +2367,9 @@ function buildEmitterContext(spec, options) {
 		outputDir: options.outputDir,
 		apiSurface: options.apiSurface,
 		overlayLookup: options.overlayLookup,
-		resolvedOperations: resolveOperations(spec, options.operationHints, options.mountRules)
+		resolvedOperations: resolveOperations(spec, options.operationHints, options.mountRules),
+		targetDir: options.target,
+		priorTargetManifestPaths: options.priorTargetManifestPaths
 	};
 }
 /**
@@ -2360,7 +2488,7 @@ function resolveImportPath(fromFilePath, importModulePath, knownPaths) {
 */
 function isRootFile(filePath) {
 	if (filePath.includes("/fixtures/")) return false;
-	if (filePath.endsWith(".spec.ts") || filePath.endsWith(".test.ts")) return false;
+	if (filePath.endsWith(".spec.ts") || filePath.endsWith(".test.ts")) return true;
 	if (filePath.includes("/serializers/")) return false;
 	if (filePath.includes("/interfaces/") && !filePath.endsWith("/index.ts")) return false;
 	return true;
@@ -2489,7 +2617,8 @@ async function resolveFileToDirectoryConflicts(files, targetDir) {
 	};
 }
 async function integrateGeneratedFiles(opts) {
-	const { files: resolved, removals } = await resolveFileToDirectoryConflicts(await treeShakeFiles(mapFilesForTargetIntegration(opts.files, opts.language), opts.language), opts.targetDir);
+	const mapped = mapFilesForTargetIntegration(opts.files, opts.language);
+	const { files: resolved, removals } = await resolveFileToDirectoryConflicts(await treeShakeFiles(mapped, opts.language), opts.targetDir);
 	const result = await writeFiles(resolved, opts.targetDir, {
 		language: opts.language,
 		header: opts.header
@@ -2497,7 +2626,10 @@ async function integrateGeneratedFiles(opts) {
 	for (const filePath of removals) try {
 		await fs.unlink(filePath);
 	} catch {}
-	return result;
+	return {
+		...result,
+		emittedPaths: mapped.map((f) => f.path)
+	};
 }
 //#endregion
 //#region src/engine/formatter.ts
@@ -2520,6 +2652,7 @@ async function formatTargetFiles(emitter, targetDir, filePaths) {
 	if (!formatCmd) return;
 	const absolutePaths = filePaths.map((f) => path$1.resolve(targetDir, f));
 	const batchSize = formatCmd.batchSize ?? 100;
+	process.stderr.write(`[oagen] formatting ${absolutePaths.length} file(s) with ${formatCmd.cmd} (batch ${batchSize})\n`);
 	for (let i = 0; i < absolutePaths.length; i += batchSize) {
 		const batch = absolutePaths.slice(i, i + batchSize);
 		try {
@@ -2528,13 +2661,148 @@ async function formatTargetFiles(emitter, targetDir, filePaths) {
 				maxBuffer: 10 * 1024 * 1024,
 				timeout: 12e4
 			});
-		} catch {}
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`[oagen] formatter batch failed: ${msg}\n`);
+		}
+	}
+}
+//#endregion
+//#region src/engine/manifest.ts
+/**
+* Prune-manifest support for `oagen generate`.
+*
+* The manifest records every auto-generated file emitted on the previous run,
+* relative to the directory it lives in (either the `--output` standalone dir
+* or the `--target` integration dir).  On the next run we diff the previous
+* list against the current emission set and delete anything that's no longer
+* produced — preventing stale-file accumulation across regens.
+*
+* Design notes:
+*  - The manifest is versioned so future format changes can be handled safely.
+*  - Paths are stored sorted for deterministic diffs in git.
+*  - Deletion is gated on a header guard when one is available: we only remove
+*    files whose contents start with the auto-generated header.  This protects
+*    a hand-maintained file that happens to share a name with a previously
+*    generated one (extremely rare, but worth catching).
+*  - On first adoption (no previous manifest), pruning is skipped and a
+*    one-line notice is printed — no surprise deletions.
+*/
+const MANIFEST_FILENAME = ".oagen-manifest.json";
+const MANIFEST_VERSION = 1;
+/** Read `.oagen-manifest.json` from a directory.  Returns null if absent or malformed. */
+async function readManifest(dir) {
+	const manifestPath = path$1.join(dir, MANIFEST_FILENAME);
+	let raw;
+	try {
+		raw = await fs.readFile(manifestPath, "utf-8");
+	} catch {
+		return null;
+	}
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.version !== "number" || typeof parsed.language !== "string" || typeof parsed.generatedAt !== "string" || !Array.isArray(parsed.files) || !parsed.files.every((p) => typeof p === "string")) return null;
+		if (parsed.version > MANIFEST_VERSION) {
+			console.warn(`[oagen] ${MANIFEST_FILENAME} schema version ${parsed.version} is newer than supported (${MANIFEST_VERSION}); ignoring for pruning.`);
+			return null;
+		}
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+/** Write `.oagen-manifest.json` to a directory with sorted paths. */
+async function writeManifest(dir, opts) {
+	const manifest = {
+		version: MANIFEST_VERSION,
+		language: opts.language,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		files: [...new Set(opts.files)].sort()
+	};
+	const manifestPath = path$1.join(dir, MANIFEST_FILENAME);
+	await fs.mkdir(dir, { recursive: true });
+	await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+}
+/** Return the set of previous paths no longer present in the current emission. */
+function computeStalePaths(prev, currentPaths) {
+	const current = new Set(currentPaths);
+	return prev.files.filter((p) => !current.has(p)).sort();
+}
+/**
+* Delete stale files from `dir`.
+*
+* When `header` is provided, a file is only deleted if its contents start with
+* that header — so hand-maintained files that somehow collide with a previously
+* generated path can't be clobbered.  When `header` is omitted, the guard is
+* skipped (useful for non-source artifacts like fixture JSON).
+*
+* Returns lists for reporting.  Empty parent directories are removed after
+* deletion, up to (but not including) `dir` itself.
+*/
+async function pruneStaleFiles(dir, paths, opts = {}) {
+	const pruned = [];
+	const preserved = [];
+	const missing = [];
+	for (const relPath of paths) {
+		const fullPath = path$1.join(dir, relPath);
+		let content;
+		try {
+			content = await fs.readFile(fullPath, "utf-8");
+		} catch {
+			missing.push(relPath);
+			continue;
+		}
+		if (opts.header && !content.startsWith(opts.header)) {
+			preserved.push(relPath);
+			continue;
+		}
+		try {
+			await fs.unlink(fullPath);
+			pruned.push(relPath);
+		} catch {
+			missing.push(relPath);
+			continue;
+		}
+		await removeEmptyParents(path$1.dirname(fullPath), dir);
+	}
+	return {
+		pruned,
+		preserved,
+		missing
+	};
+}
+/**
+* Walk up from `startDir` removing empty directories until we hit `stopDir`
+* (exclusive) or a non-empty directory.  Silently ignores errors.
+*/
+async function removeEmptyParents(startDir, stopDir) {
+	let current = path$1.resolve(startDir);
+	const stop = path$1.resolve(stopDir);
+	while (current.startsWith(stop + path$1.sep) && current !== stop) {
+		let entries;
+		try {
+			entries = await fs.readdir(current);
+		} catch {
+			return;
+		}
+		if (entries.length > 0) return;
+		try {
+			await fs.rmdir(current);
+		} catch {
+			return;
+		}
+		current = path$1.dirname(current);
 	}
 }
 //#endregion
 //#region src/engine/orchestrator.ts
 async function generate(spec, emitter, options) {
-	const { files: withHeaders, header } = generateFiles(spec, emitter, options);
+	const targetManifestForCtx = options.target && !options.noPrune ? await readManifest(options.target) : null;
+	const priorTargetManifestPaths = targetManifestForCtx ? new Set(targetManifestForCtx.files) : void 0;
+	const { files: withHeaders, header } = generateFiles(spec, emitter, {
+		...options,
+		priorTargetManifestPaths
+	});
 	if (options.dryRun) {
 		if (options.target) {
 			console.log(`\nTarget integration (${options.target}):`);
@@ -2542,13 +2810,25 @@ async function generate(spec, emitter, options) {
 		}
 		return withHeaders;
 	}
+	const outputPrevManifest = options.noPrune ? null : await readManifest(options.outputDir);
 	const writeResult = await writeFiles(withHeaders, options.outputDir, {
 		language: emitter.language,
 		header
 	});
 	if (writeResult.merged.length > 0) console.log(`Merged into ${writeResult.merged.length} existing files (additive only)`);
 	if (writeResult.ignored.length > 0) console.log(`Ignored ${writeResult.ignored.length} files (@oagen-ignore-file)`);
+	const outputEmittedPaths = withHeaders.map((f) => f.path);
+	await applyManifestPrune({
+		dir: options.outputDir,
+		label: "Output",
+		prevManifest: outputPrevManifest,
+		currentPaths: outputEmittedPaths,
+		language: emitter.language,
+		header,
+		noPrune: options.noPrune
+	});
 	if (options.target) {
+		const targetPrevManifest = targetManifestForCtx;
 		const targetResult = await integrateGeneratedFiles({
 			files: withHeaders,
 			language: emitter.language,
@@ -2558,6 +2838,15 @@ async function generate(spec, emitter, options) {
 		if (targetResult.written.length > 0) console.log(`Target: created ${targetResult.written.length} new files`);
 		if (targetResult.merged.length > 0) console.log(`Target: merged into ${targetResult.merged.length} existing files (additive only)`);
 		if (targetResult.skipped.length > 0) console.log(`Target: skipped ${targetResult.skipped.length} files (excluded or no grammar)`);
+		await applyManifestPrune({
+			dir: options.target,
+			label: "Target",
+			prevManifest: targetPrevManifest,
+			currentPaths: targetResult.emittedPaths,
+			language: emitter.language,
+			header,
+			noPrune: options.noPrune
+		});
 		const allTargetFiles = [
 			...targetResult.written,
 			...targetResult.merged,
@@ -2567,6 +2856,40 @@ async function generate(spec, emitter, options) {
 	}
 	return withHeaders;
 }
+/**
+* Prune files recorded in the previous manifest but absent from the current emission,
+* then write the fresh manifest.  Safe on first adoption (no previous manifest).
+*/
+async function applyManifestPrune(opts) {
+	if (opts.noPrune) {
+		await writeManifest(opts.dir, {
+			language: opts.language,
+			files: opts.currentPaths
+		});
+		return;
+	}
+	if (!opts.prevManifest) {
+		console.log(`${opts.label}: no ${MANIFEST_FILENAME} found — skipping prune (this baseline manifest will be written now).`);
+		await writeManifest(opts.dir, {
+			language: opts.language,
+			files: opts.currentPaths
+		});
+		return;
+	}
+	const stale = computeStalePaths(opts.prevManifest, opts.currentPaths);
+	if (stale.length > 0) {
+		const { pruned, preserved } = await pruneStaleFiles(opts.dir, stale, { header: opts.header });
+		if (pruned.length > 0) console.log(`${opts.label}: pruned ${pruned.length} stale file${pruned.length === 1 ? "" : "s"}`);
+		if (preserved.length > 0) {
+			console.log(`${opts.label}: preserved ${preserved.length} file${preserved.length === 1 ? "" : "s"} in previous manifest but lacking the auto-generated header (possibly hand-edited).`);
+			for (const p of preserved) console.log(`  ${p}`);
+		}
+	}
+	await writeManifest(opts.dir, {
+		language: opts.language,
+		files: opts.currentPaths
+	});
+}
 //#endregion
 //#region src/engine/registry.ts
 const emitters = /* @__PURE__ */ new Map();
@@ -2927,4 +3250,4 @@ function summarize(changes) {
 //#endregion
 export { integrateGeneratedFiles as a, applyFileHeaders as c, generateAllFiles as d, generateFiles as f, generate as i, buildEmitterContext as l, resolveOperations as m, getEmitter as n, mapFilesForTargetIntegration as o, deriveMethodName as p, registerEmitter as r, treeShakeFiles as s, diffSpecs as t, collectReferencedNames as u };
 
-//# sourceMappingURL=diff-CSy3g-Bq.mjs.map
+//# sourceMappingURL=diff-BYadQQV7.mjs.map