@workos/oagen-emitters 0.2.0 → 0.3.0

package/src/node/fixtures.ts

@@ -1,5 +1,5 @@
 import type { Model, TypeRef, Enum, EmitterContext } from '@workos/oagen';
-import { wireFieldName, fileName, serviceDirName } from './naming.js';
+import { wireFieldName, fileName, resolveServiceDir } from './naming.js';
 import { resolveResourceClassName } from './resources.js';
 import { createServiceDirResolver, assignModelsToServices, isListMetadataModel, isListWrapperModel } from './utils.js';
 
@@ -42,12 +42,13 @@ export function generateFixtures(
     ? createServiceDirResolver(spec.models, ctx.spec.services, ctx)
     : {
         modelToService: assignModelsToServices(spec.models, spec.services),
-        resolveDir: (irService: string | undefined) => (irService ? serviceDirName(irService) : 'common'),
+        resolveDir: (irService: string | undefined) => (irService ? resolveServiceDir(irService) : 'common'),
       };
   const modelMap = new Map(spec.models.map((m) => [m.name, m]));
   const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
   const files: { path: string; content: string }[] = [];
 
+  const seenFixturePaths = new Set<string>();
   for (const model of spec.models) {
     // Skip redundant list-metadata and list-wrapper models (handled by shared types)
     if (isListMetadataModel(model)) continue;
@@ -55,10 +56,17 @@ export function generateFixtures(
 
     const service = modelToService.get(model.name);
     const dirName = resolveDir(service);
+    const fixturePath = `src/${dirName}/fixtures/${fileName(model.name)}.fixture.json`;
+
+    // After noise suffix stripping, multiple models may resolve to the same
+    // fixture path (e.g., OrganizationDto and Organization).  Skip duplicates.
+    if (seenFixturePaths.has(fixturePath)) continue;
+    seenFixturePaths.add(fixturePath);
+
     const fixture = generateModelFixture(model, modelMap, enumMap);
 
     files.push({
-      path: `src/${dirName}/fixtures/${fileName(model.name)}.fixture.json`,
+      path: fixturePath,
       content: JSON.stringify(fixture, null, 2),
     });
   }
@@ -66,7 +74,7 @@ export function generateFixtures(
   // Generate list fixtures for models that appear in paginated responses
   for (const service of spec.services) {
     const resolvedName = ctx ? resolveResourceClassName(service, ctx) : service.name;
-    const serviceDir = serviceDirName(resolvedName);
+    const serviceDir = resolveServiceDir(resolvedName);
     for (const op of service.operations) {
       if (op.pagination) {
         let itemModel = op.pagination.itemType.kind === 'model' ? modelMap.get(op.pagination.itemType.name) : null;
@@ -175,7 +183,9 @@ function generateFieldValue(
       }
       return null;
     case 'map':
-      return { key: generateFieldValue(ref.valueType, 'value', modelName, modelMap, enumMap) };
+      return {
+        key: generateFieldValue(ref.valueType, 'value', modelName, modelMap, enumMap),
+      };
   }
 }
 

package/src/node/index.ts

@@ -1,41 +1,55 @@
-import type { Emitter, EmitterContext, GeneratedFile, ApiSpec, Model, Enum, Service } from '@workos/oagen';
+import type {
+  Emitter,
+  EmitterContext,
+  FormatCommand,
+  GeneratedFile,
+  ApiSpec,
+  Model,
+  Enum,
+  Service,
+} from '@workos/oagen';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 
-import { generateModels } from './models.js';
+import { generateModelsAndSerializers } from './models.js';
 import { generateEnums } from './enums.js';
-import { generateSerializers } from './serializers.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
 import { generateErrors } from './errors.js';
-import { generateConfig } from './config.js';
-import { generateCommon } from './common.js';
 import { generateTests } from './tests.js';
 import { generateManifest } from './manifest.js';
 
+/** Ensure every generated file's content ends with a trailing newline. */
+function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
+  for (const f of files) {
+    if (f.content && !f.content.endsWith('\n')) {
+      f.content += '\n';
+    }
+  }
+  return files;
+}
+
 export const nodeEmitter: Emitter = {
   language: 'node',
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
-    return [...generateModels(models, ctx), ...generateSerializers(models, ctx)];
+    return ensureTrailingNewlines(generateModelsAndSerializers(models, ctx));
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
-    return generateEnums(enums, ctx);
+    return ensureTrailingNewlines(generateEnums(enums, ctx));
   },
 
   generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {
-    return generateResources(services, ctx);
+    return ensureTrailingNewlines(generateResources(services, ctx));
   },
 
   generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return generateClient(spec, ctx);
+    return ensureTrailingNewlines(generateClient(spec, ctx));
   },
 
   generateErrors(ctx: EmitterContext): GeneratedFile[] {
-    return generateErrors(ctx);
-  },
-
-  generateConfig(_ctx: EmitterContext): GeneratedFile[] {
-    return [...generateConfig(), ...generateCommon()];
+    return ensureTrailingNewlines(generateErrors(ctx));
   },
 
   generateTypeSignatures(_spec: ApiSpec, _ctx: EmitterContext): GeneratedFile[] {
@@ -44,14 +58,49 @@ export const nodeEmitter: Emitter = {
   },
 
   generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return generateTests(spec, ctx);
+    return ensureTrailingNewlines(generateTests(spec, ctx));
   },
 
   generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return generateManifest(spec, ctx);
+    return ensureTrailingNewlines(generateManifest(spec, ctx));
   },
 
   fileHeader(): string {
     return '// This file is auto-generated by oagen. Do not edit.';
   },
+
+  formatCommand(targetDir: string): FormatCommand | null {
+    const hasPrettier = fs.existsSync(path.join(targetDir, '.prettierrc'));
+    const hasEslint =
+      fs.existsSync(path.join(targetDir, 'eslint.config.mjs')) ||
+      fs.existsSync(path.join(targetDir, 'eslint.config.js')) ||
+      fs.existsSync(path.join(targetDir, '.eslintrc.json')) ||
+      fs.existsSync(path.join(targetDir, '.eslintrc.js'));
+
+    if (hasPrettier && hasEslint) {
+      // Chain ESLint autofix (e.g. unused-import removal) then prettier.
+      // ESLint errors are suppressed so formatting still runs on lint failure.
+      return {
+        cmd: 'bash',
+        args: [
+          '-c',
+          'npx eslint --fix --no-error-on-unmatched-pattern "$@" 2>/dev/null; npx prettier --write --log-level silent "$@"',
+          '--',
+        ],
+      };
+    }
+    if (hasPrettier) {
+      return {
+        cmd: 'npx',
+        args: ['prettier', '--write', '--log-level', 'silent'],
+      };
+    }
+    if (hasEslint) {
+      return {
+        cmd: 'npx',
+        args: ['eslint', '--fix', '--no-error-on-unmatched-pattern'],
+      };
+    }
+    return null;
+  },
 };

package/src/node/models.ts

@@ -14,8 +14,16 @@ import {
   isListMetadataModel,
   isListWrapperModel,
   buildDeduplicationMap,
+  relativeImport,
 } from './utils.js';
 import { assignEnumsToServices } from './enums.js';
+import {
+  renderSerializerTypeParams,
+  buildSerializerImports,
+  buildSkipFormatFields,
+  shouldSkipSerializeForModel,
+  emitSerializerBody,
+} from './field-plan.js';
 
 /**
  * Detect baseline interfaces that are generic (have type parameters) even though
@@ -58,26 +66,21 @@ function enrichGenericDefaultsFromBaseline(
   }
 }
 
-export function generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
+export function generateModels(models: Model[], ctx: EmitterContext, shared?: SharedModelContext): GeneratedFile[] {
   if (models.length === 0) return [];
 
-  const { modelToService, resolveDir } = createServiceDirResolver(models, ctx.spec.services, ctx);
-  // Detect whether the existing SDK uses string dates (ISO 8601) rather than Date objects.
-  // When detected, newly generated models also use string to maintain consistency.
-  const useStringDates = detectStringDateConvention(models, ctx);
-  const genericDefaults = buildGenericModelDefaults(ctx.spec.models);
-  // Enrich genericDefaults from baseline interfaces that appear to be generic.
-  // The IR doesn't carry typeParams for models parsed from OpenAPI (which has no
-  // generics), but the existing SDK may have hand-written generic interfaces
-  // (e.g., Profile<CustomAttributesType>).  Detect these by checking if any
-  // field type contains a PascalCase name that isn't a known model, enum, or builtin.
-  enrichGenericDefaultsFromBaseline(genericDefaults, models, ctx, resolveDir, modelToService);
+  const {
+    modelToService,
+    resolveDir,
+    useStringDates,
+    dedup: sharedDedup,
+    genericDefaults: sharedDefaults,
+  } = shared ?? buildSharedContext(models, ctx);
+  const genericDefaults = sharedDefaults;
   const typeRefOpts = useStringDates ? { stringDates: true, genericDefaults } : { genericDefaults };
   const wireTypeRefOpts = { genericDefaults };
   const files: GeneratedFile[] = [];
-
-  // Detect structurally identical or same-name models — emit type aliases for duplicates
-  const dedup = buildDeduplicationMap(models, ctx);
+  const dedup = sharedDedup;
 
   for (const model of models) {
     // Fix #4: Skip per-domain ListMetadata interfaces — the shared ListMetadata type covers these
@@ -90,14 +93,28 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     // emit a type alias instead of a full interface.
     const canonicalName = dedup.get(model.name);
     if (canonicalName) {
-      const domainName = resolveInterfaceName(model.name, ctx);
-      const responseName = wireInterfaceName(domainName);
-      const canonDomainName = resolveInterfaceName(canonicalName, ctx);
-      const canonResponseName = wireInterfaceName(canonDomainName);
       const service = modelToService.get(model.name);
       const dirName = resolveDir(service);
+
+      // Skip typeAlias resolution for dedup models.  The canonical file may
+      // be preserved (skipIfExists) and 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);
+      const canonDomainName = resolveInterfaceName(canonicalName, ctx, skipTA);
+      const canonResponseName = wireInterfaceName(canonDomainName);
+
       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;
+      if (domainName === canonDomainName) continue;
       const canonRelPath =
         canonDir === dirName
           ? `./${fileName(canonicalName)}.interface`
@@ -109,7 +126,7 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
         `export type ${responseName} = ${canonResponseName};`,
       ];
       files.push({
-        path: `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`,
+        path: aliasPath,
         content: aliasLines.join('\n'),
         skipIfExists: true,
       });
@@ -118,7 +135,11 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
 
     const service = modelToService.get(model.name);
     const dirName = resolveDir(service);
-    const domainName = resolveInterfaceName(model.name, ctx);
+    // 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[] = [];
@@ -252,87 +273,98 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     if (model.description) {
       lines.push(...docComment(model.description));
     }
-    lines.push(`export interface ${domainName}${typeParams} {`);
-    for (const field of model.fields) {
-      const domainFieldName = fieldName(field.name);
-      if (seenDomainFields.has(domainFieldName)) continue;
-      seenDomainFields.add(domainFieldName);
-      if (field.description || field.deprecated || field.readOnly || field.writeOnly || field.default !== undefined) {
-        const parts: string[] = [];
-        if (field.description) parts.push(field.description);
-        if (field.readOnly) parts.push('@readonly');
-        if (field.writeOnly) parts.push('@writeonly');
-        if (field.default !== undefined) parts.push(`@default ${JSON.stringify(field.default)}`);
-        if (field.deprecated) parts.push('@deprecated');
-        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 =
-        baselineField && !baselineField.optional && responseBaselineField && responseBaselineField.optional;
-      const readonlyPrefix = field.readOnly ? 'readonly ' : '';
-      if (
-        baselineField &&
-        !domainResponseOptionalMismatch &&
-        baselineTypeResolvable(baselineField.type, importableNames) &&
-        baselineFieldCompatible(baselineField, field)
-      ) {
-        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;
-        const opt =
-          !field.required || isNewFieldOnExistingModel || domainResponseOptionalMismatch || isNewFieldOnExistingResponse
-            ? '?'
-            : '';
-        lines.push(`  ${readonlyPrefix}${domainFieldName}${opt}: ${mapTypeRef(field.type, modelTypeRefOpts)};`);
+    if (model.fields.length === 0) {
+      lines.push(`export type ${domainName}${typeParams} = object;`);
+    } else {
+      lines.push(`export interface ${domainName}${typeParams} {`);
+      for (const field of model.fields) {
+        const domainFieldName = fieldName(field.name);
+        if (seenDomainFields.has(domainFieldName)) continue;
+        seenDomainFields.add(domainFieldName);
+        if (field.description || field.deprecated || field.readOnly || field.writeOnly || field.default !== undefined) {
+          const parts: string[] = [];
+          if (field.description) parts.push(field.description);
+          if (field.readOnly) parts.push('@readonly');
+          if (field.writeOnly) parts.push('@writeonly');
+          if (field.default !== undefined) parts.push(`@default ${JSON.stringify(field.default)}`);
+          if (field.deprecated) parts.push('@deprecated');
+          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 =
+          baselineField && !baselineField.optional && responseBaselineField && responseBaselineField.optional;
+        const readonlyPrefix = field.readOnly ? 'readonly ' : '';
+        if (
+          baselineField &&
+          !domainResponseOptionalMismatch &&
+          baselineTypeResolvable(baselineField.type, importableNames) &&
+          baselineFieldCompatible(baselineField, field)
+        ) {
+          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;
+          const opt =
+            !field.required ||
+            isNewFieldOnExistingModel ||
+            domainResponseOptionalMismatch ||
+            isNewFieldOnExistingResponse
+              ? '?'
+              : '';
+          lines.push(`  ${readonlyPrefix}${domainFieldName}${opt}: ${mapTypeRef(field.type, modelTypeRefOpts)};`);
+        }
       }
-    }
-    lines.push('}');
+      lines.push('}');
+    } // close else for non-empty domain interface
     lines.push('');
 
     // Wire/response interface (snake_case fields) — deduplicate by snake_case name
     const seenWireFields = new Set<string>();
-    lines.push(`export interface ${responseName}${typeParams} {`);
-    for (const field of model.fields) {
-      const wireField = wireFieldName(field.name);
-      if (seenWireFields.has(wireField)) continue;
-      seenWireFields.add(wireField);
-      const baselineField = baselineResponse?.fields?.[wireField];
-      if (
-        baselineField &&
-        baselineTypeResolvable(baselineField.type, importableNames) &&
-        baselineFieldCompatible(baselineField, field)
-      ) {
-        const opt = baselineField.optional ? '?' : '';
-        lines.push(`  ${wireField}${opt}: ${baselineField.type};`);
-      } else {
-        const isNewFieldOnExistingModel = baselineResponse && !baselineField;
-        const opt = !field.required || isNewFieldOnExistingModel ? '?' : '';
-        lines.push(`  ${wireField}${opt}: ${mapWireTypeRef(field.type, modelWireTypeRefOpts)};`);
+    if (model.fields.length === 0) {
+      lines.push(`export type ${responseName}${typeParams} = object;`);
+    } else {
+      lines.push(`export interface ${responseName}${typeParams} {`);
+      for (const field of model.fields) {
+        const wireField = wireFieldName(field.name);
+        if (seenWireFields.has(wireField)) continue;
+        seenWireFields.add(wireField);
+        const baselineField = baselineResponse?.fields?.[wireField];
+        if (
+          baselineField &&
+          baselineTypeResolvable(baselineField.type, importableNames) &&
+          baselineFieldCompatible(baselineField, field)
+        ) {
+          const opt = baselineField.optional ? '?' : '';
+          lines.push(`  ${wireField}${opt}: ${baselineField.type};`);
+        } else {
+          const isNewFieldOnExistingModel = baselineResponse && !baselineField;
+          const opt = !field.required || isNewFieldOnExistingModel ? '?' : '';
+          lines.push(`  ${wireField}${opt}: ${mapWireTypeRef(field.type, modelWireTypeRefOpts)};`);
+        }
       }
-    }
-    lines.push('}');
+      lines.push('}');
+    } // close else for non-empty wire interface
 
     files.push({
       path: `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`,
@@ -437,3 +469,139 @@ function renderTypeParams(model: Model, genericDefaults?: Map<string, string>):
   });
   return `<${params.join(', ')}>`;
 }
+
+// ---------------------------------------------------------------------------
+// Shared context — computed once and reused by interface + serializer passes
+// ---------------------------------------------------------------------------
+
+interface SharedModelContext {
+  modelToService: Map<string, string>;
+  resolveDir: (irService: string | undefined) => string;
+  useStringDates: boolean;
+  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 useStringDates = detectStringDateConvention(models, ctx);
+  const genericDefaults = buildGenericModelDefaults(ctx.spec.models);
+  enrichGenericDefaultsFromBaseline(genericDefaults, models, ctx, resolveDir, modelToService);
+  const dedup = buildDeduplicationMap(models, ctx);
+  return { modelToService, resolveDir, useStringDates, dedup, genericDefaults };
+}
+
+// ---------------------------------------------------------------------------
+// Serializer file generation (moved from serializers.ts)
+// ---------------------------------------------------------------------------
+
+/**
+ * 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,
+  shared?: SharedModelContext,
+): GeneratedFile[] {
+  if (models.length === 0) return [];
+
+  const { modelToService, resolveDir, useStringDates, dedup } = shared ?? buildSharedContext(models, ctx);
+  const files: GeneratedFile[] = [];
+  const skippedSerializeModels = new Set<string>();
+
+  for (const model of models) {
+    if (isListMetadataModel(model)) continue;
+    if (isListWrapperModel(model)) continue;
+
+    // Deduplication: for structurally identical models, re-export the canonical serializer
+    const canonicalName = dedup.get(model.name);
+    if (canonicalName) {
+      const service = modelToService.get(model.name);
+      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);
+
+      const canonService = modelToService.get(canonicalName);
+      const canonDir = resolveDir(canonService);
+      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);
+      files.push({
+        path: serializerPath,
+        content: `export { deserialize${canonDomainName} as deserialize${domainName}, serialize${canonDomainName} as serialize${domainName} } from '${rel}';`,
+        overwriteExisting: true,
+      });
+      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);
+    const responseName = wireInterfaceName(domainName);
+    const serializerPath = `src/${dirName}/serializers/${fileName(model.name)}.serializer.ts`;
+    const typeParams = renderSerializerTypeParams(model, ctx);
+    const baselineResponse = ctx.apiSurface?.interfaces?.[responseName];
+    const baselineDomain = ctx.apiSurface?.interfaces?.[domainName];
+
+    const skipFormatFields = buildSkipFormatFields(model, useStringDates, baselineDomain);
+    const shouldSkipSerialize = shouldSkipSerializeForModel(
+      model,
+      baselineResponse,
+      baselineDomain,
+      dedup,
+      skippedSerializeModels,
+      ctx,
+    );
+    if (shouldSkipSerialize) {
+      skippedSerializeModels.add(model.name);
+    }
+
+    const sctx = { modelToService, resolveDir, useStringDates, dedup, skippedSerializeModels, ctx };
+    const lines = [
+      ...buildSerializerImports(model, serializerPath, dirName, domainName, responseName, sctx),
+      ...emitSerializerBody(
+        model,
+        domainName,
+        responseName,
+        typeParams,
+        baselineDomain,
+        baselineResponse,
+        skipFormatFields,
+        shouldSkipSerialize,
+        ctx,
+      ),
+    ];
+
+    files.push({
+      path: serializerPath,
+      content: pruneUnusedImports(lines).join('\n'),
+    });
+  }
+
+  return files;
+}
+
+// ---------------------------------------------------------------------------
+// Combined generation — single shared context, two output streams
+// ---------------------------------------------------------------------------
+
+/**
+ * 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)];
+}