@workos/oagen-emitters 0.12.1 → 0.12.2

package/src/node/models.ts

@@ -1,8 +1,16 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import type { Model, Field, TypeRef, EmitterContext, GeneratedFile } from '@workos/oagen';
-import { mapTypeRef, mapWireTypeRef } from './type-map.js';
-import { fieldName, wireFieldName, fileName, resolveInterfaceName, wireInterfaceName } from './naming.js';
+import type { Model, Field, TypeRef, EmitterContext, GeneratedFile, Operation, Service } from '@workos/oagen';
+import { planOperation } from '@workos/oagen';
+import { mapTypeRef, mapWireTypeRef, isInlineEnum } from './type-map.js';
+import {
+  fieldName,
+  wireFieldName,
+  fileName,
+  resolveInterfaceName,
+  wireInterfaceName,
+  resolveMethodName,
+} from './naming.js';
 import {
   collectFieldDependencies,
   docComment,
@@ -18,6 +26,8 @@ import {
   relativeImport,
   modelHasNewFields,
   computeNonEventReachable,
+  isServiceCoveredByExisting,
+  hasMethodsAbsentFromBaseline,
 } from './utils.js';
 import { assignEnumsToServices } from './enums.js';
 import {
@@ -28,18 +38,39 @@ import {
   emitSerializerBody,
   hasDateTimeConversion,
 } from './field-plan.js';
+import { liveSurfaceHasExistingSdk, liveSurfaceHasManagedFile } from './live-surface.js';
+import { isNodeOwnedService } from './options.js';
+import { unwrapListModel } from './fixtures.js';
+import { groupByMount, buildResolvedLookup, lookupResolved } from '../shared/resolved-ops.js';
+import { resolveWrapperParams } from '../shared/wrapper-utils.js';
+import { collectWrapperResponseModels } from './wrappers.js';
+import { resolveResourceClassName } from './resources.js';
+
+// ---------------------------------------------------------------------------
+// Shared context
+// ---------------------------------------------------------------------------
+
+interface SharedModelContext {
+  modelToService: Map<string, string>;
+  resolveDir: (irService: string | undefined) => string;
+  dedup: Map<string, string>;
+  genericDefaults: Map<string, string>;
+}
+
+interface GeneratedResourceModelUsage {
+  interfaceRoots: Set<string>;
+  serializerRoots: Set<string>;
+}
+
+function buildSharedContext(models: Model[], ctx: EmitterContext): SharedModelContext {
+  const { modelToService, resolveDir } = createServiceDirResolver(models, ctx.spec.services, ctx);
+  const genericDefaults = buildGenericModelDefaults(ctx.spec.models);
+  enrichGenericDefaultsFromBaseline(genericDefaults, models, ctx, resolveDir, modelToService);
+  const nonEventReachable = computeNonEventReachable(ctx.spec.services, models);
+  const dedup = buildDeduplicationMap(models, ctx, nonEventReachable);
+  return { modelToService, resolveDir, dedup, genericDefaults };
+}
 
-/**
- * Detect baseline interfaces that are generic (have type parameters) even though
- * the IR model has no typeParams (OpenAPI doesn't support generics).
- *
- * Heuristic: if any field type in the baseline interface contains a PascalCase
- * name that isn't a known model, enum, or builtin, it's likely a type parameter
- * (e.g., `CustomAttributesType`), indicating the interface is generic.
- *
- * When detected, adds a default generic type arg so references like `Profile`
- * become `Profile<Record<string, unknown>>`.
- */
 function enrichGenericDefaultsFromBaseline(
   genericDefaults: Map<string, string>,
   models: Model[],
@@ -51,14 +82,11 @@ function enrichGenericDefaultsFromBaseline(
   const knownNames = buildKnownTypeNames(models, ctx);
 
   for (const model of models) {
-    if (genericDefaults.has(model.name)) continue; // IR already handles it
+    if (genericDefaults.has(model.name)) continue;
     const domainName = resolveInterfaceName(model.name, ctx);
     const baseline = ctx.apiSurface.interfaces[domainName];
     if (!baseline?.fields) continue;
 
-    // Only enrich generic defaults for models whose baseline file path matches
-    // the generated path.  If the file is generated in a new directory, it
-    // won't have generics, so references to it don't need type args.
     const generatedPath = `src/${resolveDir(modelToService.get(model.name))}/interfaces/${fileName(model.name)}.interface.ts`;
     const baselineSourceFile = (baseline as any).sourceFile as string | undefined;
     if (baselineSourceFile && baselineSourceFile !== generatedPath) continue;
@@ -69,6 +97,53 @@ function enrichGenericDefaultsFromBaseline(
   }
 }
 
+function projectModelToManagedSurface(model: Model, shared: SharedModelContext, ctx: EmitterContext): Model {
+  if (!ctx.outputDir && !ctx.targetDir) return model;
+  if (!liveSurfaceHasExistingSdk()) return model;
+  const fields = model.fields.filter((field) => isSupportedFieldType(field.type, model.name, shared, ctx));
+  return fields.length === model.fields.length ? model : { ...model, fields };
+}
+
+function isSupportedFieldType(
+  ref: TypeRef,
+  ownerModelName: string,
+  shared: SharedModelContext,
+  ctx: EmitterContext,
+): boolean {
+  switch (ref.kind) {
+    case 'primitive':
+    case 'literal':
+    case 'map':
+      return true;
+    case 'model': {
+      if (ref.name === ownerModelName) return true;
+      const resolvedName = resolveInterfaceName(ref.name, ctx);
+      if (ctx.apiSurface?.interfaces?.[resolvedName] || ctx.apiSurface?.typeAliases?.[resolvedName]) return true;
+      const relPath = `src/${shared.resolveDir(shared.modelToService.get(ref.name))}/interfaces/${fileName(ref.name)}.interface.ts`;
+      return liveSurfaceHasManagedFile(relPath);
+    }
+    case 'enum': {
+      if (ctx.apiSurface?.enums?.[ref.name] || ctx.apiSurface?.typeAliases?.[ref.name]) return true;
+      const enumService = assignEnumsToServices(ctx.spec.enums, ctx.spec.services, ctx.spec.models, ctx).get(ref.name);
+      if (enumService) return true;
+      const relPath = `src/${shared.resolveDir(enumService)}/interfaces/${fileName(ref.name)}.interface.ts`;
+      return liveSurfaceHasManagedFile(relPath);
+    }
+    case 'array':
+      return isSupportedFieldType(ref.items, ownerModelName, shared, ctx);
+    case 'nullable':
+      return isSupportedFieldType(ref.inner, ownerModelName, shared, ctx);
+    case 'union':
+      return ref.variants.every((variant) => isSupportedFieldType(variant, ownerModelName, shared, ctx));
+    default:
+      return true;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Interface generation
+// ---------------------------------------------------------------------------
+
 export function generateModels(models: Model[], ctx: EmitterContext, shared?: SharedModelContext): GeneratedFile[] {
   if (models.length === 0) return [];
 
@@ -83,18 +158,22 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
   const wireTypeRefOpts = { genericDefaults };
   const files: GeneratedFile[] = [];
   const dedup = sharedDedup;
+  const projectedModels = models.map((model) =>
+    projectModelToManagedSurface(model, { modelToService, resolveDir, dedup, genericDefaults }, ctx),
+  );
+  const projectedByName = new Map(projectedModels.map((model) => [model.name, model]));
+  const resourceUsage = buildGeneratedResourceModelUsage(models, ctx);
+  const interfaceEligibleModels = resourceUsage
+    ? expandModelRoots(resourceUsage.interfaceRoots, projectedByName)
+    : undefined;
 
-  // Only generate files for models reachable from non-event service operations.
-  // Event operations (listEvents) pull in hundreds of webhook payload models
-  // that the existing SDK handles via hand-written event types. Skip those.
   const reachableModels = computeNonEventReachable(ctx.spec.services, models);
 
-  // Force-generate models that are dependencies of generated models but whose
-  // baseline definitions are inline in another file. The merger will replace the
-  // parent symbol, losing the inline definition, so a separate file is needed.
   const forceGenerate = new Set<string>();
-  for (const model of models) {
+  for (const originalModel of models) {
+    const model = projectedByName.get(originalModel.name) ?? originalModel;
     if (!reachableModels.has(model.name)) continue;
+    if (interfaceEligibleModels && !interfaceEligibleModels.has(model.name)) continue;
     if (!modelHasNewFields(model, ctx)) continue;
     const service = modelToService.get(model.name);
     const dirName = resolveDir(service);
@@ -106,35 +185,24 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
       const depBaseline = ctx.apiSurface?.interfaces?.[depName];
       const depSrc = (depBaseline as any)?.sourceFile as string | undefined;
       if (depSrc === parentPath) {
-        // The dependency's baseline is inline in the parent's file — force-generate
         forceGenerate.add(dep);
       }
     }
   }
 
-  for (const model of models) {
+  for (const originalModel of models) {
+    const model = projectedByName.get(originalModel.name) ?? originalModel;
     if (!reachableModels.has(model.name)) continue;
-
-    // Fix #4: Skip per-domain ListMetadata interfaces — the shared ListMetadata type covers these
+    if (interfaceEligibleModels && !interfaceEligibleModels.has(model.name)) continue;
     if (isListMetadataModel(model)) continue;
-
-    // Fix #6: Skip per-domain list wrapper interfaces — the shared List<T>/ListResponse<T> covers these
     if (isListWrapperModel(model)) continue;
+    const service = modelToService.get(model.name);
+    const isOwnedModel = isNodeOwnedService(ctx, service);
+    if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerate.has(model.name)) continue;
 
-    // Skip models that are unchanged from baseline (no new fields),
-    // unless they're force-generated (inline dependency of a regenerated model).
-    if (!modelHasNewFields(model, ctx) && !forceGenerate.has(model.name)) continue;
-
-    // Deduplication: if this model is structurally identical to a canonical model,
-    // emit a type alias instead of a full interface.
     const canonicalName = dedup.get(model.name);
-    if (canonicalName) {
-      const service = modelToService.get(model.name);
+    if (canonicalName && !isOwnedModel) {
       const dirName = resolveDir(service);
-
-      // Skip typeAlias resolution for dedup models.  The canonical file may
-      // still export its raw name, so the import names must match the raw
-      // exports, not resolved aliases.
       const skipTA = { skipTypeAlias: true };
       const domainName = resolveInterfaceName(model.name, ctx, skipTA);
       const responseName = wireInterfaceName(domainName);
@@ -144,9 +212,6 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
       const canonService = modelToService.get(canonicalName);
       const canonDir = resolveDir(canonService);
 
-      // After noise suffix stripping (e.g., "OrganizationDto" → "Organization"),
-      // the alias and canonical may resolve to the same file path or the same
-      // type names.  Skip — the canonical file already provides the types.
       const aliasPath = `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`;
       const canonPath = `src/${canonDir}/interfaces/${fileName(canonicalName)}.interface.ts`;
       if (aliasPath === canonPath) continue;
@@ -155,12 +220,37 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
         canonDir === dirName
           ? `./${fileName(canonicalName)}.interface`
           : `../../${canonDir}/interfaces/${fileName(canonicalName)}.interface`;
-      const aliasLines = [
-        `import type { ${canonDomainName}, ${canonResponseName} } from '${canonRelPath}';`,
-        '',
-        `export type ${domainName} = ${canonDomainName};`,
-        `export type ${responseName} = ${canonResponseName};`,
-      ];
+
+      // Single-form aliases: when the resolver collapses the IR model and
+      // its wire form to the same baseline name (or the alias's own
+      // domain/wire shapes coincide), emit only the unique exports. The
+      // earlier code unconditionally emitted both `export type X = Y;` and
+      // `export type X' = Y';` lines, producing TS2300 duplicate-identifier
+      // errors when X === X' and Y === Y'.
+      const aliasExports: string[] = [];
+      const importNeeded = new Set<string>();
+      const declared = new Set<string>();
+      const pushAlias = (lhs: string, rhs: string): void => {
+        if (lhs === rhs) return;
+        if (declared.has(lhs)) return;
+        declared.add(lhs);
+        aliasExports.push(`export type ${lhs} = ${rhs};`);
+        importNeeded.add(rhs);
+      };
+      pushAlias(domainName, canonDomainName);
+      pushAlias(responseName, canonResponseName);
+      if (aliasExports.length === 0) continue;
+
+      // Only import names that are referenced on the RHS of an alias AND
+      // aren't declared locally (which would shadow / collide with the
+      // import).
+      const importSymbols = [...importNeeded]
+        .filter((n) => !declared.has(n))
+        .sort()
+        .join(', ');
+      const aliasLines = importSymbols
+        ? [`import type { ${importSymbols} } from '${canonRelPath}';`, '', ...aliasExports]
+        : [...aliasExports];
       files.push({
         path: aliasPath,
         content: aliasLines.join('\n'),
@@ -169,19 +259,13 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
       continue;
     }
 
-    const service = modelToService.get(model.name);
     const dirName = resolveDir(service);
-    // If this model is a dedup canonical (other models alias to it), skip
-    // typeAlias resolution so the file exports the raw name.  Dedup aliases
-    // import using the raw name to stay consistent with preserved files.
     const isDedupCanonical = [...dedup.values()].includes(model.name);
     const domainName = resolveInterfaceName(model.name, ctx, isDedupCanonical ? { skipTypeAlias: true } : undefined);
     const responseName = wireInterfaceName(domainName);
     const deps = collectFieldDependencies(model);
     const lines: string[] = [];
 
-    // Exclude the current model from generic defaults to avoid self-referencing
-    // (e.g., Profile's own fields should use TCustom, not Profile<Record<...>>)
     let modelTypeRefOpts = typeRefOpts;
     let modelWireTypeRefOpts = wireTypeRefOpts;
     if (genericDefaults.has(model.name)) {
@@ -191,12 +275,9 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
       modelWireTypeRefOpts = { genericDefaults: filteredDefaults };
     }
 
-    // Baseline interface data (for compat field type matching)
     const baselineDomain = ctx.apiSurface?.interfaces?.[domainName];
     const baselineResponse = ctx.apiSurface?.interfaces?.[responseName];
 
-    // Build set of importable type names for this file:
-    // the model itself, its Response variant, all IR-dep model names + Response variants, and all IR-dep enum names
     const importableNames = new Set<string>();
     importableNames.add(domainName);
     importableNames.add(responseName);
@@ -209,16 +290,10 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
       importableNames.add(dep);
     }
 
-    // Pre-pass: discover baseline type names that aren't directly importable.
-    // For each unresolvable name we either:
-    //   1. Import the real type from another service (if it exists as an enum/model there)
-    //   2. Create a local type alias from a suffix match
-    //   3. Mark as unresolvable — the field will fall back to the IR-generated type
-    const typeDecls = new Map<string, string>(); // aliasName → type expression
-    const crossServiceImports = new Map<string, { name: string; relPath: string }>(); // extra imports
-    const unresolvableNames = new Set<string>(); // names that can't be resolved — forces IR fallback
-    const enumToService = assignEnumsToServices(ctx.spec.enums, ctx.spec.services);
-    // Build a lookup: resolved enum name → IR enum name
+    const typeDecls = new Map<string, string>();
+    const crossServiceImports = new Map<string, { name: string; relPath: string }>();
+    const unresolvableNames = new Set<string>();
+    const enumToService = assignEnumsToServices(ctx.spec.enums, ctx.spec.services, ctx.spec.models, ctx);
     const resolvedEnumNames = new Map<string, string>();
     for (const e of ctx.spec.enums) {
       resolvedEnumNames.set(resolveInterfaceName(e.name, ctx), e.name);
@@ -241,20 +316,15 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
           if (crossServiceImports.has(name)) continue;
           if (unresolvableNames.has(name)) continue;
 
-          // Check if this name exists as an enum in another service —
-          // import the actual type so the extractor sees the real name
           const irEnumName = resolvedEnumNames.get(name);
           if (irEnumName && !deps.enums.has(irEnumName)) {
             const eService = enumToService.get(irEnumName);
             const eDir = resolveDir(eService);
-            // Check baseline sourceFile — if the enum lives at a different path
-            // than the generated one, import from the baseline location.
             const bEnum = ctx.apiSurface?.enums?.[irEnumName];
             const bAlias = ctx.apiSurface?.typeAliases?.[irEnumName];
             const bSrc = (bEnum as any)?.sourceFile ?? (bAlias as any)?.sourceFile;
             const gPath = `src/${eDir}/interfaces/${fileName(irEnumName)}.interface.ts`;
             const cPath = `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`;
-            // If defined inline in the same file, just add to importable names
             if (bSrc === cPath) {
               importableNames.add(name);
               continue;
@@ -273,35 +343,56 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
             continue;
           }
 
-          // Try suffix match: find an importable name ending with this name
           const candidates = [...importableNames].filter((n) => n.endsWith(name) && n !== name);
           if (candidates.length === 1) {
-            // Create local type alias (e.g., type RoleResponse = ProfileRoleResponse)
             typeDecls.set(name, candidates[0]);
             importableNames.add(name);
           } else {
-            // Cannot resolve this baseline type name — mark it so the field
-            // falls back to the IR-generated type instead of the baseline.
-            // This avoids creating type aliases that reference undefined types.
             unresolvableNames.add(name);
           }
         }
       }
     }
 
-    // Import referenced models (domain + response) and enums with correct cross-service paths
     for (const dep of deps.models) {
       const depName = resolveInterfaceName(dep, ctx);
       const depService = modelToService.get(dep);
       const depDir = resolveDir(depService);
-      const relPath =
-        depDir === dirName ? `./${fileName(dep)}.interface` : `../../${depDir}/interfaces/${fileName(dep)}.interface`;
-      lines.push(`import type { ${depName}, ${wireInterfaceName(depName)} } from '${relPath}';`);
+
+      // When the resolver maps the IR name to a different baseline interface
+      // (via `overlayLookup.modelNameByIR` structural match), the import
+      // path must follow the baseline's `sourceFile`. Otherwise we'd point
+      // at the IR-named file (e.g. `audit-log-event.interface`) that the
+      // emitter never generates — the canonical baseline file is at a
+      // different stem (e.g. `create-audit-log-event-options.interface`).
+      const currentFilePath = `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`;
+      const baselineSrc = (ctx.apiSurface?.interfaces?.[depName] as { sourceFile?: string } | undefined)?.sourceFile;
+
+      // Self-reference: the dependency lives in the file we're currently
+      // emitting. Skip the import — it's already in scope.
+      if (baselineSrc === currentFilePath) continue;
+
+      let relPath: string;
+      if (baselineSrc) {
+        relPath = relativeImport(currentFilePath, baselineSrc).replace(/\.ts$/, '');
+      } else {
+        relPath =
+          depDir === dirName ? `./${fileName(dep)}.interface` : `../../${depDir}/interfaces/${fileName(dep)}.interface`;
+      }
+
+      // `wireInterfaceName` consults the baseline interface set so it
+      // returns the bare `depName` when the resolver mapped to a
+      // single-form interface (no separate `*Wire`). That keeps the
+      // import statement requesting only what the baseline file exports.
+      const wireName = wireInterfaceName(depName);
+      const importNames = wireName === depName ? depName : `${depName}, ${wireName}`;
+      lines.push(`import type { ${importNames} } from '${relPath}';`);
     }
     for (const dep of deps.enums) {
-      // Check if the enum has a baseline sourceFile — if it lives at a
-      // different path than the generated one, import from the baseline
-      // location since the enum file won't be regenerated there.
+      // Inlined enums are emitted as literal unions at the usage site
+      // (handled by type-map). Skip the import — the file does not exist.
+      if (isInlineEnum(dep)) continue;
+
       const baselineEnum = ctx.apiSurface?.enums?.[dep];
       const baselineAlias = ctx.apiSurface?.typeAliases?.[dep];
       const baselineSrc = (baselineEnum as any)?.sourceFile ?? (baselineAlias as any)?.sourceFile;
@@ -310,8 +401,6 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
       const generatedPath = `src/${depDir}/interfaces/${fileName(dep)}.interface.ts`;
       const currentFilePath = `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`;
 
-      // If the baseline enum is defined in the SAME file we're generating,
-      // skip the import — the merger will preserve the inline definition.
       if (baselineSrc === currentFilePath) {
         importableNames.add(dep);
         continue;
@@ -319,7 +408,6 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
 
       let relPath: string;
       if (baselineSrc && baselineSrc !== generatedPath) {
-        // Baseline provides the enum from a different file — import from there.
         relPath = relativeImport(currentFilePath, baselineSrc).replace(/\.ts$/, '');
       } else {
         relPath =
@@ -333,17 +421,16 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
 
     if (lines.length > 0) lines.push('');
 
-    // Add local type declarations for unresolvable baseline type names
-    for (const [alias, typeExpr] of typeDecls) {
-      lines.push(`type ${alias} = ${typeExpr};`);
-    }
-    if (typeDecls.size > 0) lines.push('');
-
-    // Type params (generics) — pass genericDefaults so baseline-detected generics
-    // also get type parameter declarations on the interface itself.
+    // Type-alias declarations are pre-collected from baseline field types.
+    // The IR-driven body may end up not using them (the body uses the
+    // resolved interface names, while aliases serve only as bridges from
+    // baseline-name references inside `baselineField.type`). Defer their
+    // emission, then filter to only those names actually referenced in
+    // the body or wire interface lines.
+    const typeDeclInsertIdx = lines.length;
     const typeParams = renderTypeParams(model, genericDefaults);
 
-    // Domain interface (camelCase fields) — deduplicate by camelCase name
+    // Domain interface
     const seenDomainFields = new Set<string>();
     if (model.description) {
       lines.push(...docComment(model.description));
@@ -366,10 +453,6 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
           lines.push(...docComment(parts.join('\n'), 2));
         }
         const baselineField = baselineDomain?.fields?.[domainFieldName];
-        // For the domain interface, also check that the response baseline's optionality
-        // is compatible — the serializer reads from the response type and assigns to the domain type.
-        // If the domain baseline says required but the response baseline says optional,
-        // the serializer would produce T | undefined for a field expecting T.
         const domainWireField = wireFieldName(field.name);
         const responseBaselineField = baselineResponse?.fields?.[domainWireField];
         const domainResponseOptionalMismatch =
@@ -385,23 +468,17 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
           const opt = baselineField.optional ? '?' : '';
           lines.push(`  ${readonlyPrefix}${domainFieldName}${opt}: ${baselineField.type};`);
         } else {
-          // When a baseline exists for this model, new fields (not present in the
-          // baseline) are generated as optional.  The merger can deep-merge new
-          // fields into existing interfaces, but it cannot update existing
-          // deserializer function bodies.  Making the field optional prevents a
-          // type error where the interface requires a field that the preserved
-          // deserializer never populates.
           const isNewFieldOnExistingModel = baselineDomain && !baselineField;
-          // Also make the field optional when the response baseline has it as optional
-          // but the domain baseline has it as required — the deserializer reads from
-          // the response type, so if the response field is optional, the domain value
-          // may be undefined.
-          // Additionally, when a baseline exists for the RESPONSE interface but NOT the
-          // domain interface, fields that are new on the response baseline become optional
-          // in the wire type. The domain type must also be optional to match, otherwise
-          // the deserializer produces T | undefined for a field typed as T.
           const isNewFieldOnExistingResponse = !baselineDomain && baselineResponse && !responseBaselineField;
+          // Preserve baseline-declared optionality even when we're emitting
+          // the IR-derived type (e.g. baseline `Date` for an IR string with
+          // `format: date-time`). Without this, regenerating an existing
+          // interface flips `external_id?: string` into `external_id: string
+          // | null`, which silently breaks every hand-written test fixture
+          // missing that field.
+          const baselineSaysOptional = baselineField?.optional === true;
           const opt =
+            baselineSaysOptional ||
             !field.required ||
             isNewFieldOnExistingModel ||
             domainResponseOptionalMismatch ||
@@ -412,10 +489,10 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
         }
       }
       lines.push('}');
-    } // close else for non-empty domain interface
+    }
     lines.push('');
 
-    // Wire/response interface (snake_case fields) — deduplicate by snake_case name
+    // Wire/response interface
     const seenWireFields = new Set<string>();
     if (model.fields.length === 0) {
       lines.push(`export type ${responseName}${typeParams} = object;`);
@@ -435,100 +512,107 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
           lines.push(`  ${wireField}${opt}: ${baselineField.type};`);
         } else {
           const isNewFieldOnExistingModel = baselineResponse && !baselineField;
-          const opt = !field.required || isNewFieldOnExistingModel ? '?' : '';
+          // Same baseline-optional preservation as the domain side. The
+          // wire interface's optional flag drives test-fixture shape, so
+          // flipping it on regen breaks every fixture that omitted the
+          // field assuming it was optional.
+          const baselineSaysOptional = baselineField?.optional === true;
+          const opt = baselineSaysOptional || !field.required || isNewFieldOnExistingModel ? '?' : '';
           lines.push(`  ${wireField}${opt}: ${mapWireTypeRef(field.type, modelWireTypeRefOpts)};`);
         }
       }
       lines.push('}');
-    } // close else for non-empty wire interface
+    }
 
-    // When overwriting an existing interface file, preserve inline types whose
-    // sourceFile matches this file but which aren't generated as separate files.
-    // Query the apiSurface rather than parsing the target file with regex.
+    // Preserve inline types from existing file
     const filePath = `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`;
-    if (ctx.apiSurface) {
+    if (ctx.apiSurface && ctx.targetDir) {
       const generatedNames = new Set<string>();
       for (const line of lines) {
         const m = line.match(/^export\s+(?:interface|type|enum|class|const|function)\s+(\w+)/);
         if (m) generatedNames.add(m[1]);
       }
 
-      // Read the existing file to extract inline declarations verbatim
-      if (ctx.targetDir) {
-        try {
-          const existingContent = fs.readFileSync(path.join(ctx.targetDir, filePath), 'utf-8');
-          // Collect names of inline types from the apiSurface
-          const inlineNames = new Set<string>();
-          const checkSurface = (items: Record<string, any> | undefined) => {
-            if (!items) return;
-            for (const [name, item] of Object.entries(items)) {
-              const src = (item as any).sourceFile as string | undefined;
-              if (src !== filePath) continue;
-              if (generatedNames.has(name)) continue;
-              // Check that no separate file is generated for this type
-              const sepPath = `src/${dirName}/interfaces/${fileName(name)}.interface.ts`;
-              if (sepPath !== filePath && files.some((f) => f.path === sepPath)) continue;
-              inlineNames.add(name);
+      try {
+        const existingContent = fs.readFileSync(path.join(ctx.targetDir, filePath), 'utf-8');
+        const inlineNames = new Set<string>();
+        const checkSurface = (items: Record<string, any> | undefined) => {
+          if (!items) return;
+          for (const [name, item] of Object.entries(items)) {
+            const src = (item as any).sourceFile as string | undefined;
+            if (src !== filePath) continue;
+            if (generatedNames.has(name)) continue;
+            const sepPath = `src/${dirName}/interfaces/${fileName(name)}.interface.ts`;
+            if (sepPath !== filePath && files.some((f) => f.path === sepPath)) continue;
+            inlineNames.add(name);
+          }
+        };
+        checkSurface(ctx.apiSurface.interfaces);
+        checkSurface(ctx.apiSurface.typeAliases);
+        checkSurface(ctx.apiSurface.enums);
+
+        if (inlineNames.size > 0) {
+          const existingLines = existingContent.split('\n');
+          let ei = 0;
+          while (ei < existingLines.length) {
+            const eline = existingLines[ei];
+            const dm = eline.match(/^(export\s+)?(?:interface|type|enum|class|const|function)\s+(\w+)/);
+            if (!dm || !inlineNames.has(dm[2])) {
+              ei++;
+              continue;
             }
-          };
-          checkSurface(ctx.apiSurface.interfaces);
-          checkSurface(ctx.apiSurface.typeAliases);
-          checkSurface(ctx.apiSurface.enums);
-
-          // Extract each inline type's verbatim declaration from the existing file
-          if (inlineNames.size > 0) {
-            const existingLines = existingContent.split('\n');
-            let ei = 0;
-            while (ei < existingLines.length) {
-              const eline = existingLines[ei];
-              // Match exported or non-exported declarations
-              const dm = eline.match(/^(export\s+)?(?:interface|type|enum|class|const|function)\s+(\w+)/);
-              if (!dm || !inlineNames.has(dm[2])) {
-                ei++;
-                continue;
-              }
 
-              // Collect the full declaration via brace tracking
-              const block: string[] = [eline];
-              let braces = (eline.match(/\{/g) || []).length - (eline.match(/\}/g) || []).length;
-              if (braces === 0 && eline.includes(';')) {
-                lines.push('');
-                lines.push(block.join('\n'));
-                ei++;
-                continue;
-              }
-              // Multi-line type alias (union with |)
-              if (braces === 0) {
-                ei++;
-                while (ei < existingLines.length) {
-                  const nl = existingLines[ei];
-                  block.push(nl);
-                  ei++;
-                  if (
-                    nl.trimEnd().endsWith(';') ||
-                    (nl.trim() !== '' && !nl.trim().startsWith('|') && !nl.trim().startsWith('&'))
-                  )
-                    break;
-                }
-                lines.push('');
-                lines.push(block.join('\n'));
-                continue;
-              }
-              // Brace-delimited
+            const block: string[] = [eline];
+            let braces = (eline.match(/\{/g) || []).length - (eline.match(/\}/g) || []).length;
+            if (braces === 0 && eline.includes(';')) {
+              lines.push('');
+              lines.push(block.join('\n'));
               ei++;
-              while (ei < existingLines.length && braces > 0) {
+              continue;
+            }
+            if (braces === 0) {
+              ei++;
+              while (ei < existingLines.length) {
                 const nl = existingLines[ei];
                 block.push(nl);
-                braces += (nl.match(/\{/g) || []).length - (nl.match(/\}/g) || []).length;
                 ei++;
+                if (
+                  nl.trimEnd().endsWith(';') ||
+                  (nl.trim() !== '' && !nl.trim().startsWith('|') && !nl.trim().startsWith('&'))
+                )
+                  break;
               }
               lines.push('');
               lines.push(block.join('\n'));
+              continue;
             }
+            ei++;
+            while (ei < existingLines.length && braces > 0) {
+              const nl = existingLines[ei];
+              block.push(nl);
+              braces += (nl.match(/\{/g) || []).length - (nl.match(/\}/g) || []).length;
+              ei++;
+            }
+            lines.push('');
+            lines.push(block.join('\n'));
           }
-        } catch {
-          // No existing file — nothing to preserve
         }
+      } catch {
+        // No existing file
+      }
+    }
+
+    // Splice in only the type aliases referenced by the body or wire lines.
+    if (typeDecls.size > 0) {
+      const bodyText = lines.slice(typeDeclInsertIdx).join('\n');
+      const usedDecls: string[] = [];
+      for (const [alias, typeExpr] of typeDecls) {
+        if (new RegExp(`\\b${alias}\\b`).test(bodyText)) {
+          usedDecls.push(`type ${alias} = ${typeExpr};`);
+        }
+      }
+      if (usedDecls.length > 0) {
+        lines.splice(typeDeclInsertIdx, 0, ...usedDecls, '');
       }
     }
 
@@ -542,129 +626,10 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
   return files;
 }
 
-/**
- * Check if all PascalCase type references in a baseline type string
- * can be resolved to types that are actually importable in the generated file.
- * A type is importable if it's a builtin, or if it's among the set of names
- * that will be imported (the model's own name/response, or its IR deps).
- * Returns false if any reference is unresolvable (e.g., hand-written types
- * from the live SDK, or spec types from other services not in IR deps).
- */
-function baselineTypeResolvable(typeStr: string, importableNames: Set<string>): boolean {
-  const matches = typeStr.match(/\b[A-Z][a-zA-Z0-9]*\b/g);
-  if (!matches) return true;
-
-  for (const name of matches) {
-    if (TS_BUILTINS.has(name)) continue;
-    if (importableNames.has(name)) continue;
-    return false;
-  }
-  return true;
-}
-
-/**
- * Check if a baseline field type is compatible with the IR field for use
- * in the generated interface. The serializer generates expressions based on
- * the IR type, so the interface type must be assignable from the serializer output.
- *
- * Rejects baseline types when:
- * - IR field is nullable but baseline type doesn't include `null`
- * - IR field is optional but baseline says required (and vice versa)
- * - IR field is required but baseline says optional
- */
-function baselineFieldCompatible(baselineField: { type: string; optional: boolean }, irField: Field): boolean {
-  const irNullable = irField.type.kind === 'nullable';
-  const baselineHasNull = baselineField.type.includes('null');
-
-  // If the IR field is nullable, the serializer produces `expr ?? null`,
-  // so the baseline type must include null to be assignable.
-  // Exception: for optional fields, the serializer's null guard converts
-  // null to undefined (`wireAccess != null ? expr : undefined`), so the
-  // result type is `T | undefined` which is compatible with `field?: T`.
-  if (irNullable && !baselineHasNull && irField.required) {
-    return false;
-  }
-
-  // If the IR field is optional, the serializer may produce undefined,
-  // so the baseline should also be optional (or include undefined)
-  if (!irField.required && !baselineField.optional && !baselineField.type.includes('undefined')) {
-    return false;
-  }
-
-  // If the IR field is required but the baseline says optional,
-  // the serializer produces a definite value but the interface is looser — that's OK
-  // (the domain type is wider than the serializer output)
-
-  // If the baseline type is Record<string, unknown> but the IR field has a more specific
-  // type (model, enum, or union with named variants), prefer the IR type for better type safety
-  if (baselineField.type === 'Record<string, unknown>' && hasSpecificIRType(irField.type)) {
-    return false;
-  }
-
-  return true;
-}
-
-/** Check if an IR type is more specific than Record<string, unknown>. */
-function hasSpecificIRType(ref: TypeRef): boolean {
-  switch (ref.kind) {
-    case 'model':
-    case 'enum':
-      return true;
-    case 'union':
-      // A union with named model/enum variants is more specific
-      return ref.variants.some((v) => v.kind === 'model' || v.kind === 'enum');
-    case 'nullable':
-      return hasSpecificIRType(ref.inner);
-    default:
-      return false;
-  }
-}
-
-function renderTypeParams(model: Model, genericDefaults?: Map<string, string>): string {
-  if (!model.typeParams?.length) {
-    // Fallback: if genericDefaults indicates this model is generic (detected
-    // from the baseline), generate a default generic type parameter declaration.
-    if (genericDefaults?.has(model.name)) {
-      return '<GenericType extends Record<string, unknown> = Record<string, unknown>>';
-    }
-    return '';
-  }
-  const params = model.typeParams.map((tp) => {
-    const def = tp.default ? ` = ${mapTypeRef(tp.default)}` : '';
-    return `${tp.name}${def}`;
-  });
-  return `<${params.join(', ')}>`;
-}
-
-// ---------------------------------------------------------------------------
-// Shared context — computed once and reused by interface + serializer passes
-// ---------------------------------------------------------------------------
-
-interface SharedModelContext {
-  modelToService: Map<string, string>;
-  resolveDir: (irService: string | undefined) => string;
-  dedup: Map<string, string>;
-  genericDefaults: Map<string, string>;
-}
-
-function buildSharedContext(models: Model[], ctx: EmitterContext): SharedModelContext {
-  const { modelToService, resolveDir } = createServiceDirResolver(models, ctx.spec.services, ctx);
-  const genericDefaults = buildGenericModelDefaults(ctx.spec.models);
-  enrichGenericDefaultsFromBaseline(genericDefaults, models, ctx, resolveDir, modelToService);
-  const nonEventReachable = computeNonEventReachable(ctx.spec.services, models);
-  const dedup = buildDeduplicationMap(models, ctx, nonEventReachable);
-  return { modelToService, resolveDir, dedup, genericDefaults };
-}
-
 // ---------------------------------------------------------------------------
-// Serializer file generation (moved from serializers.ts)
+// Serializer generation
 // ---------------------------------------------------------------------------
 
-/**
- * Generate serializer files for all models.
- * Can accept pre-computed shared context to avoid duplicating work
- * when called alongside generateModels.
- */
 export function generateSerializers(
   models: Model[],
   ctx: EmitterContext,
@@ -675,42 +640,55 @@ export function generateSerializers(
   const { modelToService, resolveDir, dedup } = shared ?? buildSharedContext(models, ctx);
   const files: GeneratedFile[] = [];
   const skippedSerializeModels = new Set<string>();
+  const projectedModels = models.map((model) =>
+    projectModelToManagedSurface(model, { modelToService, resolveDir, dedup, genericDefaults: new Map() }, ctx),
+  );
+  const projectedByName = new Map(projectedModels.map((model) => [model.name, model]));
+  const resourceUsage = buildGeneratedResourceModelUsage(models, ctx);
+  const serializerEligibleModels = resourceUsage
+    ? expandModelRoots(resourceUsage.serializerRoots, projectedByName)
+    : undefined;
 
-  // Reuse the same reachability set from generateModels to skip serializers
-  // for unreachable models (e.g., event/webhook payload types).
   const serializerReachable = computeNonEventReachable(ctx.spec.services, models);
 
-  // Pre-populate skippedSerializeModels for baseline models that won't be
-  // regenerated. Their existing serializers may only export deserialize.
-  if (ctx.targetDir) {
-    for (const model of models) {
+  // Detect models whose serializer file already exists in the live SDK but
+  // does not export a `serialize<Domain>` function. Generated serializers
+  // that reference such a model must skip their `serialize` half — calling
+  // a missing function would leave the SDK unable to compile.
+  const liveRoot = ctx.targetDir ?? ctx.outputDir;
+  if (liveRoot) {
+    for (const originalModel of models) {
+      const model = projectedByName.get(originalModel.name) ?? originalModel;
       if (!serializerReachable.has(model.name)) continue;
-      if (modelHasNewFields(model, ctx)) continue; // will be regenerated
+      if (serializerEligibleModels && !serializerEligibleModels.has(model.name)) continue;
       const service = modelToService.get(model.name);
       const dirName = resolveDir(service);
       const domainName = resolveInterfaceName(model.name, ctx);
-      const serializerFile = path.join(
-        ctx.targetDir,
-        'src',
-        dirName,
-        'serializers',
-        `${fileName(model.name)}.serializer.ts`,
-      );
+      const baselineSource = (ctx.apiSurface?.interfaces?.[domainName] as { sourceFile?: string } | undefined)
+        ?.sourceFile;
+      const serializerRelPath = baselineSource
+        ? baselineSource.replace('/interfaces/', '/serializers/').replace('.interface.ts', '.serializer.ts')
+        : `src/${dirName}/serializers/${fileName(model.name)}.serializer.ts`;
+      const serializerFile = path.join(liveRoot, serializerRelPath);
       try {
         const content = fs.readFileSync(serializerFile, 'utf-8');
-        if (!new RegExp(`\\bserialize${domainName}\\b`).test(content)) {
+        const isGeneratedFile =
+          ctx.priorTargetManifestPaths?.has(serializerRelPath) ||
+          /auto-generated by oagen/i.test(content.slice(0, 400));
+        if (!isGeneratedFile && !new RegExp(`\\bserialize${domainName}\\b`).test(content)) {
           skippedSerializeModels.add(model.name);
         }
       } catch {
-        // Serializer doesn't exist — model may be new or generated differently
+        // Serializer doesn't exist on disk yet — fine, we'll generate one.
       }
     }
   }
 
-  // Force-generate serializers for inline dependency models (same logic as interfaces).
   const forceGenerateSerializer = new Set<string>();
-  for (const model of models) {
+  for (const originalModel of models) {
+    const model = projectedByName.get(originalModel.name) ?? originalModel;
     if (!serializerReachable.has(model.name)) continue;
+    if (serializerEligibleModels && !serializerEligibleModels.has(model.name)) continue;
     if (!modelHasNewFields(model, ctx)) continue;
     const service = modelToService.get(model.name);
     const dirName = resolveDir(service);
@@ -726,21 +704,23 @@ export function generateSerializers(
     }
   }
 
-  // --- Pass 1: pre-compute which models skip serialize (ordering-independent) ---
-  // This must run BEFORE file generation so that buildSerializerImports can
-  // check the fully-populated set and avoid importing non-existent serialize functions.
   const eligibleModels: Model[] = [];
-  for (const model of models) {
+  for (const originalModel of models) {
+    const model = projectedByName.get(originalModel.name) ?? originalModel;
     if (!serializerReachable.has(model.name)) continue;
+    if (serializerEligibleModels && !serializerEligibleModels.has(model.name)) continue;
     if (isListMetadataModel(model)) continue;
     if (isListWrapperModel(model)) continue;
-    if (!modelHasNewFields(model, ctx) && !forceGenerateSerializer.has(model.name)) continue;
+    const service = modelToService.get(model.name);
+    const isOwnedModel = isNodeOwnedService(ctx, service);
+    if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerateSerializer.has(model.name)) continue;
     eligibleModels.push(model);
   }
+  (ctx as any)._generatedSerializerModels = new Set(eligibleModels.map((model) => model.name));
 
-  // First pass: determine shouldSkipSerialize for every eligible model
+  // Pass 1: determine shouldSkipSerialize
   for (const model of eligibleModels) {
-    if (dedup.has(model.name)) continue; // dedup aliases don't get their own serialize
+    if (dedup.has(model.name)) continue;
     const domainName = resolveInterfaceName(model.name, ctx);
     const responseName = wireInterfaceName(domainName);
     const baselineResponse = ctx.apiSurface?.interfaces?.[responseName];
@@ -758,14 +738,13 @@ export function generateSerializers(
     }
   }
 
-  // --- Pass 2: generate serializer files using fully-populated skip set ---
+  // Pass 2: generate serializer files
   for (const model of eligibleModels) {
-    // Deduplication: for structurally identical models, re-export the canonical serializer
+    const service = modelToService.get(model.name);
+    const isOwnedModel = isNodeOwnedService(ctx, service);
     const canonicalName = dedup.get(model.name);
-    if (canonicalName) {
-      const service = modelToService.get(model.name);
+    if (canonicalName && !isOwnedModel) {
       const dirName = resolveDir(service);
-      // Skip typeAlias resolution for dedup serializers (same reason as interfaces).
       const skipTA = { skipTypeAlias: true };
       const domainName = resolveInterfaceName(model.name, ctx, skipTA);
       const canonDomainName = resolveInterfaceName(canonicalName, ctx, skipTA);
@@ -775,9 +754,6 @@ export function generateSerializers(
       const serializerPath = `src/${dirName}/serializers/${fileName(model.name)}.serializer.ts`;
       const canonSerializerPath = `src/${canonDir}/serializers/${fileName(canonicalName)}.serializer.ts`;
 
-      // After noise suffix stripping, alias and canonical may resolve to the
-      // same serializer path or the same function names.  Skip — the canonical
-      // serializer already provides the functions.
       if (serializerPath === canonSerializerPath) continue;
       if (domainName === canonDomainName) continue;
       const rel = relativeImport(serializerPath, canonSerializerPath);
@@ -793,7 +769,6 @@ export function generateSerializers(
       continue;
     }
 
-    const service = modelToService.get(model.name);
     const dirName = resolveDir(service);
     const isDedupCanonical = [...dedup.values()].includes(model.name);
     const domainName = resolveInterfaceName(model.name, ctx, isDedupCanonical ? { skipTypeAlias: true } : undefined);
@@ -829,23 +804,237 @@ export function generateSerializers(
     });
   }
 
-  // Stash the fully-computed skip set on the context so the test generator
-  // can read it without duplicating the detection logic.
   (ctx as any)._skippedSerializeModels = skippedSerializeModels;
 
   return files;
 }
 
 // ---------------------------------------------------------------------------
-// Combined generation — single shared context, two output streams
+// Combined generation
 // ---------------------------------------------------------------------------
 
-/**
- * Generate both interface files and serializer files in a single pass
- * with shared context computation.
- */
 export function generateModelsAndSerializers(models: Model[], ctx: EmitterContext): GeneratedFile[] {
   if (models.length === 0) return [];
   const shared = buildSharedContext(models, ctx);
   return [...generateModels(models, ctx, shared), ...generateSerializers(models, ctx, shared)];
 }
+
+export function generatedResourceInterfaceModelNames(models: Model[], ctx: EmitterContext): Set<string> | undefined {
+  const shared = buildSharedContext(models, ctx);
+  const projectedModels = models.map((model) => projectModelToManagedSurface(model, shared, ctx));
+  const projectedByName = new Map(projectedModels.map((model) => [model.name, model]));
+  const resourceUsage = buildGeneratedResourceModelUsage(models, ctx);
+  return resourceUsage ? expandModelRoots(resourceUsage.interfaceRoots, projectedByName) : undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function buildGeneratedResourceModelUsage(
+  models: Model[],
+  ctx: EmitterContext,
+): GeneratedResourceModelUsage | undefined {
+  if (ctx.spec.services.length === 0) return undefined;
+
+  const modelMap = new Map(models.map((model) => [model.name, model]));
+  const interfaceRoots = new Set<string>();
+  const serializerRoots = new Set<string>();
+  const resolvedLookup = buildResolvedLookup(ctx);
+  const mountGroups = groupByMount(ctx);
+  const services: Service[] =
+    mountGroups.size > 0
+      ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
+      : ctx.spec.services;
+
+  for (const service of services) {
+    const resourceClass = resolveResourceClassName(service, ctx);
+    const isOwnedService = isNodeOwnedService(ctx, service.name, resourceClass);
+    const baselineHasResourceClass = Boolean(ctx.apiSurface?.classes?.[resourceClass]);
+
+    if (
+      !isOwnedService &&
+      baselineHasResourceClass &&
+      isServiceCoveredByExisting(service, ctx) &&
+      !hasMethodsAbsentFromBaseline(service, ctx)
+    ) {
+      continue;
+    }
+
+    let plans = service.operations.map((op) => ({
+      op,
+      plan: planOperation(op),
+      method: resolveMethodName(op, service, ctx),
+    }));
+
+    const baselineMethodNames = new Set(Object.keys(ctx.apiSurface?.classes?.[resourceClass]?.methods ?? {}));
+    if (!isOwnedService && baselineMethodNames.size > 0) {
+      plans = plans.filter((p) => !baselineMethodNames.has(p.method));
+    }
+    if (plans.length === 0) continue;
+
+    for (const { op, plan } of plans) {
+      if (plan.isPaginated && op.pagination && op.httpMethod === 'get') {
+        let itemName = op.pagination.itemType.kind === 'model' ? op.pagination.itemType.name : undefined;
+        if (itemName) {
+          const itemModel = modelMap.get(itemName);
+          const unwrapped = itemModel ? unwrapListModel(itemModel, modelMap) : null;
+          if (unwrapped) itemName = unwrapped.name;
+          interfaceRoots.add(itemName);
+          serializerRoots.add(itemName);
+        }
+      } else if (plan.responseModelName) {
+        interfaceRoots.add(plan.responseModelName);
+        serializerRoots.add(plan.responseModelName);
+      }
+
+      const bodyInfo = extractRequestBodyModels(op, ctx);
+      for (const name of bodyInfo) {
+        interfaceRoots.add(name);
+        serializerRoots.add(name);
+      }
+
+      for (const param of [...op.pathParams, ...op.queryParams, ...op.headerParams]) {
+        collectTypeRefModels(param.type, interfaceRoots);
+      }
+
+      const resolved = lookupResolved(op, resolvedLookup);
+      if (resolved) {
+        for (const name of collectWrapperResponseModels(resolved)) {
+          interfaceRoots.add(name);
+          serializerRoots.add(name);
+        }
+        for (const wrapper of resolved.wrappers ?? []) {
+          for (const { field } of resolveWrapperParams(wrapper, ctx)) {
+            if (field) collectTypeRefModels(field.type, interfaceRoots);
+          }
+        }
+      }
+    }
+  }
+
+  return { interfaceRoots, serializerRoots };
+}
+
+function extractRequestBodyModels(op: Operation, ctx: EmitterContext): string[] {
+  if (!op.requestBody) return [];
+  if (op.requestBody.kind === 'model') return [op.requestBody.name];
+  if (op.requestBody.kind !== 'union') return [];
+
+  const names: string[] = [];
+  for (const variant of op.requestBody.variants) {
+    if (variant.kind === 'model') names.push(variant.name);
+  }
+
+  return names.length > 0 ? names : collectDiscriminatorModelNames(op.requestBody.discriminator, ctx);
+}
+
+function collectDiscriminatorModelNames(
+  discriminator: { mapping?: Record<string, string> } | undefined,
+  ctx: EmitterContext,
+): string[] {
+  const names = new Set<string>();
+  for (const mapped of Object.values(discriminator?.mapping ?? {})) {
+    const name = mapped.split('/').pop();
+    if (name && ctx.spec.models.some((model) => model.name === name)) names.add(name);
+  }
+  return [...names];
+}
+
+function collectTypeRefModels(ref: TypeRef | undefined, out: Set<string>): void {
+  if (!ref) return;
+  switch (ref.kind) {
+    case 'model':
+      out.add(ref.name);
+      return;
+    case 'array':
+      collectTypeRefModels(ref.items, out);
+      return;
+    case 'nullable':
+      collectTypeRefModels(ref.inner, out);
+      return;
+    case 'union':
+      for (const variant of ref.variants) collectTypeRefModels(variant, out);
+      return;
+    default:
+      return;
+  }
+}
+
+function expandModelRoots(roots: Set<string>, modelsByName: Map<string, Model>): Set<string> {
+  const out = new Set<string>();
+  const queue = [...roots];
+
+  while (queue.length > 0) {
+    const name = queue.pop()!;
+    if (out.has(name)) continue;
+    const model = modelsByName.get(name);
+    if (!model) continue;
+    out.add(name);
+
+    for (const dep of collectFieldDependencies(model).models) {
+      if (!out.has(dep)) queue.push(dep);
+    }
+  }
+
+  return out;
+}
+
+function baselineTypeResolvable(typeStr: string, importableNames: Set<string>): boolean {
+  const matches = typeStr.match(/\b[A-Z][a-zA-Z0-9]*\b/g);
+  if (!matches) return true;
+
+  for (const name of matches) {
+    if (TS_BUILTINS.has(name)) continue;
+    if (importableNames.has(name)) continue;
+    return false;
+  }
+  return true;
+}
+
+function baselineFieldCompatible(baselineField: { type: string; optional: boolean }, irField: Field): boolean {
+  const irNullable = irField.type.kind === 'nullable';
+  const baselineHasNull = baselineField.type.includes('null');
+
+  if (irNullable && !baselineHasNull && irField.required) {
+    return false;
+  }
+
+  if (!irField.required && !baselineField.optional && !baselineField.type.includes('undefined')) {
+    return false;
+  }
+
+  if (baselineField.type === 'Record<string, unknown>' && hasSpecificIRType(irField.type)) {
+    return false;
+  }
+
+  return true;
+}
+
+function hasSpecificIRType(ref: TypeRef): boolean {
+  switch (ref.kind) {
+    case 'model':
+    case 'enum':
+      return true;
+    case 'union':
+      return ref.variants.some((v) => v.kind === 'model' || v.kind === 'enum');
+    case 'nullable':
+      return hasSpecificIRType(ref.inner);
+    default:
+      return false;
+  }
+}
+
+function renderTypeParams(model: Model, genericDefaults?: Map<string, string>): string {
+  if (!model.typeParams?.length) {
+    if (genericDefaults?.has(model.name)) {
+      return '<GenericType extends Record<string, unknown> = Record<string, unknown>>';
+    }
+    return '';
+  }
+  const params = model.typeParams.map((tp) => {
+    const def = tp.default ? ` = ${mapTypeRef(tp.default)}` : '';
+    return `${tp.name}${def}`;
+  });
+  return `<${params.join(', ')}>`;
+}