@workos/oagen-emitters 0.14.3 → 0.15.0

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;
+}

package/src/node/index.ts

@@ -23,6 +23,7 @@ import {
   setBaselineSerializedNames,
   setBaselineInterfaceNames,
   setAdoptedModelNames,
+  setDiscriminatedModelNames,
   setStructurallyRenamedDomainNames,
   resolveInterfaceName,
 } from './naming.js';
@@ -341,14 +342,66 @@ function isOwnedPath(relPath: string, policy: LiveSurfacePolicy): boolean {
   return dir !== undefined && policy.ownedServiceDirs.has(dir);
 }
 
+function extractRelativeImportPaths(content: string, fromPath: string): string[] {
+  const dir = path.dirname(fromPath);
+  const paths: string[] = [];
+  const re = /from\s+['"](\.[^'"]+)['"]/g;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(content)) !== null) {
+    paths.push(path.normalize(path.join(dir, match[1])) + '.ts');
+  }
+  return paths;
+}
+
 function applyLiveSurface(files: GeneratedFile[], ctx: EmitterContext, surface: LiveSurface): GeneratedFile[] {
   const out: GeneratedFile[] = [];
   const policy = buildLiveSurfacePolicy(ctx, surface);
+  const filesByPath = new Map(files.map((f) => [f.path, f]));
+  const dependencyAllowedPaths = new Set<string>();
+  const queue: string[] = [];
+
+  for (const f of files) {
+    if (f.integrateTarget === false) continue;
+    if (!canCreateNewPath(f.path, policy)) continue;
+    for (const importPath of extractRelativeImportPaths(f.content, f.path)) {
+      if (
+        filesByPath.has(importPath) &&
+        !canCreateNewPath(importPath, policy) &&
+        !dependencyAllowedPaths.has(importPath)
+      ) {
+        dependencyAllowedPaths.add(importPath);
+        queue.push(importPath);
+      }
+    }
+  }
+
+  while (queue.length > 0) {
+    const relPath = queue.pop()!;
+    const file = filesByPath.get(relPath);
+    if (!file) continue;
+    for (const importPath of extractRelativeImportPaths(file.content, relPath)) {
+      if (
+        filesByPath.has(importPath) &&
+        !canCreateNewPath(importPath, policy) &&
+        !dependencyAllowedPaths.has(importPath)
+      ) {
+        dependencyAllowedPaths.add(importPath);
+        queue.push(importPath);
+      }
+    }
+  }
+
   for (const f of files) {
     const ownedPath = isOwnedPath(f.path, policy);
     if (f.integrateTarget === false) continue;
     if (surface.protectedFiles.has(f.path)) continue;
-    if (policy.hasExistingSdk && !policy.managedPaths.has(f.path) && !canCreateNewPath(f.path, policy)) continue;
+    if (
+      policy.hasExistingSdk &&
+      !policy.managedPaths.has(f.path) &&
+      !canCreateNewPath(f.path, policy) &&
+      !dependencyAllowedPaths.has(f.path)
+    )
+      continue;
 
     // Hand-written files (on disk, no `auto-generated by oagen` header) →
     // drop. The engine would otherwise prepend the header on
@@ -372,7 +425,8 @@ function applyLiveSurface(files: GeneratedFile[], ctx: EmitterContext, surface:
       const dir = topLevelDir(f.path);
       const isAdoptedDir = dir !== undefined && policy.adoptedServiceDirs.has(dir);
       const isManagedDir = ownedPath || isAdoptedDir;
-      if (surface.files.has(f.path) && !surface.autogenFiles.has(f.path)) continue;
+      if (surface.files.has(f.path) && !surface.autogenFiles.has(f.path) && !(ownedPath && policy.regenerateOwnedTests))
+        continue;
       if (!isManagedDir && !surface.autogenFiles.has(f.path)) continue;
       if (isManagedDir && !policy.regenerateOwnedTests) continue;
     }
@@ -487,7 +541,9 @@ export const nodeEmitter: Emitter = {
     // name set on ctx so models.ts skips emitting an interface/serializer —
     // the discriminated module owns those paths instead.
     const discPlans = planDiscriminatedModels(enriched, nodeCtx);
-    (nodeCtx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames = new Set(discPlans.keys());
+    const discriminatedNames = new Set(discPlans.keys());
+    (nodeCtx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames = discriminatedNames;
+    setDiscriminatedModelNames(discriminatedNames);
     const standardFiles = generateModelsAndSerializers(enriched, nodeCtx);
     const discFiles = generateDiscriminatedFiles(discPlans, nodeCtx);
     return applyLiveSurface([...standardFiles, ...discFiles], nodeCtx, surface);

package/src/node/models.ts

@@ -223,6 +223,20 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
   // wrapper's interface importing from a file that was never written.
   const listMetadataNeeded = collectReferencedListMetadataModels(models, nonPaginatedRefs);
 
+  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;
+    const service = modelToService.get(model.name);
+    const isOwnedModel = isNodeOwnedService(ctx, service);
+    if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerate.has(model.name)) continue;
+    const canonicalName = dedup.get(model.name);
+    if (canonicalName) {
+      forceGenerate.add(canonicalName);
+      if (interfaceEligibleModels) interfaceEligibleModels.add(canonicalName);
+    }
+  }
+
   for (const originalModel of models) {
     const model = projectedByName.get(originalModel.name) ?? originalModel;
     if (!reachableModels.has(model.name)) continue;
@@ -392,6 +406,7 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
       const depName = resolveInterfaceName(dep, ctx);
       const depService = modelToService.get(dep);
       const depDir = resolveDir(depService);
+      const depIsOwned = isNodeOwnedService(ctx, depService);
 
       // When the resolver maps the IR name to a different baseline interface
       // (via `overlayLookup.modelNameByIR` structural match), the import
@@ -400,7 +415,9 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
       // 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;
+      const baselineSrc = depIsOwned
+        ? undefined
+        : (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.
@@ -697,6 +714,13 @@ export function generateSerializers(
   const responseReachableModels = resourceUsage
     ? expandModelRoots(resourceUsage.responseRoots, projectedByName)
     : undefined;
+  // Models reachable from any request — only these need a `serialize<X>`.
+  // A model used solely as a response body can safely be deserialize-only;
+  // emitting its serialize half is both unused and brittle when it contains
+  // legacy nested response models that intentionally have no serialize helper.
+  const requestReachableModels = resourceUsage
+    ? expandModelRoots(resourceUsage.requestRoots, projectedByName)
+    : undefined;
 
   const serializerReachable = computeNonEventReachable(ctx.spec.services, models);
 
@@ -759,6 +783,20 @@ export function generateSerializers(
   // Mirror the interface-emission gate (see `generateModels`).
   const serializerListMetadataNeeded = collectReferencedListMetadataModels(models, serializerNonPaginatedRefs);
 
+  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;
+    const service = modelToService.get(model.name);
+    const isOwnedModel = isNodeOwnedService(ctx, service);
+    if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerateSerializer.has(model.name)) continue;
+    const canonicalName = dedup.get(model.name);
+    if (canonicalName) {
+      forceGenerateSerializer.add(canonicalName);
+      if (serializerEligibleModels) serializerEligibleModels.add(canonicalName);
+    }
+  }
+
   const eligibleModels: Model[] = [];
   for (const originalModel of models) {
     const model = projectedByName.get(originalModel.name) ?? originalModel;
@@ -781,14 +819,9 @@ export function generateSerializers(
     const responseName = wireInterfaceName(domainName);
     const baselineResponse = ctx.apiSurface?.interfaces?.[responseName];
     const baselineDomain = ctx.apiSurface?.interfaces?.[domainName];
-    const shouldSkip = shouldSkipSerializeForModel(
-      model,
-      baselineResponse,
-      baselineDomain,
-      dedup,
-      skippedSerializeModels,
-      ctx,
-    );
+    const shouldSkip =
+      (requestReachableModels !== undefined && !requestReachableModels.has(model.name)) ||
+      shouldSkipSerializeForModel(model, baselineResponse, baselineDomain, dedup, skippedSerializeModels, ctx);
     if (shouldSkip) {
       skippedSerializeModels.add(model.name);
     }
@@ -812,27 +845,37 @@ export function generateSerializers(
 
       if (serializerPath === canonSerializerPath) continue;
       if (domainName === canonDomainName) continue;
-      const rel = relativeImport(serializerPath, canonSerializerPath);
-      const canonSkipSerialize = skippedSerializeModels.has(canonicalName) || skippedSerializeModels.has(model.name);
-      const canonSkipDeserialize =
-        responseReachableModels !== undefined &&
-        !responseReachableModels.has(canonicalName) &&
-        !responseReachableModels.has(model.name);
-      if (canonSkipSerialize && canonSkipDeserialize) continue;
-      const parts: string[] = [];
-      if (!canonSkipDeserialize) {
-        parts.push(`deserialize${canonDomainName} as deserialize${domainName}`);
-      }
-      if (!canonSkipSerialize) {
-        parts.push(`serialize${canonDomainName} as serialize${domainName}`);
+
+      const aliasNeedsDeserialize = responseReachableModels === undefined || responseReachableModels.has(model.name);
+      const canonicalHasDeserialize =
+        responseReachableModels === undefined || responseReachableModels.has(canonicalName);
+      const canAliasToCanonical = !aliasNeedsDeserialize || canonicalHasDeserialize;
+      if (canAliasToCanonical) {
+        const rel = relativeImport(serializerPath, canonSerializerPath);
+        const canonSkipSerialize = skippedSerializeModels.has(canonicalName) || skippedSerializeModels.has(model.name);
+        const canonSkipDeserialize =
+          responseReachableModels !== undefined &&
+          !responseReachableModels.has(canonicalName) &&
+          !responseReachableModels.has(model.name);
+        if (canonSkipSerialize && canonSkipDeserialize) continue;
+        const parts: string[] = [];
+        if (!canonSkipDeserialize) {
+          parts.push(`deserialize${canonDomainName} as deserialize${domainName}`);
+        }
+        if (!canonSkipSerialize) {
+          parts.push(`serialize${canonDomainName} as serialize${domainName}`);
+        }
+        const reexportContent = `export { ${parts.join(', ')} } from '${rel}';`;
+        files.push({
+          path: serializerPath,
+          content: reexportContent,
+          overwriteExisting: true,
+        });
+        continue;
       }
-      const reexportContent = `export { ${parts.join(', ')} } from '${rel}';`;
-      files.push({
-        path: serializerPath,
-        content: reexportContent,
-        overwriteExisting: true,
-      });
-      continue;
+      // The alias is response-reachable, but the canonical model is
+      // request-only. Generate a local serializer instead of re-exporting a
+      // deserialize helper that the canonical serializer intentionally omits.
     }
 
     const dirName = resolveDir(service);
@@ -906,7 +949,7 @@ export function generateSerializers(
   }
   const liveRootForBarrel = ctx.outputDir ?? ctx.targetDir;
   for (const [dir, stems] of serializersByDir) {
-    if (liveRootForBarrel) {
+    if (liveRootForBarrel && !isNodeOwnedService(ctx, dir)) {
       const serializersDir = path.join(liveRootForBarrel, 'src', dir, 'serializers');
       try {
         for (const entry of fs.readdirSync(serializersDir)) {

package/src/node/naming.ts

@@ -73,6 +73,16 @@ export function isAdoptedModelName(name: string): boolean {
   return adoptedModelNames.has(name);
 }
 
+/**
+ * IR model names handled by the discriminated-models module. These must not
+ * be remapped by the structural matcher because that module emits files and
+ * helpers under the original IR names.
+ */
+let discriminatedModelNames: Set<string> = new Set();
+export function setDiscriminatedModelNames(names: Set<string>): void {
+  discriminatedModelNames = names;
+}
+
 /**
  * Domain names that `resolveInterfaceName` reached via a structural rename
  * — the resolved name differs from the IR model's own name. `wireInterfaceName`
@@ -226,7 +236,10 @@ export function resolveInterfaceName(name: string, ctx: EmitterContext, opts?: {
   const existing = ctx.overlayLookup?.interfaceByName?.get(name);
   if (existing) return existing;
 
-  let inferred = adoptedModelNames.has(name) ? undefined : ctx.overlayLookup?.modelNameByIR?.get(name);
+  let inferred =
+    adoptedModelNames.has(name) || discriminatedModelNames.has(name)
+      ? undefined
+      : ctx.overlayLookup?.modelNameByIR?.get(name);
   if (inferred) {
     if (inferred.startsWith('Serialized')) {
       const stripped = inferred.slice('Serialized'.length);

package/src/node/node-overrides.ts

@@ -1,41 +1,6 @@
 import type { EmitterContext, Model, ResolvedOperation } from '@workos/oagen';
 import { enrichModelsFromSpec } from '../shared/model-utils.js';
-
-type OperationOverride = {
-  methodName?: string;
-  mountOn?: string;
-};
-
-const OPERATION_OVERRIDES: Record<string, OperationOverride> = {
-  'POST /organizations/{organizationId}/groups': {
-    methodName: 'create_group',
-  },
-  'GET /organizations/{organizationId}/groups': {
-    methodName: 'list_groups',
-  },
-  'GET /organizations/{organizationId}/groups/{groupId}': {
-    methodName: 'get_group',
-  },
-  'PATCH /organizations/{organizationId}/groups/{groupId}': {
-    methodName: 'update_group',
-  },
-  'DELETE /organizations/{organizationId}/groups/{groupId}': {
-    methodName: 'delete_group',
-  },
-  'POST /organizations/{organizationId}/groups/{groupId}/organization-memberships': {
-    methodName: 'add_organization_membership',
-  },
-  'GET /organizations/{organizationId}/groups/{groupId}/organization-memberships': {
-    methodName: 'list_organization_memberships',
-  },
-  'DELETE /organizations/{organizationId}/groups/{groupId}/organization-memberships/{omId}': {
-    methodName: 'remove_organization_membership',
-  },
-  'GET /user_management/organization_memberships/{omId}/groups': {
-    methodName: 'list_groups_for_organization_membership',
-    mountOn: 'UserManagement',
-  },
-};
+import { nodeOptions } from './options.js';
 
 const contextCache = new WeakMap<EmitterContext, EmitterContext>();
 
@@ -88,9 +53,11 @@ export function withNodeOperationOverrides(ctx: EmitterContext): EmitterContext
     return next;
   }
 
+  const configOverrides = nodeOptions(ctx).operationOverrides ?? {};
+
   let opsChanged = false;
   const nextResolved = resolvedOperations.map((resolved) => {
-    const override = OPERATION_OVERRIDES[operationKey(resolved)];
+    const override = configOverrides[operationKey(resolved)];
     if (!override) return resolved;
 
     const methodName = override.methodName ?? resolved.methodName;

package/src/node/options.ts

@@ -1,5 +1,16 @@
 import type { EmitterContext } from '@workos/oagen';
 
+export interface OperationOverride {
+  methodName?: string;
+  mountOn?: string;
+  optionsType?: string;
+  bodyFieldMap?: Record<string, string>;
+  returnType?: string;
+  returnDataProperty?: string;
+  returnTypeImports?: string[];
+  returnExpression?: string;
+}
+
 export interface NodeEmitterOptions {
   /**
    * Existing SDK mode normally drops brand-new paths to avoid large accidental
@@ -21,6 +32,12 @@ export interface NodeEmitterOptions {
    * and fixtures remain hand-owned.
    */
   regenerateOwnedTests?: boolean;
+  /**
+   * Node-specific operation overrides keyed by "METHOD /path".
+   * Allows renaming methods or remounting operations for the Node SDK
+   * without affecting other languages.
+   */
+  operationOverrides?: Record<string, OperationOverride>;
 }
 
 export function nodeOptions(ctx: EmitterContext): NodeEmitterOptions {
@@ -32,10 +49,21 @@ function normalizeServiceName(name: string): string {
   return name.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
 }
 
+function ownedLookupNames(name: string): string[] {
+  const names = [name];
+  const baselineDirPrefix = '__baseline_dir__:';
+  if (name.startsWith(baselineDirPrefix)) {
+    names.push(name.slice(baselineDirPrefix.length));
+  }
+  return names;
+}
+
 export function isNodeOwnedService(ctx: EmitterContext, ...names: Array<string | undefined>): boolean {
   const configured = nodeOptions(ctx).ownedServices ?? [];
   if (configured.length === 0) return false;
 
   const owned = new Set(configured.map(normalizeServiceName));
-  return names.some((name) => name !== undefined && owned.has(normalizeServiceName(name)));
+  return names.some((name) =>
+    name !== undefined ? ownedLookupNames(name).some((candidate) => owned.has(normalizeServiceName(candidate))) : false,
+  );
 }