@workos/oagen-emitters 0.19.0 → 0.19.1

package/dist/{plugin-BXDPA9pJ.mjs → plugin-DXIciTnN.mjs}

@@ -117,6 +117,55 @@ function isEnumInScope(enumName, ctx) {
 	const scope = ctx.scopedEnumNames;
 	return !scope || scope.has(enumName);
 }
+/** True when a scoped (`--services`) run is active. */
+function isScopedRun(ctx) {
+	return !!ctx.scopedServices && ctx.scopedServices.size > 0;
+}
+/**
+* Barrel/index inclusion gate for one item (model, enum, fixture) under a
+* scoped run. A barrel/index may only reference an item whose per-item FILE
+* EXISTS ON DISK after the run — otherwise the reference dangles and the SDK
+* fails to compile (the bug this guards: a brand-new model belonging to an
+* out-of-scope service gets declared in `mod.rs`/`__init__.py` but its source
+* file is never emitted). That on-disk set is:
+*   in-scope items (freshly emitted this run) ∪ items already on disk
+*   (recorded in the prior manifest, left untouched because scoped runs never
+*   prune).
+* Inactive scoping ⇒ always true (a full run emits and declares everything).
+*
+* `relPath` is the per-item file path the emitter writes (e.g.
+* `src/models/foo.rs`); `inScope` is the per-item scope predicate result
+* (`isModelInScope` / `isEnumInScope`).
+*/
+function fileExistsAfterRun(relPath, inScope, ctx) {
+	if (!isScopedRun(ctx)) return true;
+	return inScope || (ctx.priorTargetManifestPaths?.has(relPath) ?? false);
+}
+/**
+* Per-item basenames recorded in the prior manifest directly under `dir` (e.g.
+* `src/models`) with extension `ext` (e.g. `.rs`), EXCLUDING `reserved` names
+* (barrels such as `mod`, `_unions`, `__init__`). A scoped run uses this to
+* RETAIN barrel declarations for items that were renamed/removed from the spec
+* but whose files still sit on disk — and may still be referenced by
+* out-of-scope code the scoped run did not regenerate (e.g. a stale resource
+* file). Returns `[]` for a full run or when no prior manifest is available;
+* the caller is responsible for de-duping against items it already emitted.
+*/
+function priorManifestBasenames(ctx, dir, ext, reserved = /* @__PURE__ */ new Set()) {
+	if (!isScopedRun(ctx)) return [];
+	const paths = ctx.priorTargetManifestPaths;
+	if (!paths) return [];
+	const prefix = dir.endsWith("/") ? dir : `${dir}/`;
+	const out = [];
+	for (const p of paths) {
+		if (!p.startsWith(prefix) || !p.endsWith(ext)) continue;
+		const base = p.slice(prefix.length, p.length - ext.length);
+		if (base.includes("/")) continue;
+		if (reserved.has(base)) continue;
+		out.push(base);
+	}
+	return out;
+}
 /**
 * Get the mount target for an IR service.
 * Checks the first resolved operation that belongs to this service.
@@ -11830,23 +11879,26 @@ function generateModels$6(models, ctx) {
 			dispLines.push("        if dispatch_cls is not None:");
 			dispLines.push(`            return cast("${variantTypeName}", dispatch_cls.from_dict(data))`);
 			dispLines.push(`        return ${unknownClassName}.from_dict(data)`);
-			if (isModelInScope(model.name, ctx)) files.push({
+			const dispInScope = isModelInScope(model.name, ctx);
+			if (dispInScope) files.push({
 				path: `src/${ctx.namespace}/${dirName}/models/${fileName$2(model.name)}.py`,
 				content: dispLines.join("\n"),
 				integrateTarget: true,
 				overwriteExisting: true
 			});
-			if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
-			emittedModelSymbolsByDir.get(dirName).push(model.name);
-			emittedModelSymbolsByDir.get(dirName).push(variantTypeName);
-			symbolToFile.set(variantTypeName, fileName$2(model.name));
-			emittedModelSymbolsByDir.get(dirName).push(unknownClassName);
-			symbolToFile.set(unknownClassName, fileName$2(model.name));
-			const dispatcherNatural = originalModelToService.get(model.name);
-			if (dispatcherNatural) {
-				symbolToOriginalService.set(model.name, dispatcherNatural);
-				symbolToOriginalService.set(variantTypeName, dispatcherNatural);
-				symbolToOriginalService.set(unknownClassName, dispatcherNatural);
+			if (fileExistsAfterRun(`src/${ctx.namespace}/${dirName}/models/${fileName$2(model.name)}.py`, dispInScope, ctx)) {
+				if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
+				emittedModelSymbolsByDir.get(dirName).push(model.name);
+				emittedModelSymbolsByDir.get(dirName).push(variantTypeName);
+				symbolToFile.set(variantTypeName, fileName$2(model.name));
+				emittedModelSymbolsByDir.get(dirName).push(unknownClassName);
+				symbolToFile.set(unknownClassName, fileName$2(model.name));
+				const dispatcherNatural = originalModelToService.get(model.name);
+				if (dispatcherNatural) {
+					symbolToOriginalService.set(model.name, dispatcherNatural);
+					symbolToOriginalService.set(variantTypeName, dispatcherNatural);
+					symbolToOriginalService.set(unknownClassName, dispatcherNatural);
+				}
 			}
 			continue;
 		}
@@ -11861,16 +11913,20 @@ function generateModels$6(models, ctx) {
 			else lines.push(`from ${ctx.namespace}.${dirToModule(canonicalDir)}.models.${fileName$2(canonicalName)} import ${canonicalClassName}`);
 			lines.push("");
 			lines.push(`${modelClassName}: TypeAlias = ${canonicalClassName}`);
-			if (isModelInScope(model.name, ctx)) files.push({
-				path: `src/${ctx.namespace}/${dirName}/models/${fileName$2(model.name)}.py`,
+			const aliasInScope = isModelInScope(model.name, ctx);
+			const aliasPath = `src/${ctx.namespace}/${dirName}/models/${fileName$2(model.name)}.py`;
+			if (aliasInScope) files.push({
+				path: aliasPath,
 				content: lines.join("\n"),
 				integrateTarget: true,
 				overwriteExisting: true
 			});
-			if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
-			emittedModelSymbolsByDir.get(dirName).push(model.name);
-			const aliasNatural = originalModelToService.get(model.name);
-			if (aliasNatural) symbolToOriginalService.set(model.name, aliasNatural);
+			if (fileExistsAfterRun(aliasPath, aliasInScope, ctx)) {
+				if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
+				emittedModelSymbolsByDir.get(dirName).push(model.name);
+				const aliasNatural = originalModelToService.get(model.name);
+				if (aliasNatural) symbolToOriginalService.set(model.name, aliasNatural);
+			}
 			continue;
 		}
 		const seenFieldNames = /* @__PURE__ */ new Set();
@@ -12015,16 +12071,19 @@ function generateModels$6(models, ctx) {
 			}
 		}
 		lines.push("        return result");
-		if (isModelInScope(model.name, ctx)) files.push({
-			path: `src/${ctx.namespace}/${dirName}/models/${fileName$2(model.name)}.py`,
+		const regularInScope = isModelInScope(model.name, ctx);
+		if (regularInScope) files.push({
+			path: modelFilePath,
 			content: lines.join("\n"),
 			integrateTarget: true,
 			overwriteExisting: true
 		});
-		if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
-		emittedModelSymbolsByDir.get(dirName).push(model.name);
-		const regularNatural = originalModelToService.get(model.name);
-		if (regularNatural) symbolToOriginalService.set(model.name, regularNatural);
+		if (fileExistsAfterRun(modelFilePath, regularInScope, ctx)) {
+			if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
+			emittedModelSymbolsByDir.get(dirName).push(model.name);
+			const regularNatural = originalModelToService.get(model.name);
+			if (regularNatural) symbolToOriginalService.set(model.name, regularNatural);
+		}
 	}
 	const symbolsByDir = /* @__PURE__ */ new Map();
 	for (const [dirName, names] of emittedModelSymbolsByDir) {
@@ -12033,11 +12092,35 @@ function generateModels$6(models, ctx) {
 		for (const name of names) symbolsByDir.get(key).push({ name });
 	}
 	const reachableEnumNames = collectReachableEnumNames(ctx);
-	const enumSymbolsByDir = collectGeneratedEnumSymbolsByDir(ctx.spec.enums.filter((enumDef) => reachableEnumNames.has(enumDef.name)), ctx);
+	const emittedEnums = ctx.spec.enums.filter((enumDef) => reachableEnumNames.has(enumDef.name));
+	const enumSymbolsByDir = collectGeneratedEnumSymbolsByDir(emittedEnums, ctx);
+	const aliasToCanonicalEnum = /* @__PURE__ */ new Map();
+	for (const [canonical, aliasNames] of collectCompatEnumAliases(emittedEnums, ctx)) for (const aliasName of aliasNames) aliasToCanonicalEnum.set(aliasName, canonical);
 	for (const [dirName, names] of enumSymbolsByDir) {
 		const key = `src/${ctx.namespace}/${dirName}/models`;
 		if (!symbolsByDir.has(key)) symbolsByDir.set(key, []);
-		for (const name of names) symbolsByDir.get(key).push({ name });
+		for (const name of names) if (fileExistsAfterRun(`${key}/${fileName$2(name)}.py`, isEnumInScope(aliasToCanonicalEnum.get(name) ?? name, ctx), ctx)) symbolsByDir.get(key).push({ name });
+	}
+	const manifestModelDirs = /* @__PURE__ */ new Set();
+	for (const p of ctx.priorTargetManifestPaths ?? []) {
+		const m = p.match(new RegExp(`^(src/${ctx.namespace}/[^/]+/models)/[^/]+\\.py$`));
+		if (m) manifestModelDirs.add(m[1]);
+	}
+	for (const dirPath of manifestModelDirs) {
+		if (!symbolsByDir.has(dirPath)) symbolsByDir.set(dirPath, []);
+		const referencedBasenames = /* @__PURE__ */ new Set();
+		for (const sym of symbolsByDir.get(dirPath)) {
+			if (sym.reExport || sym.retainBasename) continue;
+			referencedBasenames.add(symbolToFile.get(sym.name) ?? fileName$2(sym.name));
+		}
+		for (const base of priorManifestBasenames(ctx, dirPath, ".py", new Set(["__init__"]))) {
+			if (referencedBasenames.has(base)) continue;
+			referencedBasenames.add(base);
+			symbolsByDir.get(dirPath).push({
+				name: base,
+				retainBasename: base
+			});
+		}
 	}
 	const commonDirName = "common";
 	const addReExport = (naturalService, name, sourceFile) => {
@@ -12082,6 +12165,10 @@ function generateModels$6(models, ctx) {
 		const uniqueSymbols = [...seen.values()].sort((a, b) => a.name.localeCompare(b.name));
 		const importLines = [];
 		for (const sym of uniqueSymbols) {
+			if (sym.retainBasename) {
+				importLines.push(`from .${sym.retainBasename} import *  # noqa: F401,F403`);
+				continue;
+			}
 			const cls = className$5(sym.name);
 			if (sym.reExport) importLines.push(`from ${ctx.namespace}.${dirToModule(sym.reExport.fromDir)}.models.${sym.reExport.file} import ${cls} as ${cls}`);
 			else {
@@ -12098,7 +12185,7 @@ function generateModels$6(models, ctx) {
 		});
 		if (!serviceDirModelPaths.has(dirPath)) {
 			const parentDir = dirPath.replace(/\/models$/, "");
-			const reExports = uniqueSymbols.map((sym) => `from .models import ${className$5(sym.name)} as ${className$5(sym.name)}`).join("\n");
+			const reExports = [...new Set(uniqueSymbols.map((sym) => sym.retainBasename ? "from .models import *  # noqa: F401,F403" : `from .models import ${className$5(sym.name)} as ${className$5(sym.name)}`))].join("\n");
 			files.push({
 				path: `${parentDir}/__init__.py`,
 				content: reExports,
@@ -13818,18 +13905,30 @@ const ID_PREFIXES$3 = {
 };
 /**
 * Generate JSON fixture files for test data.
-*/
-function generateFixtures$4(spec) {
+*
+* `ctx` is optional so unit tests can call with a bare spec; when supplied, a
+* scoped (`--services`) run only emits a fixture for a model whose per-model
+* file will exist on disk after the run (in-scope, or already present from a
+* prior manifest). Brand-new out-of-scope models are skipped: the round-trip
+* test that consumes these fixtures is gated the same way, and the per-service
+* tests only reference fixtures for their (in-scope) models.
+*/
+function generateFixtures$4(spec, ctx) {
 	if (spec.models.length === 0) return [];
 	const modelMap = new Map(spec.models.map((m) => [m.name, m]));
 	const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
 	const files = [];
+	const fixtureEmitted = (path, modelName) => {
+		if (!ctx) return true;
+		return fileExistsAfterRun(path, isModelInScope(modelName, ctx), ctx);
+	};
 	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
 	const listMetadataNeeded = collectReferencedListMetadataModels(spec.models, nonPaginatedRefs);
 	for (const model of spec.models) {
 		if (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
 		if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
 		if (model.fields.length === 0) continue;
+		if (!fixtureEmitted(`tests/fixtures/${fileName$2(model.name)}.json`, model.name)) continue;
 		const fixture = generateModelFixture$4(model, modelMap, enumMap);
 		files.push({
 			path: `tests/fixtures/${fileName$2(model.name)}.json`,
@@ -13842,6 +13941,7 @@ function generateFixtures$4(spec) {
 			const unwrapped = unwrapListModel$3(itemModel, modelMap);
 			if (unwrapped) itemModel = unwrapped;
 			if (itemModel.fields.length === 0) continue;
+			if (!fixtureEmitted(`tests/fixtures/list_${fileName$2(itemModel.name)}.json`, itemModel.name)) continue;
 			const listFixture = {
 				data: [generateModelFixture$4(itemModel, modelMap, enumMap)],
 				list_metadata: {
@@ -13984,7 +14084,7 @@ function buildDeleteSuccessResponseSetup(op) {
 */
 function generateTests$6(spec, ctx) {
 	const files = [];
-	const fixtures = generateFixtures$4(spec);
+	const fixtures = generateFixtures$4(spec, ctx);
 	for (const fixture of fixtures) files.push({
 		path: fixture.path,
 		content: fixture.content,
@@ -14961,11 +15061,17 @@ function generateModelRoundTripTests(spec, ctx) {
 	for (const name of responseModelNames) requestOnlyModelNames.delete(name);
 	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
 	const listMetadataNeeded = collectReferencedListMetadataModels(spec.models, nonPaginatedRefs);
-	const models = spec.models.filter((m) => !(isListWrapperModel(m) && !nonPaginatedRefs.has(m.name)) && !(isListMetadataModel(m) && !listMetadataNeeded.has(m.name)) && !requestOnlyModelNames.has(m.name));
-	if (models.length === 0) return null;
-	const modelToService = computeSchemaPlacement(spec, ctx).originalModelToService;
+	const placement = computeSchemaPlacement(spec, ctx);
+	const modelToService = placement.originalModelToService;
+	const relocatedModelToService = placement.modelToService;
 	const roundTripDirMap = buildMountDirMap$1(ctx);
 	const resolveDir = (irService) => irService ? roundTripDirMap.get(irService) ?? "common" : "common";
+	const modelFileExists = (name) => {
+		const dir = resolveDir(relocatedModelToService.get(name));
+		return fileExistsAfterRun(`src/${ctx.namespace}/${dir}/models/${fileName$2(name)}.py`, isModelInScope(name, ctx), ctx);
+	};
+	const models = spec.models.filter((m) => !(isListWrapperModel(m) && !nonPaginatedRefs.has(m.name)) && !(isListMetadataModel(m) && !listMetadataNeeded.has(m.name)) && !requestOnlyModelNames.has(m.name) && modelFileExists(m.name));
+	if (models.length === 0) return null;
 	const lines = [];
 	lines.push("\"\"\"Model round-trip tests: from_dict(to_dict()) preserves data.\"\"\"");
 	lines.push("");
@@ -17298,6 +17404,169 @@ function unionResolverName(ref) {
 	return null;
 }
 //#endregion
+//#region src/go/flat-merge.ts
+/** Read the prior on-disk content of a generated file, or null when unavailable. */
+function readPriorFile(relPath, ctx) {
+	if (!ctx.outputDir) return null;
+	const abs = resolve(ctx.outputDir, relPath);
+	if (!existsSync(abs)) return null;
+	try {
+		return readFileSync(abs, "utf-8");
+	} catch {
+		return null;
+	}
+}
+/**
+* Parse a flat Go file into the set of top-level type names it declares, mapped
+* to the verbatim text of each declaration block (including its leading doc
+* comment). Used to recover the per-type "present before" signal a scoped run
+* needs. Recognizes the exact shapes the Go emitter produces:
+*   - `type Name struct { ... }`        (brace-balanced)
+*   - `type Name = Other`               (single-line alias)
+*   - `type Name string` + `const ( ... )`  (string enum)
+*   - `type ( A = X\n B = X )`          (batched alias block — declares many)
+* The leading `package` clause and any standalone trailing `const (...)` block
+* (e.g. the events file) are returned separately by {@link parseFlatGoBlocks}.
+*/
+function parseFlatGoBlocks(content) {
+	const lines = content.split("\n");
+	const blocks = [];
+	let i = 0;
+	while (i < lines.length) {
+		const t = lines[i].trim();
+		if (t.startsWith("package ") || t === "" || t.startsWith("// Code generated")) {
+			i++;
+			continue;
+		}
+		break;
+	}
+	while (i < lines.length) {
+		const start = i;
+		while (i < lines.length && lines[i].trim().startsWith("//")) i++;
+		if (i >= lines.length) break;
+		const trimmed = lines[i].trim();
+		if (trimmed === "type (") {
+			const names = [];
+			i++;
+			while (i < lines.length && lines[i].trim() !== ")") {
+				const m = lines[i].trim().match(/^(\w+)\s*=/);
+				if (m) names.push(m[1]);
+				i++;
+			}
+			i++;
+			blocks.push({
+				names,
+				text: lines.slice(start, i).join("\n")
+			});
+		} else if (/^type\s+(\w+)\s+struct\s*\{/.test(trimmed)) {
+			const name = trimmed.match(/^type\s+(\w+)/)[1];
+			let depth = 0;
+			let sawOpen = false;
+			while (i < lines.length) {
+				for (const ch of lines[i]) if (ch === "{") {
+					depth++;
+					sawOpen = true;
+				} else if (ch === "}") depth--;
+				i++;
+				if (sawOpen && depth === 0) break;
+			}
+			blocks.push({
+				names: [name],
+				text: lines.slice(start, i).join("\n")
+			});
+		} else if (/^type\s+(\w+)\s+\w+\s+string\b/.test(trimmed) || /^type\s+(\w+)\s+string\b/.test(trimmed)) {
+			const name = trimmed.match(/^type\s+(\w+)/)[1];
+			i++;
+			let j = i;
+			while (j < lines.length && lines[j].trim() === "") j++;
+			if (j < lines.length && lines[j].trim() === "const (") {
+				i = j;
+				while (i < lines.length && lines[i].trim() !== ")") i++;
+				i++;
+			}
+			blocks.push({
+				names: [name],
+				text: lines.slice(start, i).join("\n")
+			});
+		} else if (/^type\s+(\w+)\s*=/.test(trimmed)) {
+			const name = trimmed.match(/^type\s+(\w+)/)[1];
+			i++;
+			blocks.push({
+				names: [name],
+				text: lines.slice(start, i).join("\n")
+			});
+		} else i++;
+		while (i < lines.length && lines[i].trim() === "") i++;
+	}
+	const byName = /* @__PURE__ */ new Map();
+	for (const b of blocks) for (const n of b.names) byName.set(n, b);
+	return {
+		blocks,
+		byName
+	};
+}
+/**
+* Reconcile freshly generated named blocks against the prior on-disk file for a
+* scoped run. Returns the ordered list of block texts to emit. See file-level
+* docs for the keep/carry-over rules. In a scoped run a block is emitted as:
+*   - IN-SCOPE                  → the freshly generated text (apply the new spec).
+*   - out-of-scope, existed before → the PRIOR on-disk text, FROZEN, so an
+*     unrelated change to that type in the same spec delta doesn't leak into a
+*     scoped batch (Option B). (Falls back to fresh text only when the new
+*     block's names span multiple prior blocks — a batched-alias regrouping —
+*     which can't be frozen 1:1.)
+*   - out-of-scope, brand-new   → dropped (the addition that broke the build).
+* Then any prior block the new spec no longer produces at all is carried over
+* verbatim (renamed/removed types still referenced by un-regenerated code).
+*
+* @param newBlocks    Per-type blocks the current spec produced (in emit order),
+*                     each tagged with `inScope`.
+* @param relPath      Flat file path (e.g. `models.go`) for reading the prior file.
+* @param ctx          Emitter context (provides `outputDir` + scope sets).
+* @param alsoEmitted  Names this file emits OUTSIDE `newBlocks` (e.g. the fixed
+*                     `PaginationParams` struct). They must be excluded from the
+*                     carry-over, or the prior copy would be re-appended and
+*                     redeclare the separately-emitted one.
+*/
+function reconcileFlatBlocks(newBlocks, relPath, ctx, alsoEmitted = /* @__PURE__ */ new Set()) {
+	if (!isScopedRun(ctx)) return newBlocks.map((b) => b.text);
+	const prior = readPriorFile(relPath, ctx);
+	const priorParsed = prior ? parseFlatGoBlocks(prior) : {
+		blocks: [],
+		byName: /* @__PURE__ */ new Map()
+	};
+	const out = [];
+	const emittedNames = /* @__PURE__ */ new Set();
+	for (const block of newBlocks) {
+		if (block.inScope) {
+			out.push(block.text);
+			for (const n of block.names) emittedNames.add(n);
+			continue;
+		}
+		const priorBlocks = block.names.map((n) => priorParsed.byName.get(n)).filter((b) => !!b);
+		const uniquePrior = new Set(priorBlocks);
+		if (uniquePrior.size === 1) {
+			const pb = priorBlocks[0];
+			if (!pb.names.some((n) => emittedNames.has(n))) {
+				out.push(pb.text);
+				for (const n of pb.names) emittedNames.add(n);
+			}
+		} else if (uniquePrior.size > 1) for (const pb of uniquePrior) {
+			if (pb.names.some((n) => emittedNames.has(n))) continue;
+			out.push(pb.text);
+			for (const n of pb.names) emittedNames.add(n);
+		}
+	}
+	for (const block of priorParsed.blocks) {
+		if (block.names.some((n) => alsoEmitted.has(n))) continue;
+		if (block.names.every((n) => !emittedNames.has(n))) {
+			out.push(block.text);
+			for (const n of block.names) emittedNames.add(n);
+		}
+	}
+	return out;
+}
+//#endregion
 //#region src/go/models.ts
 /**
 * Collect names of models that are referenced **only** as a named request body
@@ -17365,6 +17634,8 @@ function generateModels$4(models, ctx) {
 		if (!hashGroups.has(hash)) hashGroups.set(hash, []);
 		hashGroups.get(hash).push(model.name);
 	}
+	const priorModelNames = isScopedRun(ctx) ? new Set(parseFlatGoBlocks(readPriorFile("models.go", ctx) ?? "").blocks.flatMap((b) => b.names)) : /* @__PURE__ */ new Set();
+	const aliasEmitted = (name) => !isScopedRun(ctx) || isModelInScope(name, ctx) || priorModelNames.has(className$3(name));
 	const aliasOf = /* @__PURE__ */ new Map();
 	for (const [hash, names] of hashGroups) {
 		if (names.length <= 1) continue;
@@ -17373,6 +17644,11 @@ function generateModels$4(models, ctx) {
 		const canonical = sorted[0];
 		for (let i = 1; i < sorted.length; i++) aliasOf.set(sorted[i], canonical);
 	}
+	const forcedCanonicals = /* @__PURE__ */ new Set();
+	if (isScopedRun(ctx)) {
+		for (const [aliasName, canonical] of aliasOf) if (isModelInScope(aliasName, ctx)) forcedCanonicals.add(canonical);
+	}
+	const modelBlocks = [];
 	const batchedAliases = /* @__PURE__ */ new Set();
 	for (const model of models) {
 		if (skipAsListWrapper(model) || skipAsListMetadata(model)) continue;
@@ -17385,29 +17661,44 @@ function generateModels$4(models, ctx) {
 			if (structName === canonicalStruct) continue;
 			const hash = modelHashMap.get(model.name);
 			const aliases = (hashGroups.get(hash) ?? []).filter((n) => aliasOf.has(n) && className$3(n) !== className$3(aliasOf.get(n)));
+			const blockLines = [];
+			const blockNames = [];
+			let blockInScope = false;
 			if (aliases.length >= 5) {
 				for (const aliasName of aliases) batchedAliases.add(aliasName);
-				lines.push(`// The following types are structurally identical to ${canonicalStruct}.`);
-				lines.push("type (");
-				for (const aliasName of aliases) lines.push(`\t${className$3(aliasName)} = ${canonicalStruct}`);
-				lines.push(")");
-				lines.push("");
+				const emittedAliases = aliases.filter(aliasEmitted);
+				if (emittedAliases.length === 0) continue;
+				blockLines.push(`// The following types are structurally identical to ${canonicalStruct}.`);
+				blockLines.push("type (");
+				for (const aliasName of emittedAliases) {
+					blockLines.push(`\t${className$3(aliasName)} = ${canonicalStruct}`);
+					blockNames.push(className$3(aliasName));
+					if (isModelInScope(aliasName, ctx)) blockInScope = true;
+				}
+				blockLines.push(")");
 			} else {
-				lines.push(`// ${structName} is an alias for ${canonicalStruct}.`);
-				lines.push(`type ${structName} = ${canonicalStruct}`);
-				lines.push("");
-			}
+				blockLines.push(`// ${structName} is an alias for ${canonicalStruct}.`);
+				blockLines.push(`type ${structName} = ${canonicalStruct}`);
+				blockNames.push(structName);
+				if (isModelInScope(model.name, ctx)) blockInScope = true;
+			}
+			modelBlocks.push({
+				names: blockNames,
+				text: blockLines.join("\n"),
+				inScope: blockInScope
+			});
 			continue;
 		}
+		const blockLines = [];
 		if (model.description) {
 			const descLines = model.description.split("\n").filter((l) => l.trim());
-			lines.push(`// ${structName} ${lowerFirst$1(descLines[0])}`);
-			for (let i = 1; i < descLines.length; i++) lines.push(`// ${descLines[i].trim()}`);
+			blockLines.push(`// ${structName} ${lowerFirst$1(descLines[0])}`);
+			for (let i = 1; i < descLines.length; i++) blockLines.push(`// ${descLines[i].trim()}`);
 		} else {
 			const humanized = humanize$3(model.name);
-			lines.push(`// ${structName} represents ${articleFor$1(humanized)} ${humanized}.`);
+			blockLines.push(`// ${structName} represents ${articleFor$1(humanized)} ${humanized}.`);
 		}
-		lines.push(`type ${structName} struct {`);
+		blockLines.push(`type ${structName} struct {`);
 		const seenFieldNames = /* @__PURE__ */ new Set();
 		for (const field of model.fields) {
 			const goFieldName = domainFieldName$3(field);
@@ -17417,17 +17708,26 @@ function generateModels$4(models, ctx) {
 			const jsonTag = field.required ? `json:"${field.name}"` : `json:"${field.name},omitempty"`;
 			if (field.description) {
 				const fdLines = field.description.split("\n").filter((l) => l.trim());
-				lines.push(`\t// ${fieldDocComment(goFieldName, fdLines[0])}`);
-				for (let i = 1; i < fdLines.length; i++) lines.push(`\t// ${fdLines[i].trim()}`);
+				blockLines.push(`\t// ${fieldDocComment(goFieldName, fdLines[0])}`);
+				for (let i = 1; i < fdLines.length; i++) blockLines.push(`\t// ${fdLines[i].trim()}`);
 			}
 			if (field.deprecated) {
-				if (field.description) lines.push(`\t//`);
+				if (field.description) blockLines.push(`\t//`);
 				const deprecationReason = extractDeprecationReason(field.description);
-				lines.push(`\t// Deprecated: ${deprecationReason}`);
+				blockLines.push(`\t// Deprecated: ${deprecationReason}`);
 			}
-			lines.push(`\t${goFieldName} ${goType} \`${jsonTag}\``);
+			blockLines.push(`\t${goFieldName} ${goType} \`${jsonTag}\``);
 		}
-		lines.push("}");
+		blockLines.push("}");
+		modelBlocks.push({
+			names: [structName],
+			text: blockLines.join("\n"),
+			inScope: isModelInScope(model.name, ctx) || forcedCanonicals.has(model.name)
+		});
+	}
+	const reconciled = reconcileFlatBlocks(modelBlocks, "models.go", ctx, new Set(["PaginationParams"]));
+	for (const text of reconciled) {
+		lines.push(text);
 		lines.push("");
 	}
 	const orderEnumType = detectSharedOrderEnum(ctx.spec.services);
@@ -17590,27 +17890,36 @@ function extractDeprecationReason(description) {
 function generateEnums$4(enums, ctx) {
 	if (enums.length === 0) return [];
 	const aliasOf = collectEnumAliasOf$2(enums);
+	const forcedCanonicals = /* @__PURE__ */ new Set();
+	if (isScopedRun(ctx)) {
+		for (const [aliasName, canonical] of aliasOf) if (isEnumInScope(aliasName, ctx)) forcedCanonicals.add(canonical);
+	}
 	const files = [];
 	const lines = [];
 	lines.push(`package ${ctx.namespace}`);
 	lines.push("");
+	const enumBlocks = [];
 	for (const enumDef of enums) {
 		const canonicalName = aliasOf.get(enumDef.name);
 		if (canonicalName) {
 			const aliasType = className$3(enumDef.name);
 			const canonicalType = className$3(canonicalName);
 			if (aliasType === canonicalType) continue;
-			lines.push(`// ${aliasType} is an alias for ${canonicalType}.`);
-			lines.push(`type ${aliasType} = ${canonicalType}`);
-			lines.push("");
+			enumBlocks.push({
+				names: [aliasType],
+				text: [`// ${aliasType} is an alias for ${canonicalType}.`, `type ${aliasType} = ${canonicalType}`].join("\n"),
+				inScope: isEnumInScope(enumDef.name, ctx)
+			});
 			continue;
 		}
 		const typeName = className$3(enumDef.name);
 		if (enumDef.values.length === 0) {
 			const humanized = humanize$2(enumDef.name);
-			lines.push(`// ${typeName} represents ${humanized} values.`);
-			lines.push(`type ${typeName} = string`);
-			lines.push("");
+			enumBlocks.push({
+				names: [typeName],
+				text: [`// ${typeName} represents ${humanized} values.`, `type ${typeName} = string`].join("\n"),
+				inScope: isEnumInScope(enumDef.name, ctx) || forcedCanonicals.has(enumDef.name)
+			});
 			continue;
 		}
 		const seenValues = /* @__PURE__ */ new Set();
@@ -17623,10 +17932,11 @@ function generateEnums$4(enums, ctx) {
 			}
 		}
 		const humanized = humanize$2(enumDef.name);
-		lines.push(`// ${typeName} represents ${humanized} values.`);
-		lines.push(`type ${typeName} string`);
-		lines.push("");
-		lines.push("const (");
+		const blockLines = [];
+		blockLines.push(`// ${typeName} represents ${humanized} values.`);
+		blockLines.push(`type ${typeName} string`);
+		blockLines.push("");
+		blockLines.push("const (");
 		const usedNames = /* @__PURE__ */ new Set();
 		for (const v of uniqueValues) {
 			let constSuffix = className$3(String(v.value));
@@ -17638,14 +17948,23 @@ function generateEnums$4(enums, ctx) {
 			const constName = `${typeName}${constSuffix}`;
 			usedNames.add(constName);
 			const valueStr = typeof v.value === "string" ? `"${v.value}"` : String(v.value);
-			if (v.description) lines.push(`\t// ${constName} is ${v.description}.`);
+			if (v.description) blockLines.push(`\t// ${constName} is ${v.description}.`);
 			if (v.deprecated) {
-				if (v.description) lines.push(`\t//`);
-				lines.push(`\t// Deprecated: this value is deprecated.`);
+				if (v.description) blockLines.push(`\t//`);
+				blockLines.push(`\t// Deprecated: this value is deprecated.`);
 			}
-			lines.push(`\t${constName} ${typeName} = ${valueStr}`);
+			blockLines.push(`\t${constName} ${typeName} = ${valueStr}`);
 		}
-		lines.push(")");
+		blockLines.push(")");
+		enumBlocks.push({
+			names: [typeName],
+			text: blockLines.join("\n"),
+			inScope: isEnumInScope(enumDef.name, ctx) || forcedCanonicals.has(enumDef.name)
+		});
+	}
+	const reconciled = reconcileFlatBlocks(enumBlocks, "enums.go", ctx);
+	for (const text of reconciled) {
+		lines.push(text);
 		lines.push("");
 	}
 	files.push({
@@ -17653,7 +17972,7 @@ function generateEnums$4(enums, ctx) {
 		content: lines.join("\n"),
 		overwriteExisting: true
 	});
-	const eventConstantsFile = generateEventConstantsFile(enums);
+	const eventConstantsFile = generateEventConstantsFile(enums, ctx);
 	if (eventConstantsFile) files.push(eventConstantsFile);
 	return files;
 }
@@ -17715,9 +18034,15 @@ function collectEnumAliasOf$2(enums) {
 	}
 	return aliasOf;
 }
-function generateEventConstantsFile(enums) {
+const EVENTS_FILE_PATH = "pkg/events/events.go";
+function generateEventConstantsFile(enums, ctx) {
 	const enumDef = findWebhookEventEnum(enums);
 	if (!enumDef) return null;
+	let priorEventConsts = null;
+	if (isScopedRun(ctx)) {
+		const prior = readPriorFile(EVENTS_FILE_PATH, ctx);
+		if (prior !== null) priorEventConsts = collectPriorEventConstNames(prior);
+	}
 	const lines = [];
 	lines.push("package events");
 	lines.push("");
@@ -17732,6 +18057,7 @@ function generateEventConstantsFile(enums) {
 		if (seenValues.has(valueStr)) continue;
 		seenValues.add(valueStr);
 		const constName = uniqueEventConstantName(valueStr, usedNames);
+		if (priorEventConsts !== null && !priorEventConsts.has(constName)) continue;
 		usedNames.add(constName);
 		if (value.description) lines.push(`\t// ${constName} is ${value.description}.`);
 		if (value.deprecated) {
@@ -17743,11 +18069,25 @@ function generateEventConstantsFile(enums) {
 	lines.push(")");
 	lines.push("");
 	return {
-		path: "pkg/events/events.go",
+		path: EVENTS_FILE_PATH,
 		content: lines.join("\n"),
 		overwriteExisting: true
 	};
 }
+/**
+* Collect the constant names declared in a prior `pkg/events/events.go`. Each
+* event constant is emitted as `\tConstName = "wire.value"` inside the single
+* `const (...)` block, so a simple line scan recovers the prior name set used
+* to keep the file byte-stable across scoped runs.
+*/
+function collectPriorEventConstNames(content) {
+	const names = /* @__PURE__ */ new Set();
+	for (const raw of content.split("\n")) {
+		const m = raw.trim().match(/^(\w+)\s*=\s*"/);
+		if (m) names.add(m[1]);
+	}
+	return names;
+}
 function findWebhookEventEnum(enums) {
 	return enums.find((enumDef) => enumDef.name === "CreateWebhookEndpointEvents") ?? enums.find((enumDef) => isWebhookEventEnumName(enumDef.name) && enumDef.values.length > 0 && enumDef.values.every((value) => typeof value.value === "string" && value.value.includes("."))) ?? null;
 }
@@ -18960,8 +19300,15 @@ const ID_PREFIXES$1 = {
 };
 /**
 * Generate JSON fixture files for test data.
-*/
-function generateFixtures$2(spec) {
+*
+* Scoped runs only emit a fixture for a model whose per-model fixture FILE will
+* exist on disk after the run (in-scope, or already present from a prior run —
+* the fixture path is per-model so the prior manifest records it directly).
+* This drops brand-new out-of-scope fixtures (the round-trip ADDITION case) and
+* keeps prior fixtures untouched, mirroring the Rust fixtures fix. `ctx` is
+* optional so unit tests that assert raw content can call it for a full run.
+*/
+function generateFixtures$2(spec, ctx) {
 	if (spec.models.length === 0) return {
 		files: [],
 		pathRewrites: /* @__PURE__ */ new Map()
@@ -18971,12 +19318,15 @@ function generateFixtures$2(spec) {
 	const files = [];
 	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
 	const listMetadataNeeded = collectReferencedListMetadataModels(spec.models, nonPaginatedRefs);
+	const fixtureInScope = (relPath, modelName) => !ctx || fileExistsAfterRun(relPath, isModelInScope(modelName, ctx), ctx);
 	for (const model of spec.models) {
 		if (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
 		if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
+		const path = `testdata/${fileName$1(model.name)}.json`;
+		if (!fixtureInScope(path, model.name)) continue;
 		const fixture = model.fields.length === 0 ? {} : generateModelFixture$2(model, modelMap, enumMap);
 		files.push({
-			path: `testdata/${fileName$1(model.name)}.json`,
+			path,
 			content: JSON.stringify(fixture, null, 2)
 		});
 	}
@@ -18990,6 +19340,7 @@ function generateFixtures$2(spec) {
 			const path = `testdata/list_${fileName$1(itemModel.name)}.json`;
 			if (seenListPaths.has(path)) continue;
 			seenListPaths.add(path);
+			if (!fixtureInScope(path, itemModel.name)) continue;
 			const listFixture = {
 				data: [generateModelFixture$2(itemModel, modelMap, enumMap)],
 				list_metadata: {
@@ -19151,7 +19502,7 @@ function generateTests$4(spec, ctx) {
 		content: helperLines.join("\n"),
 		overwriteExisting: true
 	});
-	const { files: fixtures, pathRewrites: fixtureRewrites } = generateFixtures$2(spec);
+	const { files: fixtures, pathRewrites: fixtureRewrites } = generateFixtures$2(spec, ctx);
 	for (const fixture of fixtures) files.push({
 		path: fixture.path,
 		content: fixture.content,
@@ -21451,6 +21802,13 @@ function generateClientFile(spec, ctx) {
 //#endregion
 //#region src/dotnet/fixtures.ts
 /**
+* Prefix the per-model fixture path with the .NET test project layout so the
+* scoped-run gate can compare it against the prefixed paths recorded in the
+* prior manifest. Must mirror `TEST_PREFIX` in index.ts; the fixture path
+* itself (`testdata/<name>.json`) is what `prefixTestPaths` later prepends to.
+*/
+const TEST_PREFIX$2 = "test/WorkOSTests/";
+/**
 * Prefix mapping for generating realistic ID fixture values.
 */
 const ID_PREFIXES = {
@@ -21471,7 +21829,7 @@ const ID_PREFIXES = {
 /**
 * Generate JSON fixture files for test data.
 */
-function generateFixtures$1(spec) {
+function generateFixtures$1(spec, ctx) {
 	if (spec.models.length === 0) return [];
 	const modelMap = new Map(spec.models.map((m) => [m.name, m]));
 	const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
@@ -21480,9 +21838,11 @@ function generateFixtures$1(spec) {
 	for (const model of spec.models) {
 		if (isListMetadataModel(model)) continue;
 		if (isListWrapperModel(model) && !nonPaginatedWrapperRefs.has(model.name)) continue;
+		const fixturePath = `testdata/${fixtureFileName(model.name)}.json`;
+		if (!fileExistsAfterRun(`${TEST_PREFIX$2}${fixturePath}`, isModelInScope(model.name, ctx), ctx)) continue;
 		const fixture = model.fields.length === 0 ? {} : generateModelFixture$1(model, modelMap, enumMap);
 		files.push({
-			path: `testdata/${fixtureFileName(model.name)}.json`,
+			path: fixturePath,
 			content: JSON.stringify(fixture, null, 2)
 		});
 		if (model.fields.some((f) => !f.required || f.type.kind === "nullable") && model.fields.length > 0) {
@@ -21609,7 +21969,7 @@ function generatePrimitiveValue(type, format, name, modelName) {
 */
 function generateTests$3(spec, ctx) {
 	const files = [];
-	const fixtures = generateFixtures$1(spec);
+	const fixtures = generateFixtures$1(spec, ctx);
 	for (const fixture of fixtures) files.push({
 		path: fixture.path,
 		content: fixture.content,
@@ -22141,6 +22501,26 @@ function prefixTestPaths(files) {
 	for (const f of files) f.path = `${TEST_PREFIX$1}${f.path}`;
 	return files;
 }
+/**
+* Scoped-run gate for a discriminated-union variant referenced by a generated
+* converter (the event-registry / polymorphic dispatch aggregate). A converter
+* may only name a variant whose per-model `Entities/<Class>.cs` file will exist
+* on disk after the run — otherwise the `new <Class>()` / `ToObject<<Class>>`
+* arm references a type whose file is never emitted (CS0246). The set that
+* exists after the run is: in-scope variants (emitted this run) ∪ variants
+* already on disk from a prior manifest (scoped runs never prune), so a
+* renamed/removed-but-still-on-disk variant is RETAINED while a brand-new
+* out-of-scope variant is EXCLUDED. A full run includes everything.
+*
+* The variant name is resolved through the model-alias map first, exactly as
+* the converter emits it (`modelClassName(resolveModelName(name))`), and the
+* candidate path carries the `src/WorkOS.net/` prefix so it matches the
+* prefixed paths recorded in `priorTargetManifestPaths`.
+*/
+function variantFileExistsAfterRun(variantModelName, ctx) {
+	const canonical = resolveModelName(variantModelName);
+	return fileExistsAfterRun(`${SRC_PREFIX}Entities/${modelClassName(canonical)}.cs`, isModelInScope(canonical, ctx), ctx);
+}
 const dotnetEmitter = {
 	language: "dotnet",
 	generateModels(models, ctx) {
@@ -22200,6 +22580,7 @@ const dotnetEmitter = {
 			lines.push("            switch (discriminatorValue)");
 			lines.push("            {");
 			for (const [value, modelName] of Object.entries(disc.mapping)) {
+				if (!variantFileExistsAfterRun(modelName, c)) continue;
 				const csName = modelClassName(resolveModelName(modelName));
 				lines.push(`                case "${value}": return jObject.ToObject<${csName}>(serializer);`);
 			}
@@ -22220,6 +22601,7 @@ const dotnetEmitter = {
 			});
 		}
 		for (const [baseName, disc] of modelDiscriminators) {
+			if (!variantFileExistsAfterRun(baseName, c)) continue;
 			const baseClass = modelClassName(baseName);
 			const converterName = `${baseClass}DiscriminatorConverter`;
 			const lines = [];
@@ -22248,6 +22630,7 @@ const dotnetEmitter = {
 			lines.push("            switch (discriminatorValue)");
 			lines.push("            {");
 			for (const [value, variantModelName] of Object.entries(disc.mapping)) {
+				if (!variantFileExistsAfterRun(variantModelName, c)) continue;
 				const csName = modelClassName(variantModelName);
 				lines.push(`                case "${value}": target = new ${csName}(); break;`);
 			}
@@ -22805,6 +23188,16 @@ const KOTLIN_SRC_PREFIX$2 = "src/main/kotlin/";
 const MODELS_PACKAGE = "com.workos.models";
 const MODELS_DIR = "com/workos/models";
 /**
+* The relative path (target-root-relative, matching the prior manifest) of the
+* per-model `.kt` FILE the emitter writes for a model. The aggregate gate
+* ({@link fileExistsAfterRun}) checks this exact path against the freshly-emitted
+* in-scope set and the prior manifest. Must stay in sync with the path used in
+* {@link emitDataClass} / {@link emitSealedUnion} / the typealias branch.
+*/
+function modelFilePath$1(modelName) {
+	return `${KOTLIN_SRC_PREFIX$2}${MODELS_DIR}/${className$1(modelName)}.kt`;
+}
+/**
 * Some specs leave string fields without `format: date-time` even though the
 * description (or the example) makes clear they carry an ISO-8601 timestamp.
 * Detect that here so we can promote the type to `OffsetDateTime` in the
@@ -22899,7 +23292,7 @@ function generateModels$2(models, ctx) {
 		const typeName = className$1(model.name);
 		const modelInScope = isModelInScope(model.name, ctx);
 		if (model.fields.length === 0 && discriminatedUnions.has(typeName)) {
-			if (modelInScope) files.push(emitSealedUnion(typeName, discriminatedUnions.get(typeName)));
+			if (modelInScope) files.push(emitSealedUnion(typeName, discriminatedUnions.get(typeName), ctx));
 			continue;
 		}
 		const canonical = aliasOf.get(model.name);
@@ -22927,6 +23320,7 @@ function generateModels$2(models, ctx) {
 		if (skipAsListWrapper(model) || skipAsListMetadata(model)) continue;
 		if (aliasOf.has(model.name)) continue;
 		if (!isEventEnvelopeModel(model)) continue;
+		if (!fileExistsAfterRun(modelFilePath$1(model.name), isModelInScope(model.name, ctx), ctx)) continue;
 		const eventField = model.fields.find((f) => f.name === "event");
 		if (eventField && eventField.type.kind === "literal" && typeof eventField.type.value === "string") eventMapping.push({
 			wireValue: eventField.type.value,
@@ -22984,15 +23378,15 @@ function emitDataClass(model) {
 		overwriteExisting: true
 	};
 }
-function emitSealedUnion(typeName, disc) {
+function emitSealedUnion(typeName, disc, ctx) {
 	const lines = [];
 	lines.push(`package ${MODELS_PACKAGE}`);
 	lines.push("");
 	lines.push("import com.fasterxml.jackson.annotation.JsonSubTypes");
 	lines.push("import com.fasterxml.jackson.annotation.JsonTypeInfo");
 	lines.push("");
-	const exampleVariantWire = Object.keys(disc.mapping)[0];
-	const exampleVariantType = exampleVariantWire ? className$1(disc.mapping[exampleVariantWire]) : null;
+	const entries = Object.entries(disc.mapping).filter(([, modelName]) => fileExistsAfterRun(modelFilePath$1(modelName), isModelInScope(modelName, ctx), ctx));
+	const exampleVariantType = entries.length > 0 ? className$1(entries[0][1]) : null;
 	lines.push("/**");
 	lines.push(` * Discriminated union over ${typeName} variants. Selected by \`${disc.property}\`.`);
 	if (exampleVariantType) {
@@ -23021,7 +23415,6 @@ function emitSealedUnion(typeName, disc) {
 	lines.push("  visible = true");
 	lines.push(")");
 	lines.push("@JsonSubTypes(");
-	const entries = Object.entries(disc.mapping);
 	for (let i = 0; i < entries.length; i++) {
 		const [wireValue, modelName] = entries[i];
 		const variantType = className$1(modelName);
@@ -24478,6 +24871,14 @@ function deduplicateByMount(services, ctx) {
 //#endregion
 //#region src/kotlin/tests.ts
 const TEST_PREFIX = "src/test/kotlin/";
+const MODELS_FILE_PREFIX = "src/main/kotlin/com/workos/models/";
+const ENUMS_FILE_PREFIX = "src/main/kotlin/com/workos/types/";
+function modelFilePath(modelName) {
+	return `${MODELS_FILE_PREFIX}${className$1(modelName)}.kt`;
+}
+function enumFilePath(enumName) {
+	return `${ENUMS_FILE_PREFIX}${className$1(enumName)}.kt`;
+}
 /**
 * Mirror the ISO-8601 hint promotion the resource/model emitters use so tests
 * synthesize values whose Kotlin type matches the generated method signature.
@@ -25228,6 +25629,7 @@ function generateModelRoundTripTest$1(spec, ctx) {
 	for (const m of spec.models) {
 		if (isListWrapperModel(m) || isListMetadataModel(m)) continue;
 		if (m.fields.length === 0) continue;
+		if (!fileExistsAfterRun(modelFilePath(m.name), isModelInScope(m.name, ctx), ctx)) continue;
 		const cls = className$1(m.name);
 		if (seenModelClassNames.has(cls)) continue;
 		seenModelClassNames.add(cls);
@@ -25276,10 +25678,11 @@ function generateModelRoundTripTest$1(spec, ctx) {
 */
 const MAX_ENUM_FORWARD_COMPAT = 15;
 function generateForwardCompatTest(spec, ctx) {
-	const enumTargets = spec.enums.filter((e) => e.values.length > 0).slice(0, MAX_ENUM_FORWARD_COMPAT);
+	const enumTargets = spec.enums.filter((e) => e.values.length > 0).filter((e) => fileExistsAfterRun(enumFilePath(e.name), isEnumInScope(e.name, ctx), ctx)).slice(0, MAX_ENUM_FORWARD_COMPAT);
 	const modelTarget = spec.models.find((m) => {
 		if (isListWrapperModel(m) || isListMetadataModel(m)) return false;
 		if (m.fields.length === 0) return false;
+		if (!fileExistsAfterRun(modelFilePath(m.name), isModelInScope(m.name, ctx), ctx)) return false;
 		return synthJsonForModelName(m.name, ctx, /* @__PURE__ */ new Set()) !== null;
 	});
 	if (enumTargets.length === 0 && !modelTarget) return null;
@@ -27221,15 +27624,26 @@ function generateTests$1(spec, ctx) {
 			overwriteExisting: true
 		});
 	}
-	files.push(generateModelRoundTripTest(spec));
+	files.push(generateModelRoundTripTest(spec, ctx));
 	return files;
 }
 /**
 * Emit test/workos/model_round_trip_test.rb that round-trips every non-wrapper
 * model through `.new(json)` and `.to_json`, asserting the result is a Hash and
 * that required fields appear with the seeded values.
-*/
-function generateModelRoundTripTest(spec) {
+*
+* This is a whole-suite AGGREGATE: it references `WorkOS::<Class>` for every
+* model. Under a scoped (`--services`) run only the selected services' per-model
+* `.rb` files are (re)written, so a test referencing a brand-new out-of-scope
+* model whose file was never emitted would raise `NameError: uninitialized
+* constant`. Each per-model test is therefore gated by {@link fileExistsAfterRun}
+* on the SAME path `models.ts` writes (`lib/workos/<dir>/<file>.rb`): emit only
+* when that file will exist on disk after the run — in-scope (emitted this run)
+* OR already present from a prior run (`priorTargetManifestPaths`). Brand-new
+* out-of-scope models are excluded; renamed/removed-but-on-disk models are
+* retained. A full run (scoping inert) keeps every model.
+*/
+function generateModelRoundTripTest(spec, ctx) {
 	const lines = [];
 	lines.push(`require 'test_helper'`);
 	lines.push("");
@@ -27237,7 +27651,15 @@ function generateModelRoundTripTest(spec) {
 	const models = spec.models.filter((m) => !isListWrapperModel(m) && !isListMetadataModel(m));
 	const enumNames = new Set(spec.enums.map((e) => e.name));
 	const emitted = /* @__PURE__ */ new Set();
+	const modelToService = assignModelsToServices(models, ctx.spec.services, ctx.modelHints);
+	const mountDirMap = buildMountDirMap(ctx);
+	const dirFor = (modelName) => {
+		const service = modelToService.get(modelName);
+		if (!service) return classifyUnassignedModel(modelName);
+		return mountDirMap.get(service) ?? classifyUnassignedModel(modelName);
+	};
 	for (const model of models) {
+		if (!fileExistsAfterRun(`lib/workos/${dirFor(model.name)}/${fileName(model.name)}.rb`, isModelInScope(model.name, ctx), ctx)) continue;
 		const fileBase = fileName(model.name);
 		if (emitted.has(fileBase)) continue;
 		emitted.add(fileBase);
@@ -28224,14 +28646,19 @@ function generateModels(models, ctx, registry) {
 		const mod = moduleName(model.name);
 		if (seen.has(mod)) continue;
 		seen.add(mod);
-		moduleNames.push(mod);
+		const inScope = isModelInScope(model.name, ctx);
 		const path = ctx.overlayLookup?.fileBySymbol?.get(model.name) ?? `src/models/${mod}.rs`;
 		const content = renderModel(model, registry, taggedVariantFields.get(model.name));
-		if (isModelInScope(model.name, ctx)) files.push({
+		if (inScope) files.push({
 			path,
 			content,
 			overwriteExisting: true
 		});
+		if (fileExistsAfterRun(path, inScope, ctx)) moduleNames.push(mod);
+	}
+	for (const base of priorManifestBasenames(ctx, "src/models", ".rs", new Set([UNIONS_MODULE, "mod"]))) if (!seen.has(base)) {
+		seen.add(base);
+		moduleNames.push(base);
 	}
 	moduleNames.push(UNIONS_MODULE);
 	files.push({
@@ -28397,13 +28824,18 @@ function generateEnums(enums, ctx) {
 		const mod = moduleName(e.name);
 		if (seen.has(mod)) continue;
 		seen.add(mod);
-		moduleNames.push(mod);
-		if (!isEnumInScope(e.name, ctx)) continue;
-		files.push({
-			path: `src/enums/${mod}.rs`,
+		const inScope = isEnumInScope(e.name, ctx);
+		const path = `src/enums/${mod}.rs`;
+		if (inScope) files.push({
+			path,
 			content: renderEnum(e),
 			overwriteExisting: true
 		});
+		if (fileExistsAfterRun(path, inScope, ctx)) moduleNames.push(mod);
+	}
+	for (const base of priorManifestBasenames(ctx, "src/enums", ".rs", new Set(["mod"]))) if (!seen.has(base)) {
+		seen.add(base);
+		moduleNames.push(base);
 	}
 	files.push({
 		path: "src/enums/mod.rs",
@@ -29543,8 +29975,14 @@ function renderResourcesApi(ctx) {
 /**
 * Generate JSON test fixture files under `tests/fixtures/`. The Rust tests
 * pull these in via `include_str!` so no I/O is required at test time.
+*
+* Scoped runs only emit a fixture for a model whose file will exist on disk
+* after the run (in-scope, or already present from a prior run). Emitting a
+* fixture for a brand-new out-of-scope model would add a stray file for a model
+* the SDK can't even reference yet; in-scope tests only `include_str!` fixtures
+* for in-scope models, so gating here is safe.
 */
-function generateFixtures(spec) {
+function generateFixtures(spec, ctx) {
 	const files = [];
 	const modelMap = new Map(spec.models.map((m) => [m.name, m]));
 	const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
@@ -29553,8 +29991,9 @@ function generateFixtures(spec) {
 		if (seen.has(model.name)) continue;
 		if (model.fields.length === 0) continue;
 		seen.add(model.name);
-		const fixture = generateModelFixture(model, modelMap, enumMap, /* @__PURE__ */ new Set());
 		const path = `tests/fixtures/${moduleName(model.name)}.json`;
+		if (!fileExistsAfterRun(path, isModelInScope(model.name, ctx), ctx)) continue;
+		const fixture = generateModelFixture(model, modelMap, enumMap, /* @__PURE__ */ new Set());
 		files.push({
 			path,
 			content: JSON.stringify(fixture, null, 2) + "\n",
@@ -29701,7 +30140,7 @@ function matchPrimitive(value, primitive) {
 */
 function generateTests(spec, ctx) {
 	const files = [];
-	files.push(...generateFixtures(spec));
+	files.push(...generateFixtures(spec, ctx));
 	files.push({
 		path: "tests/common/mod.rs",
 		content: renderCommon(ctx),
@@ -30339,4 +30778,4 @@ const workosEmittersPlugin = {
 //#endregion
 export { fieldName$2 as A, servicePropertyName$2 as B, apiClassName as C, dotnetEmitter as D, propertyName as E, fieldName$3 as F, fieldName$5 as H, methodName$3 as I, trimMountedResourceFromMethod$2 as L, trimMountedResourceFromMethod$1 as M, goEmitter as N, appendAsyncSuffix as O, className$3 as P, phpEmitter as R, kotlinEmitter as S, packageSegment as T, safeParamName$1 as U, pythonEmitter as V, nodeEmitter as W, rubyEmitter as _, rustExtractor as a, resolveServiceTarget as b, pythonExtractor as c, rustEmitter as d, fieldName as f, typeName as g, resourceAccessorName as h, kotlinExtractor as i, methodName$2 as j, className$2 as k, rubyExtractor as l, moduleName as m, elixirExtractor as n, goExtractor as o, methodName as p, dotnetExtractor as r, phpExtractor as s, workosEmittersPlugin as t, nodeExtractor as u, buildExportedClassNameSet as v, methodName$1 as w, safeParamName as x, fieldName$1 as y, fieldName$4 as z };
 
-//# sourceMappingURL=plugin-BXDPA9pJ.mjs.map
+//# sourceMappingURL=plugin-DXIciTnN.mjs.map