@workos/oagen-emitters 0.18.4 → 0.19.0

package/dist/plugin.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.18.4",
+  "version": "0.19.0",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -42,8 +42,8 @@
     "@commitlint/config-conventional": "^21.0.2",
     "@types/node": "^26.0.0",
     "husky": "^9.1.7",
-    "oxfmt": "^0.55.0",
-    "oxlint": "^1.70.0",
+    "oxfmt": "^0.56.0",
+    "oxlint": "^1.71.0",
     "prettier": "^3.8.4",
     "tsdown": "^0.22.3",
     "tsx": "^4.22.4",
@@ -54,6 +54,6 @@
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.22.7"
+    "@workos/oagen": "^0.23.0"
   }
 }

package/src/dotnet/enums.ts

@@ -3,6 +3,7 @@ import { walkTypeRef } from '@workos/oagen';
 import { className, deprecationMessage, escapeCsAttributeString, humanize } from './naming.js';
 import { setEnumAliases, setSingleValueEnumNames } from './type-map.js';
 import { enrichModelsFromSpec } from '../shared/model-utils.js';
+import { isEnumInScope } from '../shared/resolved-ops.js';
 
 /**
  * Generate C# enum definitions from IR Enum definitions.
@@ -135,11 +136,16 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     lines.push('    }');
     lines.push('}');
 
-    files.push({
-      path: `Enums/${typeName}.cs`,
-      content: lines.join('\n'),
-      overwriteExisting: true,
-    });
+    // FR-1.4: write the per-enum FILE only when in scope. .NET uses a flat
+    // Enums/ directory with C# namespaces (no barrel/index), so an
+    // out-of-scope enum left untouched on disk stays referenceable.
+    if (isEnumInScope(enumDef.name, ctx)) {
+      files.push({
+        path: `Enums/${typeName}.cs`,
+        content: lines.join('\n'),
+        overwriteExisting: true,
+      });
+    }
   }
 
   return files;

package/src/dotnet/models.ts

@@ -26,6 +26,7 @@ import {
   isListMetadataModel,
   collectNonPaginatedResponseModelNames,
 } from '../shared/model-utils.js';
+import { isModelInScope } from '../shared/resolved-ops.js';
 export { isListWrapperModel, isListMetadataModel };
 
 /**
@@ -355,11 +356,16 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
     lines.push('    }');
     lines.push('}');
 
-    files.push({
-      path: `Entities/${csClassName}.cs`,
-      content: lines.join('\n'),
-      overwriteExisting: true,
-    });
+    // FR-1.4: write the per-model FILE only when in scope. .NET uses a flat
+    // Entities/ directory with C# namespaces (no barrel/index), so an
+    // out-of-scope model left untouched on disk stays referenceable.
+    if (isModelInScope(model.name, ctx)) {
+      files.push({
+        path: `Entities/${csClassName}.cs`,
+        content: lines.join('\n'),
+        overwriteExisting: true,
+      });
+    }
   }
 
   return files;

package/src/dotnet/resources.ts

@@ -35,7 +35,7 @@ import {
 import {
   buildResolvedLookup,
   lookupResolved,
-  groupByMount,
+  scopedMountGroups,
   getOpDefaults,
   getOpInferFromClient,
   buildHiddenParams,
@@ -71,10 +71,10 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
   if (services.length === 0) return [];
 
   const files: GeneratedFile[] = [];
-  const mountGroups = groupByMount(ctx);
+  const mountGroups = scopedMountGroups(ctx);
 
   const entries: Array<{ name: string; operations: Operation[] }> =
-    mountGroups.size > 0
+    mountGroups.size > 0 || ctx.scopedServices?.size
       ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
       : services.map((s) => ({ name: resolveResourceClassName(s, ctx), operations: s.operations }));
 

package/src/dotnet/tests.ts

@@ -16,7 +16,7 @@ import { resolveResourceClassName, sortPathParamsByTemplateOrder, optionsClassNa
 import { generateFixtures, generateModelFixture } from './fixtures.js';
 import { isListWrapperModel } from './models.js';
 import {
-  groupByMount,
+  scopedMountGroups,
   buildResolvedLookup,
   lookupResolved,
   buildHiddenParams,
@@ -40,9 +40,9 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   }
 
   // Generate per-mount-target test files
-  const mountGroups = groupByMount(ctx);
+  const mountGroups = scopedMountGroups(ctx);
   const testEntries: Array<{ name: string; operations: Operation[] }> =
-    mountGroups.size > 0
+    mountGroups.size > 0 || ctx.scopedServices?.size
       ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
       : spec.services.map((s) => ({
           name: resolveResourceClassName(s, ctx),

package/src/go/resources.ts

@@ -21,7 +21,7 @@ import {
 import {
   buildResolvedLookup,
   lookupResolved,
-  groupByMount,
+  scopedMountGroups,
   getOpDefaults,
   getOpInferFromClient,
   buildHiddenParams,
@@ -60,11 +60,11 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
   if (services.length === 0) return [];
 
   const files: GeneratedFile[] = [];
-  const mountGroups = groupByMount(ctx);
+  const mountGroups = scopedMountGroups(ctx);
 
   // If no resolved operations, fall back to raw services
   const entries: Array<{ name: string; operations: Operation[] }> =
-    mountGroups.size > 0
+    mountGroups.size > 0 || ctx.scopedServices?.size
       ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
       : services.map((s) => ({ name: resolveResourceClassName(s, ctx), operations: s.operations }));
 

package/src/go/tests.ts

@@ -5,7 +5,7 @@ import { resolveResourceClassName, paramsStructName, sortPathParamsByTemplateOrd
 import { buildServiceAccessPaths } from './client.js';
 import { generateFixtures } from './fixtures.js';
 import { isListWrapperModel } from './models.js';
-import { groupByMount, buildResolvedLookup, lookupResolved, buildHiddenParams } from '../shared/resolved-ops.js';
+import { scopedMountGroups, buildResolvedLookup, lookupResolved, buildHiddenParams } from '../shared/resolved-ops.js';
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 
@@ -85,9 +85,9 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   const accessPaths = buildServiceAccessPaths(spec.services, ctx);
 
   // Generate per-mount-target test files
-  const mountGroups = groupByMount(ctx);
+  const mountGroups = scopedMountGroups(ctx);
   const testEntries: Array<{ name: string; operations: Operation[] }> =
-    mountGroups.size > 0
+    mountGroups.size > 0 || ctx.scopedServices?.size
       ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
       : spec.services.map((s) => ({
           name: resolveResourceClassName(s, ctx),

package/src/kotlin/enums.ts

@@ -1,5 +1,6 @@
 import type { Enum, EmitterContext, GeneratedFile } from '@workos/oagen';
 import { className, ktStringLiteral } from './naming.js';
+import { isEnumInScope } from '../shared/resolved-ops.js';
 
 const KOTLIN_SRC_PREFIX = 'src/main/kotlin/';
 const ENUMS_PACKAGE = 'com.workos.types';
@@ -24,7 +25,7 @@ export const enumCanonicalMap = new Map<string, string>();
  * shortest PascalCase name becomes canonical and the rest emit `typealias`
  * files pointing at the canonical class.
  */
-export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFile[] {
+export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
   if (enums.length === 0) return [];
 
   // Reset the canonical map on every generation run (guards against re-entry).
@@ -74,6 +75,11 @@ export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFil
 
     const typeName = canonicalEnumTypeName(enumDef);
 
+    // FR-1.4: write per-enum FILES only when in scope. Each enum is its own
+    // `.kt` file (no barrel), so an out-of-scope enum left untouched on disk
+    // stays importable.
+    const enumInScope = isEnumInScope(enumDef.name, ctx);
+
     // Non-canonical enum: emit a typealias instead of a full enum class.
     const sharedSortEmitter = sharedSortEmitters.has(enumDef.name);
     const canonicalName = sharedSortEmitter
@@ -94,11 +100,13 @@ export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFil
         aliasLine,
         '',
       ].join('\n');
-      files.push({
-        path: `${KOTLIN_SRC_PREFIX}${ENUMS_DIR}/${typeName}.kt`,
-        content: aliasContent,
-        overwriteExisting: true,
-      });
+      if (enumInScope) {
+        files.push({
+          path: `${KOTLIN_SRC_PREFIX}${ENUMS_DIR}/${typeName}.kt`,
+          content: aliasContent,
+          overwriteExisting: true,
+        });
+      }
       continue;
     }
 
@@ -175,11 +183,13 @@ export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFil
     lines.push('}');
     lines.push('');
 
-    files.push({
-      path: `${KOTLIN_SRC_PREFIX}${ENUMS_DIR}/${typeName}.kt`,
-      content: lines.join('\n'),
-      overwriteExisting: true,
-    });
+    if (enumInScope) {
+      files.push({
+        path: `${KOTLIN_SRC_PREFIX}${ENUMS_DIR}/${typeName}.kt`,
+        content: lines.join('\n'),
+        overwriteExisting: true,
+      });
+    }
   }
 
   return files;

package/src/kotlin/models.ts

@@ -8,6 +8,7 @@ import {
   collectNonPaginatedResponseModelNames,
   collectReferencedListMetadataModels,
 } from '../shared/model-utils.js';
+import { isModelInScope } from '../shared/resolved-ops.js';
 
 const KOTLIN_SRC_PREFIX = 'src/main/kotlin/';
 const MODELS_PACKAGE = 'com.workos.models';
@@ -123,10 +124,17 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   for (const model of models) {
     if (skipAsListWrapper(model) || skipAsListMetadata(model)) continue;
     const typeName = className(model.name);
+    // FR-1.4: write per-model FILES only when in scope. Each model is its own
+    // `.kt` file (no barrel), so an out-of-scope model left untouched on disk
+    // stays importable. The WorkOSEvent sealed interface below is an aggregate
+    // built from many event models, so it is NOT gated.
+    const modelInScope = isModelInScope(model.name, ctx);
 
     // Parent of a discriminated union: emit a sealed class.
     if (model.fields.length === 0 && discriminatedUnions.has(typeName)) {
-      files.push(emitSealedUnion(typeName, discriminatedUnions.get(typeName)!));
+      if (modelInScope) {
+        files.push(emitSealedUnion(typeName, discriminatedUnions.get(typeName)!));
+      }
       continue;
     }
 
@@ -142,15 +150,19 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
         `typealias ${typeName} = ${canonicalType}`,
         '',
       ].join('\n');
-      files.push({
-        path: `${KOTLIN_SRC_PREFIX}${MODELS_DIR}/${typeName}.kt`,
-        content: aliasContent,
-        overwriteExisting: true,
-      });
+      if (modelInScope) {
+        files.push({
+          path: `${KOTLIN_SRC_PREFIX}${MODELS_DIR}/${typeName}.kt`,
+          content: aliasContent,
+          overwriteExisting: true,
+        });
+      }
       continue;
     }
 
-    files.push(emitDataClass(model));
+    if (modelInScope) {
+      files.push(emitDataClass(model));
+    }
   }
 
   // Generate the sealed WorkOSEvent interface. Collect all event envelope

package/src/kotlin/resources.ts

@@ -34,7 +34,7 @@ import {
 import {
   buildResolvedLookup,
   lookupResolved,
-  groupByMount,
+  scopedMountGroups,
   buildHiddenParams,
   getOpDefaults,
   getOpInferFromClient,
@@ -97,7 +97,7 @@ function promoteFieldType(f: Field): Field {
 export function generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {
   if (services.length === 0) return [];
 
-  const mountGroups = groupByMount(ctx);
+  const mountGroups = scopedMountGroups(ctx);
   if (mountGroups.size === 0) return [];
 
   const files: GeneratedFile[] = [];

package/src/kotlin/tests.ts

@@ -22,7 +22,7 @@ import {
 } from './naming.js';
 import { mapTypeRef } from './type-map.js';
 import {
-  groupByMount,
+  scopedMountGroups,
   lookupResolved,
   buildResolvedLookup,
   buildHiddenParams,
@@ -76,7 +76,7 @@ function promoteIso8601TypeRef(type: TypeRef, description: string | undefined):
  */
 export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
   const files: GeneratedFile[] = [];
-  const mountGroups = groupByMount(ctx);
+  const mountGroups = scopedMountGroups(ctx);
   const resolvedLookup = buildResolvedLookup(ctx);
 
   const exportedClasses = buildExportedClassNameSet(ctx);

package/src/node/enums.ts

@@ -5,6 +5,7 @@ import { docComment, assignModelsToEmittableServices } from './utils.js';
 import { isInlineEnum } from './type-map.js';
 import { isNodeOwnedService } from './options.js';
 import { liveSurfaceConstEnumMembers, liveSurfaceInterfacePath } from './live-surface.js';
+import { isEnumInScope } from '../shared/resolved-ops.js';
 
 export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
   if (enums.length === 0) return [];
@@ -120,11 +121,13 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
       lines.push(`  (typeof ${enumDef.name})[keyof typeof ${enumDef.name}];`);
     }
 
-    files.push({
-      path: `src/${dirName}/interfaces/${fileName(enumDef.name)}.interface.ts`,
-      content: lines.join('\n'),
-      skipIfExists: !hasNewValues,
-    });
+    if (isEnumInScope(enumDef.name, ctx)) {
+      files.push({
+        path: `src/${dirName}/interfaces/${fileName(enumDef.name)}.interface.ts`,
+        content: lines.join('\n'),
+        skipIfExists: !hasNewValues,
+      });
+    }
   }
 
   return files;

package/src/node/models.ts

@@ -45,7 +45,7 @@ import {
 import { liveSurfaceHasExistingSdk, liveSurfaceHasManagedFile, liveSurfaceInterfacePath } from './live-surface.js';
 import { isNodeOwnedService, isHandOwnedType } from './options.js';
 import { unwrapListModel } from './fixtures.js';
-import { groupByMount, buildResolvedLookup, lookupResolved } from '../shared/resolved-ops.js';
+import { groupByMount, buildResolvedLookup, lookupResolved, isModelInScope } from '../shared/resolved-ops.js';
 import { resolveWrapperParams } from '../shared/wrapper-utils.js';
 import { collectWrapperResponseModels } from './wrappers.js';
 import { resolveResourceClassName } from './resources.js';
@@ -308,11 +308,13 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
       const aliasLines = importSymbols
         ? [`import type { ${importSymbols} } from '${canonRelPath}';`, '', ...aliasExports]
         : [...aliasExports];
-      files.push({
-        path: aliasPath,
-        content: aliasLines.join('\n'),
-        overwriteExisting: true,
-      });
+      if (isModelInScope(model.name, ctx)) {
+        files.push({
+          path: aliasPath,
+          content: aliasLines.join('\n'),
+          overwriteExisting: true,
+        });
+      }
       continue;
     }
 
@@ -745,11 +747,13 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
       }
     }
 
-    files.push({
-      path: filePath,
-      content: pruneUnusedImports(lines).join('\n'),
-      overwriteExisting: true,
-    });
+    if (isModelInScope(model.name, ctx)) {
+      files.push({
+        path: filePath,
+        content: pruneUnusedImports(lines).join('\n'),
+        overwriteExisting: true,
+      });
+    }
   }
 
   return files;
@@ -943,11 +947,13 @@ export function generateSerializers(
           parts.push(`serialize${canonDomainName} as serialize${domainName}`);
         }
         const reexportContent = `export { ${parts.join(', ')} } from '${rel}';`;
-        files.push({
-          path: serializerPath,
-          content: reexportContent,
-          overwriteExisting: true,
-        });
+        if (isModelInScope(model.name, ctx)) {
+          files.push({
+            path: serializerPath,
+            content: reexportContent,
+            overwriteExisting: true,
+          });
+        }
         continue;
       }
       // The alias is response-reachable, but the canonical model is
@@ -997,11 +1003,13 @@ export function generateSerializers(
       ),
     ];
 
-    files.push({
-      path: serializerPath,
-      content: pruneUnusedImports(lines).join('\n'),
-      overwriteExisting: true,
-    });
+    if (isModelInScope(model.name, ctx)) {
+      files.push({
+        path: serializerPath,
+        content: pruneUnusedImports(lines).join('\n'),
+        overwriteExisting: true,
+      });
+    }
   }
 
   (ctx as any)._skippedSerializeModels = skippedSerializeModels;

package/src/node/resources.ts

@@ -78,6 +78,7 @@ import {
   buildResolvedLookup,
   lookupResolved,
   groupByMount,
+  isMountInScope,
   getOpDefaults,
   getOpInferFromClient,
 } from '../shared/resolved-ops.js';
@@ -718,11 +719,18 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
   // multiple IR services mount to the same resource class.
   const mountGroups = groupByMount(ctx);
   const mergedServices: Service[] =
-    mountGroups.size > 0 ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations })) : services;
+    mountGroups.size > 0 || ctx.scopedServices?.size
+      ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
+      : services;
 
   const topLevelEnumNames = new Set(ctx.spec.enums.map((e) => e.name));
 
   for (const service of mergedServices) {
+    // Scope gate: in a scoped (`--services`) run, only emit per-service resource
+    // files for the selected post-mount names. `service.name` is the mount-group
+    // key (the POST-MOUNT name that matches `ctx.scopedServices`). Applied as an
+    // additional early continue ahead of the node-owned/coverage skip logic.
+    if (!isMountInScope(service.name, ctx)) continue;
     const isOwnedService = isNodeOwnedService(ctx, service.name, resolveResourceClassName(service, ctx));
     if (!isOwnedService && isServiceCoveredByExisting(service, ctx)) {
       if (!hasMethodsAbsentFromBaseline(service, ctx)) {
@@ -770,6 +778,9 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
   // stable.  Placing them under `interfaces/` lets the per-service barrel
   // pick them up automatically.
   for (const service of mergedServices) {
+    // Scope gate: keep the per-service options interfaces aligned with the
+    // resource files emitted above — only the selected post-mount names.
+    if (!isMountInScope(service.name, ctx)) continue;
     const isOwnedService = isNodeOwnedService(ctx, service.name, resolveResourceClassName(service, ctx));
     if (!isOwnedService && isServiceCoveredByExisting(service, ctx) && !hasMethodsAbsentFromBaseline(service, ctx))
       continue;

package/src/node/tests.ts

@@ -35,7 +35,7 @@ import {
   modelHasNewFields,
   computeNonEventReachable,
 } from './utils.js';
-import { groupByMount, buildResolvedLookup, lookupResolved } from '../shared/resolved-ops.js';
+import { groupByMount, buildResolvedLookup, lookupResolved, isMountInScope } from '../shared/resolved-ops.js';
 import { isNodeOwnedService, nodeOptions, planOperationFor } from './options.js';
 
 type BaselineMethod = {
@@ -137,7 +137,7 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   }
 
   const testEntries: Array<{ name: string; operations: Operation[] }> =
-    mountGroups.size > 0
+    mountGroups.size > 0 || ctx.scopedServices?.size
       ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
       : spec.services.map((s) => ({ name: resolveResourceClassName(s, ctx), operations: s.operations }));
 
@@ -159,6 +159,11 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   }
 
   for (const { name: mountName, operations } of testEntries) {
+    // Scope gate: in a scoped (`--services`) run, only emit per-service test
+    // files for the selected post-mount names. `mountName` is the mount-group
+    // key (the POST-MOUNT name that matches `ctx.scopedServices`). Applied as an
+    // additional early continue ahead of the node-owned/coverage skip logic.
+    if (!isMountInScope(mountName, ctx)) continue;
     if (operations.length === 0) continue;
     const mergedService: Service = { name: mountName, operations };
     const isOwnedService = isNodeOwnedService(ctx, mountName, resolveResourceClassName(mergedService, ctx));

package/src/php/enums.ts

@@ -2,6 +2,7 @@ import type { Enum, EmitterContext, GeneratedFile } from '@workos/oagen';
 import { toPascalCase } from '@workos/oagen';
 import { className, resolveEnumName } from './naming.js';
 import { phpDocComment } from './utils.js';
+import { isEnumInScope } from '../shared/resolved-ops.js';
 
 /**
  * Generate PHP enum files from IR enums.
@@ -17,6 +18,16 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     if (emittedCanonical.has(canonical)) continue; // skip aliases
     emittedCanonical.add(canonical);
 
+    // FR-1.4: write the per-enum FILE only when in scope. PHP dedupes
+    // value-identical enums onto a single canonical class, so the canonical
+    // file is needed when EITHER the canonical name OR any alias resolving to
+    // it is reachable from the selected services. PSR-4 (one class per file
+    // under lib/Resource/, no barrel) means an out-of-scope enum is simply
+    // left untouched on disk and stays loadable.
+    const enumInScope = enums.some(
+      (other) => resolveEnumName(other.name) === canonical && isEnumInScope(other.name, ctx),
+    );
+
     const name = className(canonical);
     const _isAllStrings = e.values.every((v) => typeof v.value === 'string');
     const isAllInts = e.values.every((v) => typeof v.value === 'number' && Number.isInteger(v.value));
@@ -56,11 +67,13 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
 
     lines.push('}');
 
-    files.push({
-      path: `lib/Resource/${name}.php`,
-      content: lines.join('\n'),
-      overwriteExisting: true,
-    });
+    if (enumInScope) {
+      files.push({
+        path: `lib/Resource/${name}.php`,
+        content: lines.join('\n'),
+        overwriteExisting: true,
+      });
+    }
   }
 
   return files;

package/src/php/index.ts

@@ -42,9 +42,17 @@ function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
  * classes (no sum types), so a discriminated base whose IR fields the
  * parser stripped (post-allOf-aware detection) gets its original fields
  * restored to avoid silently dropping variant data.
+ *
+ * `enums` is forwarded to seed `enrichModelsFromSpec`'s collision set: an
+ * inline oneOf enum whose synthetic name (`Parent_field`) snake-collapses
+ * onto an existing IR enum (e.g. `DataIntegrationAccessTokenResponse_error`
+ * vs `DataIntegrationAccessTokenResponseError`) must NOT spawn a duplicate
+ * synthetic. Otherwise both collapse to the same `lib/Resource/X.php` path
+ * and the later writer wins by array order — which differs between a full
+ * and a scoped (`--services`) run, producing a non-deterministic case order.
  */
-function enrichModelsForPhp(models: Model[]): Model[] {
-  const enriched = enrichModelsFromSpec(models);
+function enrichModelsForPhp(models: Model[], enums: Enum[]): Model[] {
+  const enriched = enrichModelsFromSpec(models, enums);
   const originalByName = new Map(models.map((m) => [m.name, m]));
   return enriched.map((m) => {
     if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
@@ -62,7 +70,7 @@ export const phpEmitter: Emitter = {
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
     ensureNamingInitialized(ctx);
-    return ensureTrailingNewlines(generateModels(enrichModelsForPhp(models), ctx));
+    return ensureTrailingNewlines(generateModels(enrichModelsForPhp(models, ctx.spec.enums), ctx));
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {

package/src/php/models.ts

@@ -10,6 +10,7 @@ import {
   collectNonPaginatedResponseModelNames,
   collectReferencedListMetadataModels,
 } from '../shared/model-utils.js';
+import { isModelInScope } from '../shared/resolved-ops.js';
 export { isListMetadataModel, isListWrapperModel };
 
 /**
@@ -140,11 +141,16 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
 
     lines.push('}');
 
-    files.push({
-      path: `lib/Resource/${name}.php`,
-      content: lines.join('\n'),
-      overwriteExisting: true,
-    });
+    // FR-1.4: write the per-model FILE only when in scope. PHP uses PSR-4
+    // (one class per file under lib/Resource/, no barrel/index), so an
+    // out-of-scope model is simply left untouched on disk and stays loadable.
+    if (isModelInScope(model.name, ctx)) {
+      files.push({
+        path: `lib/Resource/${name}.php`,
+        content: lines.join('\n'),
+        overwriteExisting: true,
+      });
+    }
   }
 
   return files;

package/src/php/resources.ts

@@ -12,7 +12,7 @@ import { mapTypeRef, mapTypeRefForPHPDoc } from './type-map.js';
 import { className, fieldName, resolveMethodName, buildExportedClassNameSet, resolveServiceTarget } from './naming.js';
 import { isListWrapperModel } from './models.js';
 import {
-  groupByMount,
+  scopedMountGroups,
   buildResolvedLookup,
   lookupResolved,
   getOpDefaults,
@@ -44,10 +44,12 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
   const files: GeneratedFile[] = [];
   const modelMap = new Map(ctx.spec.models.map((m) => [m.name, m]));
 
-  // Group operations by mount target
-  const mountGroups = groupByMount(ctx);
+  // Group operations by mount target. In a scoped (`--services`) run this
+  // returns only the selected post-mount services so we emit per-service
+  // resource files for those alone.
+  const mountGroups = scopedMountGroups(ctx);
   const entries: Array<{ name: string; operations: Operation[] }> =
-    mountGroups.size > 0
+    mountGroups.size > 0 || ctx.scopedServices?.size
       ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
       : services.map((s) => ({ name: className(s.name), operations: s.operations }));