@workos/oagen-emitters 0.14.4 → 0.15.0

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import { t as workosEmittersPlugin } from "./plugin-BGVaMGqe.mjs";
+import { t as workosEmittersPlugin } from "./plugin-CO4RFgAW.mjs";
 export { workosEmittersPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.14.4",
+  "version": "0.15.0",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -38,22 +38,22 @@
     "prepare": "husky"
   },
   "devDependencies": {
-    "@commitlint/cli": "^21.0.1",
-    "@commitlint/config-conventional": "^21.0.1",
+    "@commitlint/cli": "^21.0.2",
+    "@commitlint/config-conventional": "^21.0.2",
     "@types/node": "^25.9.1",
     "husky": "^9.1.7",
     "oxfmt": "^0.52.0",
     "oxlint": "^1.67.0",
     "prettier": "^3.8.3",
-    "tsdown": "^0.22.0",
-    "tsx": "^4.22.3",
+    "tsdown": "^0.22.1",
+    "tsx": "^4.22.4",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.7"
+    "vitest": "^4.1.8"
   },
   "engines": {
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.21.0"
+    "@workos/oagen": "^0.21.1"
   }
 }

package/renovate.json

@@ -1,66 +1,6 @@
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
   "extends": [
-    "github>workos/renovate-config"
-  ],
-  "dependencyDashboard": false,
-  "schedule": [
-    "on the 15th day of the month before 12pm"
-  ],
-  "timezone": "UTC",
-  "rebaseWhen": "conflicted",
-  "packageRules": [
-    {
-      "matchManagers": [
-        "github-actions"
-      ],
-      "pinDigests": true,
-      "extractVersion": "^v(?<version>\\d+\\.\\d+\\.\\d+)$"
-    },
-    {
-      "matchUpdateTypes": [
-        "minor",
-        "patch"
-      ],
-      "automerge": true,
-      "groupName": "minor and patch updates"
-    },
-    {
-      "matchUpdateTypes": [
-        "major"
-      ],
-      "automerge": false
-    },
-    {
-      "matchUpdateTypes": [
-        "digest"
-      ],
-      "automerge": false
-    },
-    {
-      "matchManagers": [
-        "github-actions"
-      ],
-      "matchUpdateTypes": [
-        "minor",
-        "patch",
-        "digest",
-        "pinDigest"
-      ],
-      "groupName": "github actions non-major",
-      "groupSlug": "github-actions-non-major",
-      "automerge": true
-    },
-    {
-      "matchManagers": [
-        "github-actions"
-      ],
-      "matchUpdateTypes": [
-        "major"
-      ],
-      "groupName": "github actions major",
-      "groupSlug": "github-actions-major",
-      "automerge": false
-    }
+    "github>workos/renovate-config:public"
   ]
 }

package/src/go/client.ts

@@ -17,7 +17,7 @@ export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFil
 }
 
 /**
- * Non-spec services marked with `hasClientAccessor: true` (passwordless, vault)
+ * Non-spec services marked with `hasClientAccessor: true` (e.g. passwordless)
  * are included in the generated Client struct, constructor, and accessor methods
  * — identical to spec-driven services. Their service type (e.g. PasswordlessService)
  * is defined in a hand-written @oagen-ignore-file, but the Client wiring is generated.

package/src/go/enums.ts

@@ -96,6 +96,8 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     content: lines.join('\n'),
     overwriteExisting: true,
   });
+  const eventConstantsFile = generateEventConstantsFile(enums);
+  if (eventConstantsFile) files.push(eventConstantsFile);
 
   return files;
 }
@@ -173,6 +175,81 @@ function collectEnumAliasOf(enums: Enum[]): Map<string, string> {
   return aliasOf;
 }
 
+function generateEventConstantsFile(enums: Enum[]): GeneratedFile | null {
+  const enumDef = findWebhookEventEnum(enums);
+  if (!enumDef) return null;
+
+  const lines: string[] = [];
+  lines.push('package events');
+  lines.push('');
+  lines.push('// Event is a WorkOS event type.');
+  lines.push('type Event string');
+  lines.push('');
+  lines.push('const (');
+
+  const seenValues = new Set<string>();
+  const usedNames = new Set<string>();
+  for (const value of enumDef.values) {
+    const valueStr = String(value.value);
+    if (seenValues.has(valueStr)) continue;
+    seenValues.add(valueStr);
+
+    const constName = uniqueEventConstantName(valueStr, usedNames);
+    usedNames.add(constName);
+
+    if (value.description) {
+      lines.push(`\t// ${constName} is ${value.description}.`);
+    }
+    if (value.deprecated) {
+      if (value.description) lines.push('\t//');
+      lines.push('\t// Deprecated: this value is deprecated.');
+    }
+    // Keep constants untyped so callers can use them as plain strings,
+    // events.Event values, or typed root-package enum values.
+    lines.push(`\t${constName} = "${escapeGoString(valueStr)}"`);
+  }
+
+  lines.push(')');
+  lines.push('');
+
+  return {
+    path: 'pkg/events/events.go',
+    content: lines.join('\n'),
+    overwriteExisting: true,
+  };
+}
+
+function findWebhookEventEnum(enums: Enum[]): Enum | null {
+  return (
+    enums.find((enumDef) => enumDef.name === 'CreateWebhookEndpointEvents') ??
+    enums.find(
+      (enumDef) =>
+        isWebhookEventEnumName(enumDef.name) &&
+        enumDef.values.length > 0 &&
+        enumDef.values.every((value) => typeof value.value === 'string' && value.value.includes('.')),
+    ) ??
+    null
+  );
+}
+
+function isWebhookEventEnumName(name: string): boolean {
+  const normalized = name.toLowerCase();
+  return normalized.includes('webhook') && normalized.includes('event');
+}
+
+function uniqueEventConstantName(value: string, usedNames: Set<string>): string {
+  const base = className(value);
+  if (!usedNames.has(base)) return base;
+
+  let suffix = 2;
+  while (usedNames.has(`${base}${suffix}`)) suffix++;
+  return `${base}${suffix}`;
+}
+
+function escapeGoString(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
 export function assignEnumsToServices(enums: Enum[], services: Service[]): Map<string, string> {
   const enumToService = new Map<string, string>();
   const enumNames = new Set(enums.map((e) => e.name));

package/src/kotlin/enums.ts

@@ -41,12 +41,19 @@ export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFil
 
   // Within each group, pick the shortest className as canonical.
   const aliasOf = new Map<string, string>(); // enum name → canonical enum name
+  const sharedSortEmitters = new Set<string>();
   for (const [, group] of hashGroups) {
-    if (group.length <= 1) continue;
+    if (group.length <= 1) {
+      if (group.length === 1 && isSharedSortOrderEnum(group[0])) {
+        enumCanonicalMap.set(group[0].name, 'SortOrder');
+        sharedSortEmitters.add(group[0].name);
+      }
+      continue;
+    }
     if (group.every(isSharedSortOrderEnum)) {
       const [canonical, ...rest] = [...group].sort((a, b) => a.name.localeCompare(b.name));
-      enumCanonicalMap.set(canonical.name, canonical.name);
-      for (const enumDef of rest) enumCanonicalMap.set(enumDef.name, 'SortOrder');
+      sharedSortEmitters.add(canonical.name);
+      for (const enumDef of [canonical, ...rest]) enumCanonicalMap.set(enumDef.name, 'SortOrder');
       continue;
     }
     const sorted = [...group].sort(
@@ -68,7 +75,7 @@ export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFil
     const typeName = canonicalEnumTypeName(enumDef);
 
     // Non-canonical enum: emit a typealias instead of a full enum class.
-    const sharedSortEmitter = isSharedSortOrderEnum(enumDef) && enumCanonicalMap.get(enumDef.name) === enumDef.name;
+    const sharedSortEmitter = sharedSortEmitters.has(enumDef.name);
     const canonicalName = sharedSortEmitter
       ? undefined
       : (aliasOf.get(enumDef.name) ?? enumCanonicalMap.get(enumDef.name));

package/src/node/client.ts

@@ -18,9 +18,11 @@ import {
   isListWrapperModel,
   computeNonEventReachable,
 } from './utils.js';
+import { isNodeOwnedService, nodeOptions } from './options.js';
 import { resolveResourceClassName, resolveResourceDir } from './resources.js';
 import { generatedResourceInterfaceModelNames } from './models.js';
 import { assignEnumsToServices } from './enums.js';
+import { liveSurfaceInterfacePath } from './live-surface.js';
 
 export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
   const files: GeneratedFile[] = [];
@@ -129,6 +131,46 @@ function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   };
 }
 
+function sourceFileForExportedType(ctx: EmitterContext, typeName: string): string | undefined {
+  return (
+    (ctx.apiSurface?.interfaces?.[typeName] as { sourceFile?: string } | undefined)?.sourceFile ??
+    (ctx.apiSurface?.typeAliases?.[typeName] as { sourceFile?: string } | undefined)?.sourceFile ??
+    (ctx.apiSurface?.enums?.[typeName] as { sourceFile?: string } | undefined)?.sourceFile ??
+    liveSurfaceInterfacePath(typeName)
+  );
+}
+
+function exportedNamesForSource(ctx: EmitterContext, sourceFile: string): string[] {
+  const names = new Set<string>();
+  const addNamesFromSurface = (items: Record<string, unknown> | undefined) => {
+    if (!items) return;
+    for (const [name, item] of Object.entries(items)) {
+      if ((item as { sourceFile?: string }).sourceFile === sourceFile) {
+        names.add(name);
+      }
+    }
+  };
+
+  addNamesFromSurface(ctx.apiSurface?.interfaces);
+  addNamesFromSurface(ctx.apiSurface?.typeAliases);
+  addNamesFromSurface(ctx.apiSurface?.enums);
+
+  const rootDir = ctx.targetDir ?? ctx.outputDir;
+  if (rootDir) {
+    try {
+      const content = fs.readFileSync(path.join(rootDir, sourceFile), 'utf-8');
+      for (const match of content.matchAll(/export\s+(?:interface|type|enum|class|const|function)\s+(\w+)/g)) {
+        names.add(match[1]);
+      }
+    } catch {
+      // The live source map is best-effort; apiSurface/livesurface names above
+      // are enough when the file is not readable.
+    }
+  }
+
+  return [...names];
+}
+
 /**
  * Generate per-service barrel files (interfaces/index.ts) that re-export
  * all interface and enum files for each service directory. This reduces
@@ -146,6 +188,12 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
   // from one file and a domain type from another).
   const dirExports = new Map<string, string[]>();
   const dirSymbols = new Map<string, Set<string>>();
+  const ownedDirNames = new Set<string>();
+  for (const service of spec.services) {
+    if (isNodeOwnedService(ctx, service.name)) {
+      ownedDirNames.add(resolveDir(service.name));
+    }
+  }
 
   // Pre-seed dirSymbols with names already exported by existing interface files.
   // When the existing SDK has an interface file in a directory that already
@@ -160,6 +208,7 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
     const match = sourceFile.match(/^src\/([^/]+)\/interfaces\/(.+)\.ts$/);
     if (!match) return;
     const dirName = match[1];
+    if (ownedDirNames.has(dirName)) return;
     const fileStem = match[2];
     if (!dirSymbols.has(dirName)) dirSymbols.set(dirName, new Set());
     dirSymbols.get(dirName)!.add(name);
@@ -260,14 +309,82 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
     dirExports.get(dirName)!.push(`export * from './${fileName(enumDef.name)}.interface';`);
   }
 
+  const overrideWildcardSources = new Set<string>();
+  const overrideNamedExports = new Set<string>();
+  const addOverrideTypeExport = (typeName: string | undefined) => {
+    if (!typeName) return;
+    const sourceFile = sourceFileForExportedType(ctx, typeName);
+    if (!sourceFile) return;
+    const match = sourceFile?.match(/^src\/([^/]+)\/interfaces\/(.+)\.ts$/);
+    if (!match) return;
+    const dirName = match[1];
+    const stem = match[2].replace(/\.ts$/, '');
+    if (!dirExports.has(dirName)) {
+      dirExports.set(dirName, []);
+      if (!dirSymbols.has(dirName)) {
+        dirSymbols.set(dirName, new Set());
+      }
+    }
+    const symbols = dirSymbols.get(dirName)!;
+    const sourceKey = `${dirName}/${stem}`;
+    if (overrideWildcardSources.has(sourceKey)) return;
+
+    const sourceNames = exportedNamesForSource(ctx, sourceFile);
+    const hasConflictingNeighbor = sourceNames.some((name) => name !== typeName && globalExistingSymbols.has(name));
+    if (hasConflictingNeighbor) {
+      const exportKey = `${sourceKey}:${typeName}`;
+      if (overrideNamedExports.has(exportKey)) return;
+      dirExports.get(dirName)!.push(`export type { ${typeName} } from './${stem}';`);
+      overrideNamedExports.add(exportKey);
+      symbols.add(typeName);
+      globalExistingSymbols.add(typeName);
+      return;
+    }
+
+    dirExports.get(dirName)!.push(`export * from './${stem}';`);
+    overrideWildcardSources.add(sourceKey);
+    const namesToRegister = sourceNames.length > 0 ? sourceNames : [typeName];
+    for (const name of namesToRegister) {
+      symbols.add(name);
+      globalExistingSymbols.add(name);
+    }
+  };
+
+  for (const override of Object.values(nodeOptions(ctx).operationOverrides ?? {})) {
+    addOverrideTypeExport(override.optionsType);
+    for (const typeName of override.returnTypeImports ?? []) {
+      addOverrideTypeExport(typeName);
+    }
+  }
+
+  const generatedOptionExports = (ctx as any)._nodeGeneratedOptionInterfaceExports as
+    | Map<string, Array<{ stem: string; typeName: string }>>
+    | undefined;
+  for (const [dirName, options] of generatedOptionExports ?? []) {
+    if (!dirExports.has(dirName)) {
+      dirExports.set(dirName, []);
+      if (!dirSymbols.has(dirName)) {
+        dirSymbols.set(dirName, new Set());
+      }
+    }
+    const symbols = dirSymbols.get(dirName)!;
+    for (const { stem, typeName } of options) {
+      if (globalExistingSymbols.has(typeName)) continue;
+      symbols.add(typeName);
+      globalExistingSymbols.add(typeName);
+      dirExports.get(dirName)!.push(`export * from './${stem}';`);
+    }
+  }
+
   for (const [dirName, exports] of dirExports) {
     const exportSet = new Set(exports);
+    const isDirOwned = ownedDirNames.has(dirName);
 
     // When integrating into an existing SDK, include baseline exports from
     // the api-surface so the barrel is comprehensive.  This ensures stale
     // entries (e.g., renamed files from previous generations) are removed
     // when overwriteExisting replaces the barrel.
-    if (ctx.apiSurface) {
+    if (ctx.apiSurface && !isDirOwned) {
       const addBaselineExports = (items: Record<string, any> | undefined) => {
         if (!items) return;
         for (const item of Object.values(items)) {
@@ -288,7 +405,7 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
       // corresponding file still exists on disk.  This prevents dropping
       // hand-written types (e.g., Factor in multi-factor-auth) when a
       // generated model in the same file causes a symbol collision.
-      if (ctx.targetDir) {
+      if (ctx.targetDir && !isDirOwned) {
         const interfacesDir = path.join(ctx.targetDir, 'src', dirName, 'interfaces');
         try {
           const barrelPath = path.join(interfacesDir, 'index.ts');

package/src/node/discriminated-models.ts

@@ -69,6 +69,8 @@ interface DiscriminatedShape {
   discriminatorProperty: string;
   /** Field name in domain (camelCase). */
   discriminatorPropertyDomain: string;
+  /** Description from the OpenAPI spec, if present. */
+  discriminatorDescription?: string;
   variants: VariantSpec[];
 }
 
@@ -133,11 +135,14 @@ export function detectDiscriminatedShape(
 
   const baseFields = baseObject ? collectObjectFields(baseObject, modelName) : [];
 
+  const discriminatorDescription = flattenedVariants[0].alwaysProperties.get(discProp)?.description;
+
   return {
     modelName,
     baseFields,
     discriminatorProperty: discProp,
     discriminatorPropertyDomain: toCamelCase(discProp),
+    discriminatorDescription,
     variants,
   };
 }
@@ -527,6 +532,9 @@ function buildInterfaceBody(name: string, shape: DiscriminatedShape, variant: Va
   }
   // Discriminator (typed as the variant's const value)
   const discKey = isWire ? shape.discriminatorProperty : shape.discriminatorPropertyDomain;
+  if (shape.discriminatorDescription) {
+    lines.push(`  /** ${shape.discriminatorDescription} */`);
+  }
   lines.push(`  ${discKey}: '${variant.discriminatorValue}';`);
   // Variant-specific fields
   for (const field of variant.fields) {

package/src/node/field-plan.ts

@@ -7,8 +7,15 @@ import {
   isBaselineGeneric,
   createServiceDirResolver,
   modelHasNewFields,
+  assignModelsToServices,
 } from './utils.js';
-import { liveSurfaceHasFunction, liveSurfaceHasFile, liveSurfaceFunctionPath } from './live-surface.js';
+import {
+  liveSurfaceHasFunction,
+  liveSurfaceHasFile,
+  liveSurfaceFunctionPath,
+  liveSurfaceHasAutogenFile,
+} from './live-surface.js';
+import { isNodeOwnedService } from './options.js';
 
 // ---------------------------------------------------------------------------
 // Guard strategy
@@ -51,6 +58,19 @@ function helperExists(helperName: string, depModelName: string, ctx: EmitterCont
   if (liveSurfaceHasFunction(helperName)) return true;
   const depModel = ctx.spec.models.find((m) => m.name === depModelName);
   if (!depModel) return false;
+  const modelToService = assignModelsToServices(ctx.spec.models, ctx.spec.services, ctx.modelHints);
+  const depService = modelToService.get(depModelName);
+  const resolvedName = resolveInterfaceName(depModelName, ctx);
+  const siblingPrefix = helperName.startsWith('serialize') ? 'deserialize' : 'serialize';
+  const siblingPath = liveSurfaceFunctionPath(`${siblingPrefix}${resolvedName}`);
+  if (siblingPath && liveSurfaceHasFile(siblingPath) && !liveSurfaceHasAutogenFile(siblingPath)) return false;
+  const sourceFile = (ctx.apiSurface?.interfaces?.[resolvedName] as { sourceFile?: string } | undefined)?.sourceFile;
+  const { resolveDir } = createServiceDirResolver(ctx.spec.models, ctx.spec.services, ctx);
+  const candidate = sourceFile
+    ? sourceFile.replace('/interfaces/', '/serializers/').replace('.interface.ts', '.serializer.ts')
+    : `src/${resolveDir(depService)}/serializers/${fileName(depModelName)}.serializer.ts`;
+  if (liveSurfaceHasFile(candidate) && !liveSurfaceHasAutogenFile(candidate)) return false;
+  if (isNodeOwnedService(ctx, depService)) return true;
   return modelHasNewFields(depModel, ctx);
 }
 
@@ -699,6 +719,7 @@ export function buildSerializerImports(
     const depService = sctx.modelToService.get(dep);
     const depDir = sctx.resolveDir(depService);
     const depName = resolveInterfaceName(dep, sctx.ctx);
+    const depIsOwned = isNodeOwnedService(sctx.ctx, depService);
 
     // Locate the serializer file, in priority order:
     //   1. The actual file containing `deserialize${depName}` per
@@ -708,14 +729,16 @@ export function buildSerializerImports(
     //   2. The baseline interface's adjacent serializer file path.
     //   3. The IR-name path — this is where the emitter writes the
     //      serializer it's producing this run.
-    const baselineSrc = (sctx.ctx.apiSurface?.interfaces?.[depName] as { sourceFile?: string } | undefined)?.sourceFile;
+    const baselineSrc = depIsOwned
+      ? undefined
+      : (sctx.ctx.apiSurface?.interfaces?.[depName] as { sourceFile?: string } | undefined)?.sourceFile;
     const baselineSerializerPath = baselineSrc
       ? baselineSrc.replace('/interfaces/', '/serializers/').replace('.interface.ts', '.serializer.ts')
       : null;
     const irNameSerializerPath = `src/${depDir}/serializers/${fileName(dep)}.serializer.ts`;
 
-    const liveDeserPath = liveSurfaceFunctionPath(`deserialize${depName}`);
-    const liveSerPath = liveSurfaceFunctionPath(`serialize${depName}`);
+    const liveDeserPath = depIsOwned ? undefined : liveSurfaceFunctionPath(`deserialize${depName}`);
+    const liveSerPath = depIsOwned ? undefined : liveSurfaceFunctionPath(`serialize${depName}`);
     const depSerializerPath =
       liveDeserPath ??
       liveSerPath ??
@@ -742,11 +765,11 @@ export function buildSerializerImports(
     // pass-through expression when it can't call the helper.
     const hasDeser = liveSurfaceHasFunction(`deserialize${depName}`);
     const hasSer = liveSurfaceHasFunction(`serialize${depName}`);
-    const fileExists = liveSurfaceHasFile(depSerializerPath);
+    const fileExists = !depIsOwned && liveSurfaceHasFile(depSerializerPath);
     if (fileExists && !hasDeser && !hasSer) continue;
     if (!fileExists) {
       const depModel = sctx.ctx.spec.models.find((m) => m.name === dep);
-      const willGenerateSerializer = depModel ? modelHasNewFields(depModel, sctx.ctx) : true;
+      const willGenerateSerializer = depModel ? depIsOwned || modelHasNewFields(depModel, sctx.ctx) : true;
       if (!willGenerateSerializer) continue;
     }
 
@@ -803,7 +826,9 @@ export function shouldSkipSerializeForModel(
   skippedSerializeModels: Set<string>,
   ctx: EmitterContext,
 ): boolean {
-  let shouldSkip = serializerHasBaselineIncompatibility(model, baselineResponse, baselineDomain, ctx);
+  let shouldSkip =
+    serializerHasBaselineIncompatibility(model, baselineResponse, baselineDomain, ctx) ||
+    hasUnsafeSerializePassthrough(model, baselineDomain, baselineResponse, ctx);
   if (!shouldSkip) {
     for (const field of model.fields) {
       for (const ref of collectSerializedModelRefs(field.type)) {
@@ -816,6 +841,11 @@ export function shouldSkipSerializeForModel(
           shouldSkip = true;
           break;
         }
+        const resolved = resolveInterfaceName(ref, ctx);
+        if (wireInterfaceName(resolved) !== resolved && !helperExists(`serialize${resolved}`, ref, ctx)) {
+          shouldSkip = true;
+          break;
+        }
       }
       if (shouldSkip) break;
     }
@@ -836,6 +866,8 @@ export function emitSerializerBody(
   ctx: EmitterContext,
 ): string[] {
   const lines: string[] = [];
+  const effectiveShouldSkipSerialize =
+    shouldSkipSerialize || hasUnsafeSerializePassthrough(model, baselineDomain, baselineResponse, ctx);
 
   if (!shouldSkipDeserialize) {
     const seenDeserFields = new Set<string>();
@@ -853,7 +885,7 @@ export function emitSerializerBody(
     lines.push('});');
   }
 
-  if (!shouldSkipSerialize) {
+  if (!effectiveShouldSkipSerialize) {
     if (!shouldSkipDeserialize) lines.push('');
     const serParamPrefix = model.fields.length === 0 ? '_' : '';
     lines.push(`export const serialize${domainName} = ${typeParams.decl}(`);
@@ -872,3 +904,27 @@ export function emitSerializerBody(
 
   return lines;
 }
+
+function hasUnsafeSerializePassthrough(
+  model: Model,
+  baselineDomain: BaselineInterface | undefined,
+  baselineResponse: BaselineInterface | undefined,
+  ctx: EmitterContext,
+): boolean {
+  if (!baselineDomain?.fields || !baselineResponse?.fields) return false;
+
+  for (const field of model.fields) {
+    const domain = fieldName(field.name);
+    const wire = wireFieldName(field.name);
+    const domainField = baselineDomain.fields[domain];
+    const wireField = baselineResponse.fields[wire];
+    if (!domainField || !wireField || domainField.type === wireField.type) continue;
+
+    const domainAccess = `model.${domain}`;
+    if (serializeExpression(field.type, domainAccess, ctx) === domainAccess) {
+      return true;
+    }
+  }
+
+  return false;
+}