@workos/oagen-emitters 0.16.0 → 0.16.1

package/dist/{plugin-DuB1UozS.mjs → plugin-CpO8rePT.mjs}

@@ -1,8 +1,8 @@
+import { assignModelsToServices, assignModelsToServices as assignModelsToServices$1, collectEnumRefs, collectFieldDependencies, collectFieldDependencies as collectFieldDependencies$1, collectModelRefs, mapTypeRef, planOperation, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, toUpperSnakeCase, walkTypeRef } from "@workos/oagen";
 import * as fs$1 from "node:fs";
 import fs, { existsSync, readFileSync } from "node:fs";
 import * as path$1 from "node:path";
 import path, { resolve } from "node:path";
-import { assignModelsToServices, assignModelsToServices as assignModelsToServices$1, collectEnumRefs, collectFieldDependencies, collectFieldDependencies as collectFieldDependencies$1, collectModelRefs, mapTypeRef, planOperation, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, toUpperSnakeCase, walkTypeRef } from "@workos/oagen";
 import { execFileSync } from "node:child_process";
 import { dotnetExtractor, elixirExtractor, goExtractor, kotlinExtractor, nodeExtractor, phpExtractor, pythonExtractor, rubyExtractor, rustExtractor } from "@workos/oagen/compat";
 import { fileURLToPath } from "node:url";
@@ -2844,6 +2844,25 @@ function setBaselineInterfaceNames(names) {
 	baselineInterfaceNames = names;
 }
 /**
+* Every name DECLARED by the live SDK or baseline api-surface — interfaces
+* AND type aliases. Exact-name declarations preempt structural renames in
+* `resolveInterfaceName`: when the IR model's own name is already declared,
+* the structural matcher must not re-point it at a different declaration.
+*
+* This matters for alias-form files (`export type X = Y;`): the engine's
+* api-surface records X under `typeAliases` with no fields, so its
+* exact-name pass cannot claim X and the Jaccard fallback "renames" IR
+* model X to whatever interface looks similar. Propagating that rename
+* emitted duplicate, renamed declarations whose form flip-flopped on every
+* regeneration (workos-node ApiKeyOwner / UserManagement model files).
+*
+* Set by `index.ts` immediately after `getSurface(ctx)` runs.
+*/
+let baselineDeclaredNames = /* @__PURE__ */ new Set();
+function setBaselineDeclaredNames(names) {
+	baselineDeclaredNames = names;
+}
+/**
 * IR models that belong to newly-adopted services should not be renamed by
 * structural baseline matches from unrelated hand-written services.
 */
@@ -2880,6 +2899,142 @@ function setStructurallyRenamedDomainNames(names) {
 	structurallyRenamedDomainNames = names;
 }
 /**
+* The structural half of `resolveInterfaceName`, pre-injectivity: look up the
+* engine's structurally-inferred match (`overlayLookup.modelNameByIR`), apply
+* the adopted/discriminated/declared-name guards, and normalize legacy
+* `Serialized*` / wire-shaped `*Response` matches down to the baseline domain
+* name. Returns the candidate live name, or undefined when no structural
+* match applies. Shared by `resolveInterfaceName` and the claims registry so
+* both see the exact same candidate for every IR model.
+*/
+function inferStructuralRename(name, ctx) {
+	let inferred = adoptedModelNames.has(name) || discriminatedModelNames.has(name) ? void 0 : ctx.overlayLookup?.modelNameByIR?.get(name);
+	if (inferred && inferred !== name && baselineDeclaredNames.has(name)) return;
+	if (!inferred) return void 0;
+	if (inferred.startsWith("Serialized")) {
+		const stripped = inferred.slice(10);
+		if (stripped && ctx.apiSurface?.interfaces?.[stripped]) inferred = stripped;
+	}
+	if (inferred.endsWith("Response") && ctx.apiSurface?.interfaces) {
+		const stripped = inferred.slice(0, -8);
+		if (stripped && ctx.apiSurface.interfaces[stripped]) inferred = stripped;
+	}
+	return inferred;
+}
+/**
+* Per-run registry making structural name resolution INJECTIVE: live-surface
+* name → the single IR model name allowed to claim it. Built lazily from
+* `ctx.spec.models` on first use and cached per ctx.
+*
+* Cache-correctness invariant (relied on, not assumed): the `ctx` reaching
+* this function is always the memoized `nodeCtx` from `withNodeOperationOverrides`
+* — every emitter hook derives it as its first step and threads it through
+* `getSurface`/`resolveInterfaceName`, and that helper returns one stable
+* object per run. `nodeCtx.spec` is built once via spread and `spec.models` is
+* never reassigned or mutated in place anywhere (enrichment pushes only onto a
+* pre-enrichment local collector). So the cached value can never drift from
+* the `spec.models` it was computed from. Do not begin mutating `spec.models`
+* under a live ctx without invalidating this cache.
+*
+* Without it, the structural fallback could map two distinct IR models onto
+* one live declaration. workos-node AuditLogs evidence: IR
+* `AuditLogEventActor` and `AuditLogEventTarget` (near-identical shapes) both
+* resolved to the hand-written `AuditLogActor`, so
+* `audit-log-event-target.interface.ts` was emitted declaring
+* `export interface AuditLogActor` (file stem and declaration disagree),
+* with duplicate imports/`describe` blocks and two `serializeAuditLogActor`
+* definitions downstream. The raw engine overlay is injective on its own
+* names, but the resolver's `Serialized*`/`*Response` normalization below can
+* collapse two distinct raw matches onto one bare name — the claims registry
+* gates the final, post-normalization answer.
+*
+* Claim order:
+*  1. Exact-name overrides (`overlayLookup.interfaceByName`) claim first.
+*  2. Identity structural matches (IR name === live name) claim their own name.
+*  3. Contested renames go to the claimant with the higher field-overlap
+*     similarity; ties break toward the closer name (edit distance), then
+*     lexicographically for determinism. Losers are NEVER unified — they keep
+*     their canonical IR-derived names.
+*/
+const structuralClaimsCache = /* @__PURE__ */ new WeakMap();
+/** Jaccard similarity between two normalized field-name sets. */
+function fieldJaccard(a, b) {
+	if (a.size === 0 && b.size === 0) return 0;
+	let intersection = 0;
+	for (const item of a) if (b.has(item)) intersection++;
+	const union = a.size + b.size - intersection;
+	return union === 0 ? 0 : intersection / union;
+}
+/** Levenshtein distance over lowercased names (tie-break for contested claims). */
+function nameDistance(a, b) {
+	const s = a.toLowerCase();
+	const t = b.toLowerCase();
+	if (s === t) return 0;
+	let prev = Array.from({ length: t.length + 1 }, (_, i) => i);
+	for (let i = 1; i <= s.length; i++) {
+		const curr = [i];
+		for (let j = 1; j <= t.length; j++) {
+			const cost = s[i - 1] === t[j - 1] ? 0 : 1;
+			curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+		}
+		prev = curr;
+	}
+	return prev[t.length];
+}
+/** Normalized field-name signature of an IR model. */
+function irFieldSignature(model) {
+	return new Set(model.fields.map((f) => toSnakeCase(f.name)));
+}
+/** Normalized field-name signature of a live-surface interface, if known. */
+function liveFieldSignature(ctx, liveName) {
+	const iface = ctx.apiSurface?.interfaces?.[liveName];
+	if (!iface?.fields) return void 0;
+	return new Set(Object.keys(iface.fields).map((f) => toSnakeCase(f)));
+}
+function getStructuralNameClaims(ctx) {
+	const cached = structuralClaimsCache.get(ctx);
+	if (cached) return cached;
+	const claims = /* @__PURE__ */ new Map();
+	for (const [irName, liveName] of ctx.overlayLookup?.interfaceByName ?? /* @__PURE__ */ new Map()) if (!claims.has(liveName)) claims.set(liveName, irName);
+	const contested = /* @__PURE__ */ new Map();
+	const modelsByName = /* @__PURE__ */ new Map();
+	for (const model of ctx.spec.models) {
+		modelsByName.set(model.name, model);
+		if (ctx.overlayLookup?.interfaceByName?.has(model.name)) continue;
+		const inferred = inferStructuralRename(model.name, ctx);
+		if (!inferred) continue;
+		if (inferred === model.name) {
+			if (!claims.has(inferred)) claims.set(inferred, model.name);
+			continue;
+		}
+		const group = contested.get(inferred);
+		if (group) group.push(model.name);
+		else contested.set(inferred, [model.name]);
+	}
+	for (const [liveName, irNames] of contested) {
+		if (claims.has(liveName)) continue;
+		let winner = irNames[0];
+		if (irNames.length > 1) {
+			const liveFields = liveFieldSignature(ctx, liveName);
+			const scoreOf = (irName) => {
+				const model = modelsByName.get(irName);
+				if (!model || !liveFields) return 0;
+				return fieldJaccard(irFieldSignature(model), liveFields);
+			};
+			winner = [...irNames].sort((a, b) => {
+				const scoreDiff = scoreOf(b) - scoreOf(a);
+				if (scoreDiff !== 0) return scoreDiff;
+				const distDiff = nameDistance(a, liveName) - nameDistance(b, liveName);
+				if (distDiff !== 0) return distDiff;
+				return a < b ? -1 : a > b ? 1 : 0;
+			})[0];
+		}
+		claims.set(liveName, winner);
+	}
+	structuralClaimsCache.set(ctx, claims);
+	return claims;
+}
+/**
 * Wire/response interface name.
 *
 * Resolution order:
@@ -2978,7 +3133,8 @@ function resolveClassName$5(service, ctx) {
 *  1. `overlayLookup.interfaceByName` — exact-name overrides from the live SDK.
 *  2. `overlayLookup.modelNameByIR` — structurally-inferred matches (e.g., IR
 *     `ValidateApiKey` with one field `value: string` → live SDK interface
-*     `ValidateApiKeyOptions`).
+*     `ValidateApiKeyOptions`), gated by the injective claims registry: each
+*     live name goes to at most one IR model (see `getStructuralNameClaims`).
 *  3. Type-alias resolution (when an alias points to an interface).
 *  4. Suffix-fallback heuristic for the workos-node `*Options` convention:
 *     when the IR name `X` has no baseline match but `XOptions` does, use
@@ -2989,17 +3145,13 @@ function resolveClassName$5(service, ctx) {
 function resolveInterfaceName(name, ctx, opts) {
 	const existing = ctx.overlayLookup?.interfaceByName?.get(name);
 	if (existing) return existing;
-	let inferred = adoptedModelNames.has(name) || discriminatedModelNames.has(name) ? void 0 : ctx.overlayLookup?.modelNameByIR?.get(name);
-	if (inferred) {
-		if (inferred.startsWith("Serialized")) {
-			const stripped = inferred.slice(10);
-			if (stripped && ctx.apiSurface?.interfaces?.[stripped]) inferred = stripped;
-		}
-		if (inferred.endsWith("Response") && ctx.apiSurface?.interfaces) {
-			const stripped = inferred.slice(0, -8);
-			if (stripped && ctx.apiSurface.interfaces[stripped]) inferred = stripped;
+	let inferred = inferStructuralRename(name, ctx);
+	if (inferred !== void 0) {
+		if (inferred !== name) {
+			const claimant = getStructuralNameClaims(ctx).get(inferred);
+			if (claimant !== void 0 && claimant !== name) inferred = void 0;
 		}
-		return inferred;
+		if (inferred !== void 0) return inferred;
 	}
 	if (!opts?.skipTypeAlias && ctx.apiSurface?.typeAliases) {
 		const alias = ctx.apiSurface.typeAliases[name];
@@ -3120,416 +3272,84 @@ function parenthesizeUnion$1(type) {
 	return type.includes(" | ") || type.includes(" & ") ? `(${type})` : type;
 }
 //#endregion
-//#region src/node/utils.ts
-/**
-* Compute a relative import path between two files within the generated SDK.
-*/
-function relativeImport(fromFile, toFile) {
-	const fromDir = fromFile.split("/").slice(0, -1);
-	const toFileParts = toFile.split("/");
-	const toDir = toFileParts.slice(0, -1);
-	const toFileName = toFileParts[toFileParts.length - 1];
-	let common = 0;
-	while (common < fromDir.length && common < toDir.length && fromDir[common] === toDir[common]) common++;
-	const ups = fromDir.length - common;
-	const downs = toDir.slice(common);
-	let result = [
-		...Array(ups).fill(".."),
-		...downs,
-		toFileName
-	].join("/");
-	result = result.replace(/\.ts$/, "");
-	if (!result.startsWith(".")) result = "./" + result;
-	return result;
+//#region src/node/options.ts
+function nodeOptions(ctx) {
+	return ctx.emitterOptions ?? {};
 }
-/**
-* Render a JSDoc comment block from a description string.
-*/
-function docComment$2(description, indent = 0) {
-	const pad = " ".repeat(indent);
-	const descLines = description.split("\n");
-	if (descLines.length === 1) return [`${pad}/** ${descLines[0]} */`];
-	const lines = [`${pad}/**`];
-	for (const line of descLines) lines.push(line === "" ? `${pad} *` : `${pad} * ${line}`);
-	lines.push(`${pad} */`);
-	return lines;
+function normalizeServiceName(name) {
+	return name.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
 }
-/**
-* Build a map from model name -> default type args string for generic models.
-*/
-function buildGenericModelDefaults(models) {
-	const result = /* @__PURE__ */ new Map();
-	for (const model of models) {
-		if (!model.typeParams?.length) continue;
-		const defaults = model.typeParams.map((tp) => tp.default ? mapTypeRef$7(tp.default) : "unknown");
-		result.set(model.name, `<${defaults.join(", ")}>`);
-	}
-	return result;
+function ownedLookupNames(name) {
+	const names = [name];
+	if (name.startsWith("__baseline_dir__:")) names.push(name.slice(17));
+	return names;
 }
+function isNodeOwnedService(ctx, ...names) {
+	const configured = nodeOptions(ctx).ownedServices ?? [];
+	if (configured.length === 0) return false;
+	const owned = new Set(configured.map(normalizeServiceName));
+	return names.some((name) => name !== void 0 ? ownedLookupNames(name).some((candidate) => owned.has(normalizeServiceName(candidate))) : false);
+}
+//#endregion
+//#region src/node/live-surface.ts
+const SRC_DIR = "src";
 /**
-* Remove unused imports from generated source code.
+* Walk `${rootDir}/src/` and build a live-surface snapshot.
+*
+* If `${rootDir}/src/` does not exist, returns an empty surface (greenfield).
+* Reads each `.ts` file once; ignores `.spec.ts` and `.test.ts`.
 */
-function pruneUnusedImports(lines) {
-	const importLines = [];
-	const bodyLines = [];
-	let inBody = false;
-	for (const line of lines) if (!inBody && (line.startsWith("import ") || line === "")) importLines.push(line);
-	else {
-		inBody = true;
-		bodyLines.push(line);
-	}
-	const body = bodyLines.join("\n");
-	const kept = [];
-	for (const line of importLines) {
-		if (line === "") {
-			kept.push(line);
-			continue;
-		}
-		const match = line.match(/\{([^}]+)\}/);
-		if (!match) {
-			kept.push(line);
+function buildLiveSurface(rootDir) {
+	const surface = {
+		rootDir,
+		files: /* @__PURE__ */ new Set(),
+		trackedFiles: loadGitTrackedFiles(rootDir),
+		protectedFiles: /* @__PURE__ */ new Set(),
+		autogenFiles: /* @__PURE__ */ new Set(),
+		classes: /* @__PURE__ */ new Map(),
+		interfaces: /* @__PURE__ */ new Map(),
+		functions: /* @__PURE__ */ new Map(),
+		constObjectEnums: /* @__PURE__ */ new Map()
+	};
+	const srcRoot = path$1.join(rootDir, SRC_DIR);
+	if (!fs$1.existsSync(srcRoot) || !fs$1.statSync(srcRoot).isDirectory()) return surface;
+	for (const absPath of walk$1(srcRoot)) {
+		const rel = toPosix(path$1.relative(rootDir, absPath));
+		surface.files.add(rel);
+		if (!rel.endsWith(".ts")) continue;
+		if (surface.trackedFiles.size > 0 && !surface.trackedFiles.has(rel)) continue;
+		let text;
+		try {
+			text = fs$1.readFileSync(absPath, "utf8");
+		} catch {
 			continue;
 		}
-		const names = match[1].split(",").map((n) => n.trim()).filter(Boolean);
-		const usedNames = names.filter((name) => {
-			return new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(body);
-		});
-		if (usedNames.length === 0) continue;
-		if (usedNames.length === names.length) kept.push(line);
-		else {
-			const isTypeImport = line.startsWith("import type");
-			const fromMatch = line.match(/from\s+['"]([^'"]+)['"]/);
-			if (fromMatch) {
-				const prefix = isTypeImport ? "import type" : "import";
-				kept.push(`${prefix} { ${usedNames.join(", ")} } from '${fromMatch[1]}';`);
-			} else kept.push(line);
-		}
+		if (isProtected(text)) surface.protectedFiles.add(rel);
+		else if (isAutogen(text)) surface.autogenFiles.add(rel);
+		if (rel.endsWith(".spec.ts") || rel.endsWith(".test.ts")) continue;
+		extractDeclarations(text, rel, surface);
 	}
-	return [...kept, ...bodyLines];
+	return surface;
 }
-/** Built-in TypeScript types that are always available. */
-const TS_BUILTINS = new Set([
-	"Record",
-	"Promise",
-	"Array",
-	"Map",
-	"Set",
-	"Date",
-	"string",
-	"number",
-	"boolean",
-	"void",
-	"null",
-	"undefined",
-	"any",
-	"never",
-	"unknown",
-	"true",
-	"false"
-]);
 /**
-* Build a comprehensive set of all known type names from the IR and baseline.
+* Module-level snapshot of the active live-surface, set by `index.ts` once per
+* generation run. Used by callers that don't have a clean way to thread
+* `EmitterContext` through (e.g. deeply-nested helpers in `resources.ts`
+* that decide whether to inline a serializer call).
 */
-function buildKnownTypeNames(models, ctx) {
-	const knownNames = /* @__PURE__ */ new Set();
-	for (const m of models) knownNames.add(resolveInterfaceName(m.name, ctx));
-	for (const e of ctx.spec.enums) knownNames.add(e.name);
-	if (ctx.apiSurface?.interfaces) for (const name of Object.keys(ctx.apiSurface.interfaces)) knownNames.add(name);
-	if (ctx.apiSurface?.typeAliases) for (const name of Object.keys(ctx.apiSurface.typeAliases)) knownNames.add(name);
-	if (ctx.apiSurface?.enums) for (const name of Object.keys(ctx.apiSurface.enums)) knownNames.add(name);
-	return knownNames;
+let activeSurface = null;
+function setActiveLiveSurface(surface) {
+	activeSurface = surface;
 }
-/**
-* Create a service directory resolver bundle.
-*
-* When `ctx.apiSurface` is populated, the baseline `sourceFile` of an
-* existing interface wins over the IR-derived first-reference assignment.
-* This keeps generated imports pointing at the existing live SDK location
-* instead of duplicating a model into a different service directory.
-*/
-function createServiceDirResolver(models, services, ctx) {
-	const modelToService = assignModelsToServices(models, services, ctx.modelHints);
-	const serviceNameMap = buildServiceNameMap(services, ctx);
-	const baselineDirByModel = /* @__PURE__ */ new Map();
-	const recordSource = (name, info) => {
-		const sourceFile = info?.sourceFile;
-		if (!sourceFile) return;
-		const m = sourceFile.match(/^src\/([^/]+)\//);
-		if (!m) return;
-		baselineDirByModel.set(name, m[1]);
-	};
-	for (const [name, info] of Object.entries(ctx.apiSurface?.interfaces ?? {})) recordSource(name, info);
-	for (const [name, info] of Object.entries(ctx.apiSurface?.typeAliases ?? {})) if (!baselineDirByModel.has(name)) recordSource(name, info);
-	for (const [modelName] of modelToService) {
-		const dir = baselineDirByModel.get(modelName);
-		if (!dir) continue;
-		const synthetic = `__baseline_dir__:${dir}`;
-		modelToService.set(modelName, synthetic);
-		if (!serviceNameMap.has(synthetic)) serviceNameMap.set(synthetic, dir);
-	}
-	const resolveDir = (irService) => {
-		if (!irService) return "common";
-		if (irService.startsWith("__baseline_dir__:")) return irService.slice(17);
-		return resolveServiceDir$1(serviceNameMap.get(irService) ?? irService);
-	};
-	return {
-		modelToService,
-		serviceNameMap,
-		resolveDir
-	};
+function liveSurfaceHasFunction(name) {
+	return activeSurface?.functions.has(name) ?? false;
 }
-/**
-* Check if baseline interface fields appear to contain generic type parameters.
-*
-* Heuristic: strip string literals first (so `'GoogleSAML'` is not mistaken
-* for a type name), then look for any PascalCase token that isn't a known
-* type — those indicate an unbound generic parameter like `TCustomAttributes`.
-*/
-function isBaselineGeneric(fields, knownNames) {
-	for (const [, bf] of Object.entries(fields)) {
-		const typeNames = bf.type.replace(/'[^']*'/g, "").replace(/"[^"]*"/g, "").match(/\b[A-Z][a-zA-Z0-9]*\b/g);
-		if (!typeNames) continue;
-		for (const tn of typeNames) {
-			if (TS_BUILTINS.has(tn)) continue;
-			if (knownNames.has(tn)) continue;
-			return true;
-		}
-	}
-	return false;
+/** Returns the relative file path containing the function, if known. */
+function liveSurfaceFunctionPath(name) {
+	return activeSurface?.functions.get(name);
 }
-function modelFingerprint(model) {
-	return model.fields.map((f) => `${f.name}:${JSON.stringify(f.type)}:${f.required}`).sort().join("|");
-}
-/**
-* Find structurally identical models and build a deduplication map.
-*/
-function buildDeduplicationMap(models, ctx, reachable) {
-	const dedup = /* @__PURE__ */ new Map();
-	const fingerprints = /* @__PURE__ */ new Map();
-	for (const model of models) {
-		if (model.fields.length === 0) continue;
-		const fp = modelFingerprint(model);
-		const existing = fingerprints.get(fp);
-		if (existing) if (reachable && !reachable.has(existing) && reachable.has(model.name)) {
-			dedup.delete(existing);
-			dedup.set(existing, model.name);
-			fingerprints.set(fp, model.name);
-		} else dedup.set(model.name, existing);
-		else fingerprints.set(fp, model.name);
-	}
-	if (ctx) {
-		const byDomainName = /* @__PURE__ */ new Map();
-		for (const model of models) {
-			if (model.fields.length === 0) continue;
-			if (dedup.has(model.name)) continue;
-			const domainName = resolveInterfaceName(model.name, ctx);
-			const group = byDomainName.get(domainName);
-			if (group) group.push(model);
-			else byDomainName.set(domainName, [model]);
-		}
-		for (const [, group] of byDomainName) {
-			if (group.length < 2) continue;
-			group.sort((a, b) => {
-				if (reachable) {
-					const aReach = reachable.has(a.name) ? 0 : 1;
-					const bReach = reachable.has(b.name) ? 0 : 1;
-					if (aReach !== bReach) return aReach - bReach;
-				}
-				return b.fields.length - a.fields.length || a.name.localeCompare(b.name);
-			});
-			const canonical = group[0];
-			for (let i = 1; i < group.length; i++) dedup.set(group[i].name, canonical.name);
-		}
-	}
-	return dedup;
-}
-/**
-* Check whether a service's endpoints are already fully covered by existing
-* hand-written service classes.
-*/
-function isServiceCoveredByExisting(service, ctx) {
-	if (getMountTarget(service, ctx) !== toPascalCase(service.name)) return true;
-	const overlay = ctx.overlayLookup?.methodByOperation;
-	if (!overlay || overlay.size === 0) return false;
-	if (service.operations.length === 0) return false;
-	const baselineClasses = ctx.apiSurface?.classes;
-	if (!baselineClasses) return false;
-	const existingClassNames = new Set(Object.keys(baselineClasses));
-	return service.operations.every((op) => {
-		const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
-		const match = overlay.get(httpKey);
-		if (!match) return false;
-		return existingClassNames.has(match.className);
-	});
-}
-/**
-* Check whether a fully-covered service has operations whose overlay-mapped
-* methods are missing from the baseline class.
-*/
-function hasMethodsAbsentFromBaseline(service, ctx) {
-	const baselineClasses = ctx.apiSurface?.classes;
-	if (!baselineClasses) return false;
-	const mountTarget = getMountTarget(service, ctx);
-	if (mountTarget !== toPascalCase(service.name)) {
-		const cls = baselineClasses[mountTarget];
-		if (!cls) return true;
-		for (const op of service.operations) {
-			const method = resolveMethodName$6(op, service, ctx);
-			if (!cls.methods?.[method]) return true;
-		}
-		return false;
-	}
-	const overlay = ctx.overlayLookup?.methodByOperation;
-	if (!overlay) return false;
-	for (const op of service.operations) {
-		const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
-		const match = overlay.get(httpKey);
-		if (!match) continue;
-		const cls = baselineClasses[match.className];
-		if (!cls) continue;
-		if (!cls.methods?.[match.methodName]) return true;
-	}
-	return false;
-}
-/**
-* Check whether an IR model has fields not present in the baseline interface.
-*
-* When the live SDK exposes the same name as a type alias (e.g.
-* `type Role = EnvironmentRole | OrganizationRole;`), treat it as already
-* fully covered — generating an interface against an existing alias would
-* collide. The alias's referenced types still get generated independently
-* and serve as the canonical implementation.
-*/
-function modelHasNewFields(model, ctx) {
-	if (!ctx.apiSurface?.interfaces && !ctx.apiSurface?.typeAliases) return true;
-	const domainName = resolveInterfaceName(model.name, ctx);
-	if (ctx.apiSurface?.typeAliases?.[domainName]) return false;
-	const baseline = ctx.apiSurface?.interfaces?.[domainName];
-	if (!baseline?.fields) return true;
-	for (const field of model.fields) {
-		const camelName = fieldName$6(field.name);
-		if (!baseline.fields[camelName]) return true;
-	}
-	return false;
-}
-/**
-* Return operations in a service that are NOT covered by existing hand-written
-* service classes.
-*/
-function uncoveredOperations(service, ctx) {
-	const overlay = ctx.overlayLookup?.methodByOperation;
-	if (!overlay || overlay.size === 0) return service.operations;
-	const baselineClasses = ctx.apiSurface?.classes;
-	if (!baselineClasses) return service.operations;
-	const existingClassNames = new Set(Object.keys(baselineClasses));
-	return service.operations.filter((op) => {
-		const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
-		const match = overlay.get(httpKey);
-		if (!match) return true;
-		return !existingClassNames.has(match.className);
-	});
-}
-/**
-* Compute the set of model names reachable from non-event service operations.
-*/
-function computeNonEventReachable(services, models) {
-	const seeds = /* @__PURE__ */ new Set();
-	for (const svc of services) {
-		if (svc.name.toLowerCase() === "events") continue;
-		for (const op of svc.operations) {
-			const collectFromRef = (t) => {
-				if (!t) return;
-				if (t.kind === "model") seeds.add(t.name);
-				if (t.kind === "array") collectFromRef(t.items);
-				if (t.kind === "nullable") collectFromRef(t.inner);
-				if (t.kind === "union") t.variants.forEach(collectFromRef);
-			};
-			collectFromRef(op.response);
-			collectFromRef(op.requestBody);
-			if (op.pagination?.itemType) collectFromRef(op.pagination.itemType);
-		}
-	}
-	const modelMap = new Map(models.map((m) => [m.name, m]));
-	const reachable = /* @__PURE__ */ new Set();
-	const queue = [...seeds];
-	while (queue.length > 0) {
-		const name = queue.pop();
-		if (reachable.has(name)) continue;
-		reachable.add(name);
-		const m = modelMap.get(name);
-		if (!m) continue;
-		for (const field of m.fields) {
-			const walk = (t) => {
-				if (t.kind === "model" && !reachable.has(t.name)) queue.push(t.name);
-				if (t.kind === "array") walk(t.items);
-				if (t.kind === "nullable") walk(t.inner);
-				if (t.kind === "union") t.variants.forEach(walk);
-			};
-			walk(field.type);
-		}
-	}
-	return reachable;
-}
-//#endregion
-//#region src/node/live-surface.ts
-const SRC_DIR = "src";
-/**
-* Walk `${rootDir}/src/` and build a live-surface snapshot.
-*
-* If `${rootDir}/src/` does not exist, returns an empty surface (greenfield).
-* Reads each `.ts` file once; ignores `.spec.ts` and `.test.ts`.
-*/
-function buildLiveSurface(rootDir) {
-	const surface = {
-		rootDir,
-		files: /* @__PURE__ */ new Set(),
-		trackedFiles: loadGitTrackedFiles(rootDir),
-		protectedFiles: /* @__PURE__ */ new Set(),
-		autogenFiles: /* @__PURE__ */ new Set(),
-		classes: /* @__PURE__ */ new Map(),
-		interfaces: /* @__PURE__ */ new Map(),
-		functions: /* @__PURE__ */ new Map(),
-		constObjectEnums: /* @__PURE__ */ new Map()
-	};
-	const srcRoot = path$1.join(rootDir, SRC_DIR);
-	if (!fs$1.existsSync(srcRoot) || !fs$1.statSync(srcRoot).isDirectory()) return surface;
-	for (const absPath of walk$1(srcRoot)) {
-		const rel = toPosix(path$1.relative(rootDir, absPath));
-		surface.files.add(rel);
-		if (!rel.endsWith(".ts")) continue;
-		if (surface.trackedFiles.size > 0 && !surface.trackedFiles.has(rel)) continue;
-		let text;
-		try {
-			text = fs$1.readFileSync(absPath, "utf8");
-		} catch {
-			continue;
-		}
-		if (isProtected(text)) surface.protectedFiles.add(rel);
-		else if (isAutogen(text)) surface.autogenFiles.add(rel);
-		if (rel.endsWith(".spec.ts") || rel.endsWith(".test.ts")) continue;
-		extractDeclarations(text, rel, surface);
-	}
-	return surface;
-}
-/**
-* Module-level snapshot of the active live-surface, set by `index.ts` once per
-* generation run. Used by callers that don't have a clean way to thread
-* `EmitterContext` through (e.g. deeply-nested helpers in `resources.ts`
-* that decide whether to inline a serializer call).
-*/
-let activeSurface = null;
-function setActiveLiveSurface(surface) {
-	activeSurface = surface;
-}
-function liveSurfaceHasFunction(name) {
-	return activeSurface?.functions.has(name) ?? false;
-}
-/** Returns the relative file path containing the function, if known. */
-function liveSurfaceFunctionPath(name) {
-	return activeSurface?.functions.get(name);
-}
-function liveSurfaceHasFile(relPath) {
-	return activeSurface?.files.has(relPath) ?? false;
+function liveSurfaceHasFile(relPath) {
+	return activeSurface?.files.has(relPath) ?? false;
 }
 function liveSurfaceHasManagedFile(relPath) {
 	const surface = activeSurface;
@@ -3659,68 +3479,741 @@ function extractDeclarations(text, relPath, surface) {
 			const value = memberMatch[4];
 			if (memberName && value !== void 0) members.set(value, memberName);
 		}
-		if (members.size > 0) surface.constObjectEnums.set(enumName, members);
+		if (members.size > 0) surface.constObjectEnums.set(enumName, members);
+	}
+}
+const CONST_OBJECT_ENUM_RE = /^\s*export\s+const\s+([A-Z][\w$]*)\s*=\s*\{([\s\S]*?)\}\s*as\s+const\s*;/gm;
+const CONST_OBJECT_MEMBER_RE = /(?:'([^']+)'|"([^"]+)"|([a-zA-Z_$][\w$]*))\s*:\s*'([^']*)'/g;
+const METHOD_KEYWORD_BLOCKLIST = new Set([
+	"if",
+	"for",
+	"while",
+	"switch",
+	"catch",
+	"return",
+	"throw",
+	"constructor"
+]);
+const CLASS_MEMBER_RE = /^ {2}(?:(?:public|private|protected|readonly|static)\s+)*(?:async\s+)?([a-zA-Z_$][\w$]*)\s*(?:<[^>]*>)?\s*\(/;
+/**
+* Advance a brace-balance scan across one `line`, mutating `s`. Counts only
+* braces that live in *code* — including template `${ … }` interpolation,
+* whose braces are self-balancing — and ignores braces inside string/template
+* text, line comments, and block comments. State threads across lines so block
+* comments and multi-line template literals are tracked correctly.
+*
+* Naive character counting (the prior approach) would clip a method block at a
+* `}` that merely sat inside a comment (`// returns when done }`) or a string
+* (`'closing brace: }'`), appending a truncated, unbalanced body. Regex
+* literals are intentionally not modelled: distinguishing `/` division from a
+* regex needs full tokenization, and a regex whose braces are net-unbalanced
+* does not occur in generated or hand-edited SDK code (`{n,m}` quantifiers are
+* always balanced).
+*/
+function advanceBraceScan(line, s) {
+	for (let i = 0; i < line.length; i++) {
+		const c = line[i];
+		if (s.inBlockComment) {
+			if (c === "*" && line[i + 1] === "/") {
+				s.inBlockComment = false;
+				i++;
+			}
+			continue;
+		}
+		const tdepth = s.templates.length;
+		if (tdepth > 0 && s.templates[tdepth - 1] === 0) {
+			if (c === "\\") i++;
+			else if (c === "`") s.templates.pop();
+			else if (c === "$" && line[i + 1] === "{") {
+				s.templates[tdepth - 1] = 1;
+				s.depth++;
+				s.opened = true;
+				i++;
+			}
+			continue;
+		}
+		if (c === "/" && line[i + 1] === "/") break;
+		if (c === "/" && line[i + 1] === "*") {
+			s.inBlockComment = true;
+			i++;
+			continue;
+		}
+		if (c === "'" || c === "\"") {
+			const quote = c;
+			i++;
+			while (i < line.length && line[i] !== quote) {
+				if (line[i] === "\\") i++;
+				i++;
+			}
+			continue;
+		}
+		if (c === "`") {
+			s.templates.push(0);
+			continue;
+		}
+		if (c === "{") {
+			s.depth++;
+			s.opened = true;
+			if (tdepth > 0) s.templates[tdepth - 1]++;
+		} else if (c === "}") {
+			s.depth--;
+			if (tdepth > 0) s.templates[tdepth - 1]--;
+		}
+	}
+}
+function parseClassesByLine(lines) {
+	const classes = [];
+	for (let i = 0; i < lines.length; i++) {
+		const decl = lines[i].match(/^export\s+(?:abstract\s+)?class\s+([A-Z][\w$]*)/);
+		if (!decl) continue;
+		const scan = {
+			depth: 0,
+			opened: false,
+			inBlockComment: false,
+			templates: []
+		};
+		let closeLine = -1;
+		for (let j = i; j < lines.length; j++) {
+			advanceBraceScan(lines[j], scan);
+			if (scan.opened && scan.depth <= 0) {
+				closeLine = j;
+				break;
+			}
+		}
+		if (closeLine < 0) continue;
+		const methods = [];
+		for (let j = i + 1; j < closeLine; j++) {
+			const member = lines[j].match(CLASS_MEMBER_RE);
+			if (!member) continue;
+			const name = member[1];
+			if (name === "constructor" || METHOD_KEYWORD_BLOCKLIST.has(name)) continue;
+			if (!methods.includes(name)) methods.push(name);
+		}
+		classes.push({
+			name: decl[1],
+			declLine: i,
+			closeLine,
+			methods
+		});
+		i = closeLine;
+	}
+	return classes;
+}
+/**
+* Extract the full source block of `method` (attached comments included) from
+* a parsed class. Returns null if the block cannot be delimited.
+*/
+function extractMethodBlock(lines, cls, method) {
+	for (let j = cls.declLine + 1; j < cls.closeLine; j++) {
+		const member = lines[j].match(CLASS_MEMBER_RE);
+		if (!member || member[1] !== method) continue;
+		let start = j;
+		while (start > cls.declLine + 1) {
+			const above = lines[start - 1].trim();
+			if (above.startsWith("//") || above.startsWith("/*") || above.startsWith("*")) start--;
+			else break;
+		}
+		const scan = {
+			depth: 0,
+			opened: false,
+			inBlockComment: false,
+			templates: []
+		};
+		for (let end = j; end < cls.closeLine; end++) {
+			advanceBraceScan(lines[end], scan);
+			if (scan.opened && scan.depth <= 0) return lines.slice(start, end + 1);
+		}
+		return null;
+	}
+	return null;
+}
+const IMPORT_STMT_RE = /^import\s+(type\s+)?(?:([A-Za-z_$][\w$]*)\s*,?\s*)?(?:\{([\s\S]*?)\}\s*)?(?:\*\s+as\s+([A-Za-z_$][\w$]*)\s+)?from\s+['"]([^'"]+)['"];?/gm;
+function importLocalName(entry) {
+	const asMatch = entry.match(/\s+as\s+([A-Za-z_$][\w$]*)\s*$/);
+	if (asMatch) return asMatch[1];
+	return entry.replace(/^type\s+/, "").trim();
+}
+function collectImportedLocalNames(text) {
+	const names = /* @__PURE__ */ new Set();
+	for (const m of text.matchAll(IMPORT_STMT_RE)) {
+		if (m[2]) names.add(m[2]);
+		if (m[4]) names.add(m[4]);
+		for (const entry of (m[3] ?? "").split(",")) {
+			const trimmed = entry.trim();
+			if (trimmed) names.add(importLocalName(trimmed));
+		}
+	}
+	return names;
+}
+/** Import statements from `generatedText` whose names `existingText` lacks. */
+function missingImportStatements(existingText, generatedText) {
+	const existingNames = collectImportedLocalNames(existingText);
+	const statements = [];
+	for (const m of generatedText.matchAll(IMPORT_STMT_RE)) {
+		const [stmt, typeOnly, defaultName, named, namespaceName, moduleSpec] = m;
+		if (defaultName || namespaceName) {
+			const local = defaultName ?? namespaceName;
+			if (local && !existingNames.has(local)) statements.push(stmt.endsWith(";") ? stmt : `${stmt};`);
+			continue;
+		}
+		const missing = (named ?? "").split(",").map((entry) => entry.trim()).filter((entry) => entry && !existingNames.has(importLocalName(entry)));
+		if (missing.length === 0) continue;
+		statements.push(`import ${typeOnly ? "type " : ""}{ ${missing.join(", ")} } from '${moduleSpec}';`);
+	}
+	return statements;
+}
+/**
+* Merge a partial class emission into the existing on-disk file content.
+*
+* Acts only when a class declared in BOTH texts has methods on disk that the
+* generated content drops — the signature of a "new operations only" partial
+* emission. Returns the existing text with the generated-only methods appended
+* to the class body (and missing imports added), preserving every existing
+* method and import verbatim.
+*
+* Returns null when the generated content does not drop any existing method;
+* callers should then proceed with their normal (overwrite) path so full
+* regenerations keep propagating emitter improvements and spec renames.
+*/
+function mergeGeneratedClassMethodsIntoExisting(existingText, generatedText) {
+	const existingLines = existingText.split("\n");
+	const generatedLines = generatedText.split("\n");
+	const existingClasses = parseClassesByLine(existingLines);
+	if (existingClasses.length === 0) return null;
+	const generatedClasses = new Map(parseClassesByLine(generatedLines).map((cls) => [cls.name, cls]));
+	let dropsExistingMethod = false;
+	const insertions = [];
+	for (const existing of existingClasses) {
+		const generated = generatedClasses.get(existing.name);
+		if (!generated) continue;
+		const generatedMethods = new Set(generated.methods);
+		if (!existing.methods.some((method) => !generatedMethods.has(method))) continue;
+		dropsExistingMethod = true;
+		const existingMethods = new Set(existing.methods);
+		const blocks = [];
+		for (const method of generated.methods) {
+			if (existingMethods.has(method)) continue;
+			const block = extractMethodBlock(generatedLines, generated, method);
+			if (block) blocks.push(block);
+		}
+		if (blocks.length > 0) insertions.push({
+			atLine: existing.closeLine,
+			blocks
+		});
+	}
+	if (!dropsExistingMethod) return null;
+	const merged = [...existingLines];
+	insertions.sort((a, b) => b.atLine - a.atLine);
+	for (const insertion of insertions) {
+		const blockLines = [];
+		for (const block of insertion.blocks) blockLines.push("", ...block);
+		merged.splice(insertion.atLine, 0, ...blockLines);
+	}
+	const importStatements = missingImportStatements(existingText, generatedText);
+	if (importStatements.length > 0) {
+		let lastImportLine = -1;
+		for (let i = 0; i < existingLines.length; i++) if (/from\s+['"][^'"]+['"];?\s*$/.test(existingLines[i]) || /^import\s+['"][^'"]+['"];?\s*$/.test(existingLines[i])) lastImportLine = i;
+		if (lastImportLine >= 0) merged.splice(lastImportLine + 1, 0, ...importStatements);
+		else {
+			let insertAt = 0;
+			while (insertAt < existingLines.length) {
+				const line = existingLines[insertAt].trim();
+				if (line === "" || line.startsWith("//") || line.startsWith("/*") || line.startsWith("*")) insertAt++;
+				else break;
+			}
+			merged.splice(insertAt, 0, ...importStatements, "");
+		}
+	}
+	return merged.join("\n");
+}
+/**
+* Given the start index of a class declaration, return the brace-delimited body
+* as a substring. Returns '' if the body cannot be located.
+*/
+function sliceClassBody(text, start) {
+	const open = text.indexOf("{", start);
+	if (open < 0) return "";
+	let depth = 0;
+	for (let i = open; i < text.length; i++) {
+		const c = text[i];
+		if (c === "{") depth++;
+		else if (c === "}") {
+			depth--;
+			if (depth === 0) return text.slice(open + 1, i);
+		}
+	}
+	return "";
+}
+/**
+* Pull field names from an interface body. Conservative: only matches simple
+* declarations of the form `name?: ...;` or `name: ...;`. Generics, methods,
+* and computed property names are skipped (they don't influence skip decisions).
+*/
+function extractInterfaceFields(text, start) {
+	const fields = /* @__PURE__ */ new Set();
+	const open = text.indexOf("{", start);
+	if (open < 0) return fields;
+	let depth = 0;
+	let close = -1;
+	for (let i = open; i < text.length; i++) {
+		const c = text[i];
+		if (c === "{") depth++;
+		else if (c === "}") {
+			depth--;
+			if (depth === 0) {
+				close = i;
+				break;
+			}
+		}
+	}
+	if (close < 0) return fields;
+	const body = text.slice(open + 1, close);
+	for (const m of body.matchAll(/^\s*(?:readonly\s+)?(?:'([^']+)'|"([^"]+)"|([a-zA-Z_$][\w$]*))\s*\??\s*:/gm)) {
+		const name = m[1] ?? m[2] ?? m[3];
+		if (name) fields.add(name);
+	}
+	return fields;
+}
+//#endregion
+//#region src/node/utils.ts
+/**
+* Compute a relative import path between two files within the generated SDK.
+*/
+function relativeImport(fromFile, toFile) {
+	const fromDir = fromFile.split("/").slice(0, -1);
+	const toFileParts = toFile.split("/");
+	const toDir = toFileParts.slice(0, -1);
+	const toFileName = toFileParts[toFileParts.length - 1];
+	let common = 0;
+	while (common < fromDir.length && common < toDir.length && fromDir[common] === toDir[common]) common++;
+	const ups = fromDir.length - common;
+	const downs = toDir.slice(common);
+	let result = [
+		...Array(ups).fill(".."),
+		...downs,
+		toFileName
+	].join("/");
+	result = result.replace(/\.ts$/, "");
+	if (!result.startsWith(".")) result = "./" + result;
+	return result;
+}
+/**
+* Render a JSDoc comment block from a description string.
+*/
+function docComment$2(description, indent = 0) {
+	const pad = " ".repeat(indent);
+	const descLines = description.split("\n");
+	if (descLines.length === 1) return [`${pad}/** ${descLines[0]} */`];
+	const lines = [`${pad}/**`];
+	for (const line of descLines) lines.push(line === "" ? `${pad} *` : `${pad} * ${line}`);
+	lines.push(`${pad} */`);
+	return lines;
+}
+/**
+* Build a map from model name -> default type args string for generic models.
+*/
+function buildGenericModelDefaults(models) {
+	const result = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		if (!model.typeParams?.length) continue;
+		const defaults = model.typeParams.map((tp) => tp.default ? mapTypeRef$7(tp.default) : "unknown");
+		result.set(model.name, `<${defaults.join(", ")}>`);
+	}
+	return result;
+}
+/**
+* Remove unused imports from generated source code.
+*/
+function pruneUnusedImports(lines) {
+	const importLines = [];
+	const bodyLines = [];
+	let inBody = false;
+	for (const line of lines) if (!inBody && (line.startsWith("import ") || line === "")) importLines.push(line);
+	else {
+		inBody = true;
+		bodyLines.push(line);
+	}
+	const body = bodyLines.join("\n");
+	const kept = [];
+	for (const line of importLines) {
+		if (line === "") {
+			kept.push(line);
+			continue;
+		}
+		const match = line.match(/\{([^}]+)\}/);
+		if (!match) {
+			kept.push(line);
+			continue;
+		}
+		const names = match[1].split(",").map((n) => n.trim()).filter(Boolean);
+		const usedNames = names.filter((name) => {
+			return new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(body);
+		});
+		if (usedNames.length === 0) continue;
+		if (usedNames.length === names.length) kept.push(line);
+		else {
+			const isTypeImport = line.startsWith("import type");
+			const fromMatch = line.match(/from\s+['"]([^'"]+)['"]/);
+			if (fromMatch) {
+				const prefix = isTypeImport ? "import type" : "import";
+				kept.push(`${prefix} { ${usedNames.join(", ")} } from '${fromMatch[1]}';`);
+			} else kept.push(line);
+		}
+	}
+	return [...kept, ...bodyLines];
+}
+/** Built-in TypeScript types that are always available. */
+const TS_BUILTINS = new Set([
+	"Record",
+	"Promise",
+	"Array",
+	"Map",
+	"Set",
+	"Date",
+	"string",
+	"number",
+	"boolean",
+	"void",
+	"null",
+	"undefined",
+	"any",
+	"never",
+	"unknown",
+	"true",
+	"false"
+]);
+/**
+* Build a comprehensive set of all known type names from the IR and baseline.
+*/
+function buildKnownTypeNames(models, ctx) {
+	const knownNames = /* @__PURE__ */ new Set();
+	for (const m of models) knownNames.add(resolveInterfaceName(m.name, ctx));
+	for (const e of ctx.spec.enums) knownNames.add(e.name);
+	if (ctx.apiSurface?.interfaces) for (const name of Object.keys(ctx.apiSurface.interfaces)) knownNames.add(name);
+	if (ctx.apiSurface?.typeAliases) for (const name of Object.keys(ctx.apiSurface.typeAliases)) knownNames.add(name);
+	if (ctx.apiSurface?.enums) for (const name of Object.keys(ctx.apiSurface.enums)) knownNames.add(name);
+	return knownNames;
+}
+/**
+* Create a service directory resolver bundle.
+*
+* When `ctx.apiSurface` is populated, the baseline `sourceFile` of an
+* existing interface wins over the IR-derived first-reference assignment.
+* This keeps generated imports pointing at the existing live SDK location
+* instead of duplicating a model into a different service directory.
+*/
+function createServiceDirResolver(models, services, ctx) {
+	const modelToService = assignModelsToEmittableServices(models, services, ctx);
+	const serviceNameMap = buildServiceNameMap(services, ctx);
+	const baselineDirByModel = harvestBaselineDirByModel(ctx);
+	for (const [modelName] of modelToService) {
+		const dir = baselineDirByModel.get(modelName);
+		if (!dir) continue;
+		const synthetic = `__baseline_dir__:${dir}`;
+		modelToService.set(modelName, synthetic);
+		if (!serviceNameMap.has(synthetic)) serviceNameMap.set(synthetic, dir);
+	}
+	const resolveDir = (irService) => {
+		if (!irService) return "common";
+		if (irService.startsWith("__baseline_dir__:")) return irService.slice(17);
+		return resolveServiceDir$1(serviceNameMap.get(irService) ?? irService);
+	};
+	return {
+		modelToService,
+		serviceNameMap,
+		resolveDir
+	};
+}
+/**
+* Map baseline interface / type-alias names to the top-level `src/<dir>/`
+* their `sourceFile` lives in. Both kinds can shadow IR model names — e.g.
+* `type Role = EnvironmentRole | OrganizationRole;` is the live SDK's
+* canonical Role definition even though the IR represents Role as a model.
+*/
+function harvestBaselineDirByModel(ctx) {
+	const baselineDirByModel = /* @__PURE__ */ new Map();
+	const recordSource = (name, info) => {
+		const sourceFile = info?.sourceFile;
+		if (!sourceFile) return;
+		const m = sourceFile.match(/^src\/([^/]+)\//);
+		if (!m) return;
+		baselineDirByModel.set(name, m[1]);
+	};
+	for (const [name, info] of Object.entries(ctx.apiSurface?.interfaces ?? {})) recordSource(name, info);
+	for (const [name, info] of Object.entries(ctx.apiSurface?.typeAliases ?? {})) if (!baselineDirByModel.has(name)) recordSource(name, info);
+	return baselineDirByModel;
+}
+/**
+* `assignModelsToServices` plus an owned-service correction pass.
+*
+* The engine's assignment is first-reference-wins: a model referenced by both
+* Organizations and AuditLogs lands in `organizations/` even when only
+* AuditLogs is owned this run. Against an existing SDK, `applyLiveSurface`
+* then drops the model file (a non-owned, non-adopted directory cannot
+* receive new paths) while the owned resource still imports
+* `../organizations/interfaces/<model>.interface` — an import that resolves
+* to nothing (TS2307).
+*
+* The correction re-homes such models to the owned service that references
+* them, so emission and import planning agree on a directory that is allowed
+* to receive files. It only fires when:
+*  1. `ownedServices` is configured and the run targets an existing SDK;
+*  2. the model has no baseline `sourceFile` (otherwise the baseline-dir
+*     override keeps imports pointing at the on-disk location);
+*  3. the model's computed interface path does not already exist on disk;
+*  4. the assigned service is neither owned itself nor sharing a directory
+*     with an owned service.
+*/
+function assignModelsToEmittableServices(models, services, ctx) {
+	const modelToService = assignModelsToServices(models, services, ctx?.modelHints);
+	if (ctx) reassignOwnedServiceDependencies(modelToService, models, services, ctx);
+	return modelToService;
+}
+function reassignOwnedServiceDependencies(modelToService, models, services, ctx) {
+	const serviceNameMap = buildServiceNameMap(services, ctx);
+	const mountGroups = groupByMount(ctx);
+	const ownedServices = (mountGroups.size > 0 ? [...mountGroups].map(([name, group]) => ({
+		name,
+		operations: group.operations
+	})) : services).filter((s) => isNodeOwnedService(ctx, s.name, serviceNameMap.get(s.name)));
+	if (ownedServices.length === 0) return;
+	if (!liveSurfaceHasExistingSdk()) return;
+	const dirOf = (irService) => irService ? resolveServiceDir$1(serviceNameMap.get(irService) ?? irService) : "common";
+	const ownedDirs = new Set(ownedServices.map((s) => dirOf(s.name)));
+	const baselineDirByModel = harvestBaselineDirByModel(ctx);
+	const modelsByName = new Map(models.map((m) => [m.name, m]));
+	for (const service of ownedServices) for (const name of collectServiceModelClosure(service, modelsByName)) {
+		if (!modelsByName.has(name)) continue;
+		if (baselineDirByModel.has(name)) continue;
+		const assigned = modelToService.get(name);
+		if (assigned && isNodeOwnedService(ctx, assigned, serviceNameMap.get(assigned))) continue;
+		const assignedDir = dirOf(assigned);
+		if (ownedDirs.has(assignedDir)) continue;
+		if (liveSurfaceHasFile(`src/${assignedDir}/interfaces/${fileName$3(name)}.interface.ts`)) continue;
+		modelToService.set(name, service.name);
+	}
+}
+/** Model names referenced by a service's operations, expanded through fields. */
+function collectServiceModelClosure(service, modelsByName) {
+	const referenced = /* @__PURE__ */ new Set();
+	const add = (ref) => {
+		if (!ref) return;
+		for (const name of collectModelRefs(ref)) referenced.add(name);
+	};
+	for (const op of service.operations) {
+		add(op.requestBody);
+		add(op.response);
+		for (const param of [
+			...op.pathParams,
+			...op.queryParams,
+			...op.headerParams,
+			...op.cookieParams ?? []
+		]) add(param.type);
+		if (op.pagination) add(op.pagination.itemType);
+	}
+	const queue = [...referenced];
+	while (queue.length > 0) {
+		const name = queue.pop();
+		const model = modelsByName.get(name);
+		if (!model) continue;
+		for (const dep of collectFieldDependencies(model).models) if (!referenced.has(dep)) {
+			referenced.add(dep);
+			queue.push(dep);
+		}
+	}
+	return referenced;
+}
+/**
+* Check if baseline interface fields appear to contain generic type parameters.
+*
+* Heuristic: strip string literals first (so `'GoogleSAML'` is not mistaken
+* for a type name), then look for any PascalCase token that isn't a known
+* type — those indicate an unbound generic parameter like `TCustomAttributes`.
+*/
+function isBaselineGeneric(fields, knownNames) {
+	for (const [, bf] of Object.entries(fields)) {
+		const typeNames = bf.type.replace(/'[^']*'/g, "").replace(/"[^"]*"/g, "").match(/\b[A-Z][a-zA-Z0-9]*\b/g);
+		if (!typeNames) continue;
+		for (const tn of typeNames) {
+			if (TS_BUILTINS.has(tn)) continue;
+			if (knownNames.has(tn)) continue;
+			return true;
+		}
+	}
+	return false;
+}
+function modelFingerprint(model) {
+	return model.fields.map((f) => `${f.name}:${JSON.stringify(f.type)}:${f.required}`).sort().join("|");
+}
+/**
+* Find structurally identical models and build a deduplication map.
+*/
+function buildDeduplicationMap(models, ctx, reachable) {
+	const dedup = /* @__PURE__ */ new Map();
+	const fingerprints = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		if (model.fields.length === 0) continue;
+		const fp = modelFingerprint(model);
+		const existing = fingerprints.get(fp);
+		if (existing) if (reachable && !reachable.has(existing) && reachable.has(model.name)) {
+			dedup.delete(existing);
+			dedup.set(existing, model.name);
+			fingerprints.set(fp, model.name);
+		} else dedup.set(model.name, existing);
+		else fingerprints.set(fp, model.name);
+	}
+	if (ctx) {
+		const byDomainName = /* @__PURE__ */ new Map();
+		for (const model of models) {
+			if (model.fields.length === 0) continue;
+			if (dedup.has(model.name)) continue;
+			const domainName = resolveInterfaceName(model.name, ctx);
+			const group = byDomainName.get(domainName);
+			if (group) group.push(model);
+			else byDomainName.set(domainName, [model]);
+		}
+		for (const [, group] of byDomainName) {
+			if (group.length < 2) continue;
+			group.sort((a, b) => {
+				if (reachable) {
+					const aReach = reachable.has(a.name) ? 0 : 1;
+					const bReach = reachable.has(b.name) ? 0 : 1;
+					if (aReach !== bReach) return aReach - bReach;
+				}
+				return b.fields.length - a.fields.length || a.name.localeCompare(b.name);
+			});
+			const canonical = group[0];
+			for (let i = 1; i < group.length; i++) dedup.set(group[i].name, canonical.name);
+		}
 	}
+	return dedup;
 }
-const CONST_OBJECT_ENUM_RE = /^\s*export\s+const\s+([A-Z][\w$]*)\s*=\s*\{([\s\S]*?)\}\s*as\s+const\s*;/gm;
-const CONST_OBJECT_MEMBER_RE = /(?:'([^']+)'|"([^"]+)"|([a-zA-Z_$][\w$]*))\s*:\s*'([^']*)'/g;
-const METHOD_KEYWORD_BLOCKLIST = new Set([
-	"if",
-	"for",
-	"while",
-	"switch",
-	"catch",
-	"return",
-	"throw",
-	"constructor"
-]);
 /**
-* Given the start index of a class declaration, return the brace-delimited body
-* as a substring. Returns '' if the body cannot be located.
+* Check whether a service's endpoints are already fully covered by existing
+* hand-written service classes.
 */
-function sliceClassBody(text, start) {
-	const open = text.indexOf("{", start);
-	if (open < 0) return "";
-	let depth = 0;
-	for (let i = open; i < text.length; i++) {
-		const c = text[i];
-		if (c === "{") depth++;
-		else if (c === "}") {
-			depth--;
-			if (depth === 0) return text.slice(open + 1, i);
+function isServiceCoveredByExisting(service, ctx) {
+	if (getMountTarget(service, ctx) !== toPascalCase(service.name)) return true;
+	const overlay = ctx.overlayLookup?.methodByOperation;
+	if (!overlay || overlay.size === 0) return false;
+	if (service.operations.length === 0) return false;
+	const baselineClasses = ctx.apiSurface?.classes;
+	if (!baselineClasses) return false;
+	const existingClassNames = new Set(Object.keys(baselineClasses));
+	return service.operations.every((op) => {
+		const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+		const match = overlay.get(httpKey);
+		if (!match) return false;
+		return existingClassNames.has(match.className);
+	});
+}
+/**
+* Check whether a fully-covered service has operations whose overlay-mapped
+* methods are missing from the baseline class.
+*/
+function hasMethodsAbsentFromBaseline(service, ctx) {
+	const baselineClasses = ctx.apiSurface?.classes;
+	if (!baselineClasses) return false;
+	const mountTarget = getMountTarget(service, ctx);
+	if (mountTarget !== toPascalCase(service.name)) {
+		const cls = baselineClasses[mountTarget];
+		if (!cls) return true;
+		for (const op of service.operations) {
+			const method = resolveMethodName$6(op, service, ctx);
+			if (!cls.methods?.[method]) return true;
 		}
+		return false;
 	}
-	return "";
+	const overlay = ctx.overlayLookup?.methodByOperation;
+	if (!overlay) return false;
+	for (const op of service.operations) {
+		const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+		const match = overlay.get(httpKey);
+		if (!match) continue;
+		const cls = baselineClasses[match.className];
+		if (!cls) continue;
+		if (!cls.methods?.[match.methodName]) return true;
+	}
+	return false;
 }
 /**
-* Pull field names from an interface body. Conservative: only matches simple
-* declarations of the form `name?: ...;` or `name: ...;`. Generics, methods,
-* and computed property names are skipped (they don't influence skip decisions).
+* Check whether an IR model has fields not present in the baseline interface.
+*
+* When the live SDK exposes the same name as a type alias (e.g.
+* `type Role = EnvironmentRole | OrganizationRole;`), treat it as already
+* fully covered — generating an interface against an existing alias would
+* collide. The alias's referenced types still get generated independently
+* and serve as the canonical implementation.
 */
-function extractInterfaceFields(text, start) {
-	const fields = /* @__PURE__ */ new Set();
-	const open = text.indexOf("{", start);
-	if (open < 0) return fields;
-	let depth = 0;
-	let close = -1;
-	for (let i = open; i < text.length; i++) {
-		const c = text[i];
-		if (c === "{") depth++;
-		else if (c === "}") {
-			depth--;
-			if (depth === 0) {
-				close = i;
-				break;
-			}
+function modelHasNewFields(model, ctx) {
+	if (!ctx.apiSurface?.interfaces && !ctx.apiSurface?.typeAliases) return true;
+	const domainName = resolveInterfaceName(model.name, ctx);
+	if (ctx.apiSurface?.typeAliases?.[domainName]) return false;
+	const baseline = ctx.apiSurface?.interfaces?.[domainName];
+	if (!baseline?.fields) return true;
+	for (const field of model.fields) {
+		const camelName = fieldName$6(field.name);
+		if (!baseline.fields[camelName]) return true;
+	}
+	return false;
+}
+/**
+* Return operations in a service that are NOT covered by existing hand-written
+* service classes.
+*/
+function uncoveredOperations(service, ctx) {
+	const overlay = ctx.overlayLookup?.methodByOperation;
+	if (!overlay || overlay.size === 0) return service.operations;
+	const baselineClasses = ctx.apiSurface?.classes;
+	if (!baselineClasses) return service.operations;
+	const existingClassNames = new Set(Object.keys(baselineClasses));
+	return service.operations.filter((op) => {
+		const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+		const match = overlay.get(httpKey);
+		if (!match) return true;
+		return !existingClassNames.has(match.className);
+	});
+}
+/**
+* Compute the set of model names reachable from non-event service operations.
+*/
+function computeNonEventReachable(services, models) {
+	const seeds = /* @__PURE__ */ new Set();
+	for (const svc of services) {
+		if (svc.name.toLowerCase() === "events") continue;
+		for (const op of svc.operations) {
+			const collectFromRef = (t) => {
+				if (!t) return;
+				if (t.kind === "model") seeds.add(t.name);
+				if (t.kind === "array") collectFromRef(t.items);
+				if (t.kind === "nullable") collectFromRef(t.inner);
+				if (t.kind === "union") t.variants.forEach(collectFromRef);
+			};
+			collectFromRef(op.response);
+			collectFromRef(op.requestBody);
+			if (op.pagination?.itemType) collectFromRef(op.pagination.itemType);
 		}
 	}
-	if (close < 0) return fields;
-	const body = text.slice(open + 1, close);
-	for (const m of body.matchAll(/^\s*(?:readonly\s+)?(?:'([^']+)'|"([^"]+)"|([a-zA-Z_$][\w$]*))\s*\??\s*:/gm)) {
-		const name = m[1] ?? m[2] ?? m[3];
-		if (name) fields.add(name);
+	const modelMap = new Map(models.map((m) => [m.name, m]));
+	const reachable = /* @__PURE__ */ new Set();
+	const queue = [...seeds];
+	while (queue.length > 0) {
+		const name = queue.pop();
+		if (reachable.has(name)) continue;
+		reachable.add(name);
+		const m = modelMap.get(name);
+		if (!m) continue;
+		for (const field of m.fields) {
+			const walk = (t) => {
+				if (t.kind === "model" && !reachable.has(t.name)) queue.push(t.name);
+				if (t.kind === "array") walk(t.items);
+				if (t.kind === "nullable") walk(t.inner);
+				if (t.kind === "union") t.variants.forEach(walk);
+			};
+			walk(field.type);
+		}
 	}
-	return fields;
+	return reachable;
 }
 //#endregion
 //#region src/node/enums.ts
@@ -3732,13 +4225,15 @@ function generateEnums$7(enums, ctx) {
 	const files = [];
 	for (const enumDef of enums) {
 		if (isInlineEnum(enumDef.name)) continue;
-		const dirName = resolveDir(enumToService.get(enumDef.name));
+		const service = enumToService.get(enumDef.name);
+		const dirName = resolveDir(service);
 		const baselineEnum = ctx.apiSurface?.enums?.[enumDef.name];
 		const baselineAlias = ctx.apiSurface?.typeAliases?.[enumDef.name];
 		const generatedPath = `src/${dirName}/interfaces/${fileName$3(enumDef.name)}.interface.ts`;
 		const baselineSourceFile = baselineEnum?.sourceFile ?? baselineAlias?.sourceFile ?? liveSurfaceInterfacePath(enumDef.name);
 		if (dirName === "common" && !baselineSourceFile && (ctx.outputDir || ctx.targetDir || ctx.apiSurface)) continue;
-		if (baselineSourceFile && baselineSourceFile !== generatedPath) continue;
+		const isOwnedEnumService = isNodeOwnedService(ctx, service, service ? serviceNameMap.get(service) : void 0);
+		if (baselineSourceFile && baselineSourceFile !== generatedPath && !isOwnedEnumService) continue;
 		const lines = [];
 		let hasNewValues = false;
 		if (baselineEnum?.members) {
@@ -3824,7 +4319,7 @@ function assignEnumsToServices(enums, services, models = [], ctx) {
 		for (const name of refs) if (enumNames.has(name) && !enumToService.has(name)) enumToService.set(name, service.name);
 	}
 	if (models.length > 0) {
-		const modelToService = assignModelsToServices(models, services, ctx?.modelHints);
+		const modelToService = assignModelsToEmittableServices(models, services, ctx);
 		for (const model of models) {
 			const service = modelToService.get(model.name);
 			if (!service) continue;
@@ -3834,25 +4329,6 @@ function assignEnumsToServices(enums, services, models = [], ctx) {
 	return enumToService;
 }
 //#endregion
-//#region src/node/options.ts
-function nodeOptions(ctx) {
-	return ctx.emitterOptions ?? {};
-}
-function normalizeServiceName(name) {
-	return name.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
-}
-function ownedLookupNames(name) {
-	const names = [name];
-	if (name.startsWith("__baseline_dir__:")) names.push(name.slice(17));
-	return names;
-}
-function isNodeOwnedService(ctx, ...names) {
-	const configured = nodeOptions(ctx).ownedServices ?? [];
-	if (configured.length === 0) return false;
-	const owned = new Set(configured.map(normalizeServiceName));
-	return names.some((name) => name !== void 0 ? ownedLookupNames(name).some((candidate) => owned.has(normalizeServiceName(candidate))) : false);
-}
-//#endregion
 //#region src/node/field-plan.ts
 /**
 * Decide whether a `deserialize${X}` / `serialize${X}` helper will be
@@ -4718,7 +5194,7 @@ function ignoredResourceMethodNames(ctx, resourcePath) {
 	}
 	const methods = /* @__PURE__ */ new Set();
 	for (const block of content.matchAll(/@oagen-ignore-start[\s\S]*?@oagen-ignore-end/g)) for (const line of block[0].split("\n")) {
-		const match = line.match(/^\s{2}(?:(?:public|private|protected)\s+)?(?:async\s+)?([A-Za-z_$][\w$]*)\s*\(/);
+		const match = line.match(/^\s{2}(?:(?:public|private|protected)\s+)?(?:async\s+)?([A-Za-z_$][\w$]*)\s*[<(]/);
 		if (match) methods.add(match[1]);
 	}
 	return methods;
@@ -4780,6 +5256,17 @@ function optionsObjectInfo(service, method, op, plan, ctx, baselineMethod, resol
 function renderOptionsParam(param) {
 	return `options${param.optional ? "?" : ""}: ${param.type}`;
 }
+/**
+* Whether a baseline-derived type reference is a plain TypeScript identifier
+* that can appear in a named import. Baseline (live-SDK) method params can
+* carry inline object-literal TYPES (e.g. `{ intent: GenerateLinkIntent; ... }`);
+* treating that literal text as a type NAME would slugify it into a filename
+* and emit a named import of a brace-expression — both invalid. Literal types
+* are kept inline in the emitted signature instead and never imported.
+*/
+function isValidTypeIdentifier(name) {
+	return /^[A-Za-z_$][\w$]*$/.test(name);
+}
 function autoPaginatableItemType$1(returnType) {
 	return returnType?.match(/\b(?:AutoPaginatable|List)<\s*([A-Za-z_$][\w$]*)/)?.[1];
 }
@@ -5108,6 +5595,7 @@ function generateResourceClass(service, ctx) {
 	if (hasIdempotentPost || hasCustomEncoding) lines.push("import type { PostOptions } from '../common/interfaces/post-options.interface';");
 	const importedTypeNames = /* @__PURE__ */ new Set();
 	for (const optionType of optionObjectTypes) {
+		if (!isValidTypeIdentifier(optionType)) continue;
 		if (importedTypeNames.has(optionType)) continue;
 		importedTypeNames.add(optionType);
 		const sourceFile = baselineTypeSourceFile(ctx, optionType);
@@ -5546,7 +6034,8 @@ function renderOptionsObjectMethod(lines, op, plan, method, service, ctx, modelM
 		if (!itemType) return false;
 		const wireType = wireInterfaceName(itemType);
 		const needsWireSerializer = op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name)).some((p) => fieldName$6(p.name) !== wireFieldName(p.name));
-		const paginationType = needsWireSerializer ? "PaginationOptions" : optionParam.type;
+		const restOptionsType = pathBindings.length > 0 ? `Omit<${optionParam.type}, ${pathBindings.map((b) => `'${b}'`).join(" | ")}>` : optionParam.type;
+		const paginationType = needsWireSerializer ? "PaginationOptions" : restOptionsType;
 		const returnType = needsWireSerializer ? `Promise<AutoPaginatable<${itemType}, ${paginationType}>>` : preferredBaselineReturnType(ctx, baselineMethod?.returnType) ?? `Promise<AutoPaginatable<${itemType}, ${paginationType}>>`;
 		const listOptionsExpr = needsWireSerializer ? `options ? serialize${optionParam.type}(options) : undefined` : "paginationOptions";
 		lines.push(`  async ${method}(${renderOptionsParam(optionParam)}): ${returnType} {`);
@@ -5641,7 +6130,8 @@ function renderOptionsObjectMethod(lines, op, plan, method, service, ctx, modelM
 		const finalReturnExpr = override?.returnDataProperty ? `${returnExpr}.${override.returnDataProperty}` : returnExpr;
 		lines.push(`  async ${method}(${renderOptionsParam(optionParam)}): ${methodReturnType} {`);
 		renderOptionsObjectDestructure(lines, pathBindings);
-		lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireType}>(${pathStr}${queryOptionsArg});`);
+		const emptyBodyArg = httpMethodNeedsBody(op.httpMethod) ? ", {}" : "";
+		lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireType}>(${pathStr}${emptyBodyArg}${queryOptionsArg});`);
 		if (override?.returnExpression) {
 			lines.push(`    const result = ${returnExpr};`);
 			lines.push(`    return ${override.returnExpression};`);
@@ -6509,10 +6999,11 @@ function generateModels$7(models, ctx, shared) {
 					if (unresolvableNames.has(name)) continue;
 					const irEnumName = resolvedEnumNames.get(name);
 					if (irEnumName && !deps.enums.has(irEnumName)) {
-						const eDir = resolveDir(enumToService.get(irEnumName));
+						const eService = enumToService.get(irEnumName);
+						const eDir = resolveDir(eService);
 						const bEnum = ctx.apiSurface?.enums?.[irEnumName];
 						const bAlias = ctx.apiSurface?.typeAliases?.[irEnumName];
-						const bSrc = bEnum?.sourceFile ?? bAlias?.sourceFile;
+						const bSrc = isNodeOwnedService(ctx, eService) ? void 0 : bEnum?.sourceFile ?? bAlias?.sourceFile;
 						const gPath = `src/${eDir}/interfaces/${fileName$3(irEnumName)}.interface.ts`;
 						const cPath = `src/${dirName}/interfaces/${fileName$3(model.name)}.interface.ts`;
 						if (bSrc === cPath) {
@@ -6556,8 +7047,9 @@ function generateModels$7(models, ctx, shared) {
 			if (isInlineEnum(dep)) continue;
 			const baselineEnum = ctx.apiSurface?.enums?.[dep];
 			const baselineAlias = ctx.apiSurface?.typeAliases?.[dep];
-			const baselineSrc = baselineEnum?.sourceFile ?? baselineAlias?.sourceFile;
-			const depDir = resolveDir(enumToService.get(dep));
+			const depService = enumToService.get(dep);
+			const baselineSrc = isNodeOwnedService(ctx, depService) ? void 0 : baselineEnum?.sourceFile ?? baselineAlias?.sourceFile ?? liveSurfaceInterfacePath(dep);
+			const depDir = resolveDir(depService);
 			const generatedPath = `src/${depDir}/interfaces/${fileName$3(dep)}.interface.ts`;
 			const currentFilePath = `src/${dirName}/interfaces/${fileName$3(model.name)}.interface.ts`;
 			if (baselineSrc === currentFilePath) {
@@ -6648,6 +7140,7 @@ function generateModels$7(models, ctx, shared) {
 						if (generatedNames.has(name)) continue;
 						const sepPath = `src/${dirName}/interfaces/${fileName$3(name)}.interface.ts`;
 						if (sepPath !== filePath && files.some((f) => f.path === sepPath)) continue;
+						if (!isInlineEnum(name) && ctx.spec.enums.some((e) => e.name === name) && isNodeOwnedService(ctx, enumToService.get(name))) continue;
 						inlineNames.add(name);
 					}
 				};
@@ -7020,6 +7513,7 @@ function baselineTypeResolvable(typeStr, importableNames) {
 	return true;
 }
 function baselineFieldCompatible(baselineField, irField) {
+	if (baselineTypeIsDegradedAny(baselineField.type) && hasNamedTypeReference(irField.type)) return false;
 	const irNullable = irField.type.kind === "nullable";
 	const baselineHasNull = baselineField.type.includes("null");
 	if (irNullable && !baselineHasNull && irField.required) return false;
@@ -7027,6 +7521,21 @@ function baselineFieldCompatible(baselineField, irField) {
 	if (baselineField.type === "Record<string, unknown>" && hasSpecificIRType(irField.type)) return false;
 	return true;
 }
+/** `any`, `any[]`, `any | null`, … — shapes api-surface extraction degrades to. */
+function baselineTypeIsDegradedAny(typeStr) {
+	return typeStr.replace(/\s*\|\s*(?:null|undefined)\b/g, "").replace(/\[\]$/, "").trim() === "any";
+}
+/** Does the IR type reference a named model/enum anywhere (incl. arrays)? */
+function hasNamedTypeReference(ref) {
+	switch (ref.kind) {
+		case "model":
+		case "enum": return true;
+		case "array": return hasNamedTypeReference(ref.items);
+		case "nullable": return hasNamedTypeReference(ref.inner);
+		case "union": return ref.variants.some((v) => hasNamedTypeReference(v));
+		default: return false;
+	}
+}
 function hasSpecificIRType(ref) {
 	switch (ref.kind) {
 		case "model":
@@ -8841,6 +9350,22 @@ function getEmittedPaths(ctx) {
 	}
 	return set;
 }
+/**
+* Every `GeneratedFile` the node emitter has produced so far in this ctx,
+* keyed by path. All emitter hooks share one ctx (and the engine only reads
+* file contents after the last hook returns), so the final hook can run a
+* whole-run pass over files emitted by earlier hooks — see
+* `enforceEmittedImportInvariant`.
+*/
+const emittedFilesCache = /* @__PURE__ */ new WeakMap();
+function getEmittedFiles(ctx) {
+	let map = emittedFilesCache.get(ctx);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		emittedFilesCache.set(ctx, map);
+	}
+	return map;
+}
 function getSurface(ctx) {
 	let surface = surfaceCache.get(ctx);
 	if (surface) return surface;
@@ -8861,6 +9386,9 @@ function getSurface(ctx) {
 	if (ifaces) for (const name of Object.keys(ifaces)) allInterfaces.add(name);
 	for (const name of surface.interfaces.keys()) allInterfaces.add(name);
 	setBaselineInterfaceNames(allInterfaces);
+	const declaredNames = new Set(allInterfaces);
+	for (const name of Object.keys(ctx.apiSurface?.typeAliases ?? {})) declaredNames.add(name);
+	setBaselineDeclaredNames(declaredNames);
 	setInlineEnumUnions(/* @__PURE__ */ new Map());
 	setAdoptedModelNames(computeAdoptedModelNames(ctx, surface));
 	const renamed = /* @__PURE__ */ new Set();
@@ -9026,6 +9554,15 @@ function isOwnedPath(relPath, policy) {
 	const dir = topLevelDir(relPath);
 	return dir !== void 0 && policy.ownedServiceDirs.has(dir);
 }
+/** Read the current on-disk content of a live-surface file, if present. */
+function readExistingSurfaceFile(surface, relPath) {
+	if (!surface.rootDir) return null;
+	try {
+		return fs$1.readFileSync(path$1.join(surface.rootDir, relPath), "utf8");
+	} catch {
+		return null;
+	}
+}
 function extractRelativeImportPaths(content, fromPath) {
 	const dir = path$1.dirname(fromPath);
 	const paths = [];
@@ -9072,6 +9609,15 @@ function applyLiveSurface(files, ctx, surface) {
 			if (isManagedDir && !policy.regenerateOwnedTests) continue;
 		}
 		if (surface.autogenFiles.has(f.path) || ownedPath) {
+			const dir = topLevelDir(f.path);
+			const isAdoptedDirPath = dir !== void 0 && policy.adoptedServiceDirs.has(dir);
+			if (!ownedPath && !isAdoptedDirPath && surface.autogenFiles.has(f.path)) {
+				const existingText = readExistingSurfaceFile(surface, f.path);
+				if (existingText !== null) {
+					const merged = mergeGeneratedClassMethodsIntoExisting(existingText, f.content);
+					if (merged !== null) f.content = merged;
+				}
+			}
 			f.overwriteExisting = true;
 			f.skipIfExists = false;
 		}
@@ -9079,10 +9625,136 @@ function applyLiveSurface(files, ctx, surface) {
 		out.push(f);
 	}
 	const emitted = getEmittedPaths(ctx);
-	for (const f of out) emitted.add(f.path);
+	const emittedFiles = getEmittedFiles(ctx);
+	for (const f of out) {
+		emitted.add(f.path);
+		emittedFiles.set(f.path, f);
+	}
 	return out;
 }
 /**
+* Matches single-line `import`/`export … from './relative'` statements — the
+* only form the node emitter produces. Captures: keyword, optional ` type`
+* modifier, the binding clause (`* [as ns]` or `{ … }`), and the module path.
+*/
+const RELATIVE_FROM_STMT_RE = /^(import|export)(\s+type)?\s+(\*(?:\s+as\s+[\w$]+)?|\{[^}]*\})\s+from\s+['"](\.[^'"]+)['"];?\s*$/;
+const EXPORTED_DECL_RE = /^export\s+(?:declare\s+)?(?:abstract\s+)?(?:async\s+)?(?:interface|class|enum|function|const|let|var|type)\s+([A-Za-z_$][\w$]*)/gm;
+const EXPORTED_CLAUSE_RE = /^export\s+(?:type\s+)?\{([^}]*)\}/gm;
+/** Repo-relative paths a relative import specifier may resolve to. */
+function importTargetCandidates(fromPath, spec) {
+	const base = path$1.posix.normalize(path$1.posix.join(path$1.posix.dirname(fromPath), spec));
+	return [
+		base,
+		`${base}.ts`,
+		`${base}/index.ts`
+	];
+}
+/** Index exported symbol → file path across this run's emitted contents. */
+function indexEmittedExports(files) {
+	const index = /* @__PURE__ */ new Map();
+	for (const f of files) {
+		if (!f.path.endsWith(".ts") || !f.content) continue;
+		for (const m of f.content.matchAll(EXPORTED_DECL_RE)) if (!index.has(m[1])) index.set(m[1], f.path);
+		for (const m of f.content.matchAll(EXPORTED_CLAUSE_RE)) for (const raw of m[1].split(",")) {
+			const entry = raw.trim();
+			if (!entry) continue;
+			const parts = entry.split(/\s+as\s+/);
+			const exported = (parts[1] ?? parts[0]).replace(/^type\s+/, "").trim();
+			if (exported && !index.has(exported)) index.set(exported, f.path);
+		}
+	}
+	return index;
+}
+/**
+* Enforce: every relative import/re-export path in emitted code resolves to
+* either (i) a file emitted in the same run, or (ii) a file that already
+* exists on disk in the target SDK.
+*
+* Violations observed in real generations (all TS2307 in otherwise-valid
+* output): serializer imports pointing at canonical paths while the function
+* lives in a legacy hand serializer under a different filename; barrels
+* re-exporting a module-local enum file whose declaration lives under
+* `src/common/interfaces`; barrels exporting interface files that no run
+* emits at all.
+*
+* Repair strategy, per statement whose target is neither emitted nor on
+* disk:
+*  1. Locate each imported symbol (this run's emissions first, then the
+*     live-surface declaration maps) and rewrite the path to where the
+*     symbol actually lives — splitting into one statement per location
+*     when symbols are spread across files.
+*  2. `export * from` / namespace imports carry no symbol list, so derive
+*     the expected symbol from the file stem (`foo-bar.interface` →
+*     `FooBar`, `foo.serializer` → `deserializeFoo`/`serializeFoo`).
+*  3. When a symbol exists nowhere, drop the statement and warn — a missing
+*     named export fails loudly at the usage site instead of as a phantom
+*     module, and a barrel line for a never-emitted file is pure noise.
+*
+* Mutates `f.content` in place and returns the warnings issued.
+*/
+function enforceEmittedImportInvariant(files, emittedPaths, surface) {
+	const fileList = [...files];
+	const emittedSymbols = indexEmittedExports(fileList);
+	const warnings = [];
+	const targetExists = (fromPath, spec) => importTargetCandidates(fromPath, spec).some((p) => emittedPaths.has(p) || surface.files.has(p));
+	const locateSymbol = (name) => emittedSymbols.get(name) ?? surface.functions.get(name) ?? surface.interfaces.get(name)?.filePath ?? surface.classes.get(name)?.filePath;
+	for (const f of fileList) {
+		if (!f.path.endsWith(".ts") || !f.content) continue;
+		let changed = false;
+		const outLines = [];
+		for (const line of f.content.split("\n")) {
+			const m = line.match(RELATIVE_FROM_STMT_RE);
+			if (!m || targetExists(f.path, m[4])) {
+				outLines.push(line);
+				continue;
+			}
+			const [, keyword, typeMod, clause, spec] = m;
+			const repaired = repairUnresolvableStatement(f.path, keyword, typeMod ?? "", clause, spec, locateSymbol);
+			changed = true;
+			outLines.push(...repaired.lines);
+			if (repaired.warning) warnings.push(repaired.warning);
+		}
+		if (changed) f.content = outLines.join("\n");
+	}
+	for (const w of warnings) console.warn(w);
+	return warnings;
+}
+function repairUnresolvableStatement(fromPath, keyword, typeMod, clause, spec, locateSymbol) {
+	if (clause.startsWith("{")) {
+		const entries = clause.slice(1, -1).split(",").map((e) => e.trim()).filter(Boolean);
+		const byLocation = /* @__PURE__ */ new Map();
+		const missing = [];
+		for (const entry of entries) {
+			const source = entry.split(/\s+as\s+/)[0].replace(/^type\s+/, "").trim();
+			const location = locateSymbol(source);
+			if (!location) {
+				missing.push(source);
+				continue;
+			}
+			if (location === fromPath) continue;
+			const group = byLocation.get(location);
+			if (group) group.push(entry);
+			else byLocation.set(location, [entry]);
+		}
+		return {
+			lines: [...byLocation].map(([location, group]) => `${keyword}${typeMod} { ${group.join(", ")} } from '${relativeImport(fromPath, location)}';`),
+			warning: missing.length > 0 ? `oagen(node): dropped unresolvable symbol(s) from ${keyword} in ${fromPath}: '${spec}' — found neither in this run's output nor in the target SDK: ${missing.join(", ")}` : void 0
+		};
+	}
+	const stem = spec.split("/").pop() ?? "";
+	let location;
+	if (stem.endsWith(".interface")) location = locateSymbol(toPascalCase(stem.slice(0, -10)));
+	else if (stem.endsWith(".serializer")) {
+		const base = toPascalCase(stem.slice(0, -11));
+		location = locateSymbol(`deserialize${base}`) ?? locateSymbol(`serialize${base}`);
+	}
+	if (location && location !== fromPath) return { lines: [`${keyword}${typeMod} ${clause} from '${relativeImport(fromPath, location)}';`] };
+	return {
+		lines: [],
+		warning: `oagen(node): dropped unresolvable ${keyword} in ${fromPath}: '${spec}' — module is neither emitted this run nor present in the target SDK`
+	};
+}
+/**
 * Re-declare prior-manifest paths that we did not emit this run so manifest
 * pruning can tell "intentionally removed" from "untouched but still managed."
 *
@@ -9193,7 +9865,9 @@ const nodeEmitter = {
 	generateTests(spec, ctx) {
 		const nodeCtx = withNodeOperationOverrides(ctx);
 		const surface = getSurface(nodeCtx);
-		return [...nodeOptions(nodeCtx).regenerateOwnedTests ? applyLiveSurface(generateTests$7(spec, nodeCtx), nodeCtx, surface) : [], ...carryForwardManagedFiles(nodeCtx, surface)];
+		const result = [...nodeOptions(nodeCtx).regenerateOwnedTests ? applyLiveSurface(generateTests$7(spec, nodeCtx), nodeCtx, surface) : [], ...carryForwardManagedFiles(nodeCtx, surface)];
+		if (managedPathsFor(nodeCtx, surface).size > 0) enforceEmittedImportInvariant(getEmittedFiles(nodeCtx).values(), getEmittedPaths(nodeCtx), surface);
+		return result;
 	},
 	buildOperationsMap() {
 		return {};
@@ -28470,4 +29144,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-DuB1UozS.mjs.map
+//# sourceMappingURL=plugin-CpO8rePT.mjs.map