@workos/oagen-emitters 0.18.4 → 0.19.0

package/src/php/tests.ts

@@ -20,7 +20,7 @@ import { isListWrapperModel } from './models.js';
 import { generateFixtures } from './fixtures.js';
 import {
   getMountTarget,
-  groupByMount,
+  scopedMountGroups,
   buildHiddenParams,
   getOpDefaults,
   getOpInferFromClient,
@@ -39,9 +39,12 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
 
   // Collect all operations per mount target using resolved per-operation mounts.
   // This correctly handles operationHint mountOn overrides (e.g., audit_logs_retention → AuditLogs).
-  const mountGroupsFromResolved = groupByMount(ctx);
+  // In a scoped (`--services`) run this returns only the selected post-mount
+  // services so we emit per-service test files for those alone. ClientTest.php
+  // and fixtures below are built from `spec` and stay full.
+  const mountGroupsFromResolved = scopedMountGroups(ctx);
   const mountGroups = new Map<string, { op: Operation; service: Service; resolvedOp?: ResolvedOperation }[]>();
-  if (mountGroupsFromResolved.size > 0) {
+  if (mountGroupsFromResolved.size > 0 || ctx.scopedServices?.size) {
     for (const [target, group] of mountGroupsFromResolved) {
       mountGroups.set(
         target,

package/src/python/enums.ts

@@ -2,6 +2,7 @@ import type { Enum, EmitterContext, GeneratedFile } from '@workos/oagen';
 import { toUpperSnakeCase } from '@workos/oagen';
 import { className, fileName, buildMountDirMap, dirToModule } from './naming.js';
 import { computeSchemaPlacement } from './shared-schemas.js';
+import { isEnumInScope } from '../shared/resolved-ops.js';
 
 /**
  * Convert a PascalCase class name to a human-readable lowercase string,
@@ -38,6 +39,10 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
   for (const enumDef of enums) {
     const service = enumToService.get(enumDef.name);
     const dirName = resolveDir(service);
+    // FR-1.4: write per-enum FILES only when in scope; the enum barrel is built
+    // separately (collectGeneratedEnumSymbolsByDir over the full set), so an
+    // out-of-scope enum left on disk stays exported and importable.
+    const enumInScope = isEnumInScope(enumDef.name, ctx);
 
     // If this enum is an alias for a canonical enum, generate a type alias file
     const canonicalName = aliasOf.get(enumDef.name);
@@ -73,12 +78,14 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
         lines.push('        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")');
       }
       lines.push(`__all__ = ["${aliasCls}"]`);
-      files.push({
-        path: `src/${ctx.namespace}/${dirName}/models/${fileName(enumDef.name)}.py`,
-        content: lines.join('\n'),
-        integrateTarget: true,
-        overwriteExisting: true,
-      });
+      if (enumInScope) {
+        files.push({
+          path: `src/${ctx.namespace}/${dirName}/models/${fileName(enumDef.name)}.py`,
+          content: lines.join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
 
       // Also generate compat alias files for dedup aliases (they may have compat aliases too)
       for (const aliasName of compatAliases.get(enumDef.name) ?? []) {
@@ -107,12 +114,14 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
             `__all__ = ["${aliasName}"]`,
           ].join('\n');
         }
-        files.push({
-          path: `src/${ctx.namespace}/${dirName}/models/${fileName(aliasName)}.py`,
-          content: compatContent,
-          integrateTarget: true,
-          overwriteExisting: true,
-        });
+        if (enumInScope) {
+          files.push({
+            path: `src/${ctx.namespace}/${dirName}/models/${fileName(aliasName)}.py`,
+            content: compatContent,
+            integrateTarget: true,
+            overwriteExisting: true,
+          });
+        }
       }
 
       continue;
@@ -241,26 +250,28 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
       );
     }
 
-    files.push({
-      path: `src/${ctx.namespace}/${dirName}/models/${fileName(enumDef.name)}.py`,
-      content: lines.join('\n'),
-      integrateTarget: true,
-      overwriteExisting: true,
-    });
-
-    for (const aliasName of compatAliases.get(enumDef.name) ?? []) {
+    if (enumInScope) {
       files.push({
-        path: `src/${ctx.namespace}/${dirName}/models/${fileName(aliasName)}.py`,
-        content: [
-          'from typing import TypeAlias',
-          `from .${fileName(enumDef.name)} import ${cls}`,
-          '',
-          `${aliasName}: TypeAlias = ${cls}`,
-          `__all__ = ["${aliasName}"]`,
-        ].join('\n'),
+        path: `src/${ctx.namespace}/${dirName}/models/${fileName(enumDef.name)}.py`,
+        content: lines.join('\n'),
         integrateTarget: true,
         overwriteExisting: true,
       });
+
+      for (const aliasName of compatAliases.get(enumDef.name) ?? []) {
+        files.push({
+          path: `src/${ctx.namespace}/${dirName}/models/${fileName(aliasName)}.py`,
+          content: [
+            'from typing import TypeAlias',
+            `from .${fileName(enumDef.name)} import ${cls}`,
+            '',
+            `${aliasName}: TypeAlias = ${cls}`,
+            `__all__ = ["${aliasName}"]`,
+          ].join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
     }
   }
 

package/src/python/models.ts

@@ -4,6 +4,7 @@ import { mapTypeRef } from './type-map.js';
 import { className, domainFieldName, fileName, buildMountDirMap, dirToModule } from './naming.js';
 import { collectGeneratedEnumSymbolsByDir } from './enums.js';
 import { computeSchemaPlacement } from './shared-schemas.js';
+import { isModelInScope } from '../shared/resolved-ops.js';
 
 /**
  * Generate Python dataclass model files from IR Model definitions.
@@ -169,12 +170,16 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
       dispLines.push(`            return cast("${variantTypeName}", dispatch_cls.from_dict(data))`);
       dispLines.push(`        return ${unknownClassName}.from_dict(data)`);
 
-      files.push({
-        path: `src/${ctx.namespace}/${dirName}/models/${fileName(model.name)}.py`,
-        content: dispLines.join('\n'),
-        integrateTarget: true,
-        overwriteExisting: true,
-      });
+      // FR-1.4: write the file only when in scope; the barrel tracking below is
+      // unconditional so out-of-scope models (left on disk) stay exported.
+      if (isModelInScope(model.name, ctx)) {
+        files.push({
+          path: `src/${ctx.namespace}/${dirName}/models/${fileName(model.name)}.py`,
+          content: dispLines.join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
 
       if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
       emittedModelSymbolsByDir.get(dirName)!.push(model.name);
@@ -216,12 +221,14 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
       }
       lines.push('');
       lines.push(`${modelClassName}: TypeAlias = ${canonicalClassName}`);
-      files.push({
-        path: `src/${ctx.namespace}/${dirName}/models/${fileName(model.name)}.py`,
-        content: lines.join('\n'),
-        integrateTarget: true,
-        overwriteExisting: true,
-      });
+      if (isModelInScope(model.name, ctx)) {
+        files.push({
+          path: `src/${ctx.namespace}/${dirName}/models/${fileName(model.name)}.py`,
+          content: lines.join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
       if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
       emittedModelSymbolsByDir.get(dirName)!.push(model.name);
       const aliasNatural = originalModelToService.get(model.name);
@@ -457,12 +464,14 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
 
     lines.push('        return result');
 
-    files.push({
-      path: `src/${ctx.namespace}/${dirName}/models/${fileName(model.name)}.py`,
-      content: lines.join('\n'),
-      integrateTarget: true,
-      overwriteExisting: true,
-    });
+    if (isModelInScope(model.name, ctx)) {
+      files.push({
+        path: `src/${ctx.namespace}/${dirName}/models/${fileName(model.name)}.py`,
+        content: lines.join('\n'),
+        integrateTarget: true,
+        overwriteExisting: true,
+      });
+    }
     if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
     emittedModelSymbolsByDir.get(dirName)!.push(model.name);
     const regularNatural = originalModelToService.get(model.name);

package/src/python/resources.ts

@@ -30,7 +30,7 @@ import {
   buildResolvedLookup,
   lookupMethodName,
   lookupResolved,
-  groupByMount,
+  scopedMountGroups,
   getOpDefaults,
   getOpInferFromClient,
   buildHiddenParams as buildHiddenParamsShared,
@@ -1056,12 +1056,12 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
   const resolvedLookup = buildResolvedLookup(ctx);
   const files: GeneratedFile[] = [];
   const mountDirMap = buildMountDirMap(ctx);
-  const mountGroups = groupByMount(ctx);
+  const mountGroups = scopedMountGroups(ctx);
 
   // Build mount group entries. When resolved operations are available, group by
   // mount target. Otherwise fall back to one group per service (for tests).
   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: resolveClassName(s, ctx), operations: s.operations }));
 

package/src/python/tests.ts

@@ -25,7 +25,7 @@ import { generateFixtures, generateModelFixture } from './fixtures.js';
 import { isListWrapperModel, isListMetadataModel } from './models.js';
 import { collectNonPaginatedResponseModelNames, collectReferencedListMetadataModels } from '../shared/model-utils.js';
 import {
-  groupByMount,
+  scopedMountGroups,
   buildResolvedLookup,
   lookupResolved,
   buildHiddenParams,
@@ -118,9 +118,9 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   const accessPaths = buildServiceAccessPaths(spec.services, ctx);
 
   // Generate per-mount-target test files (merges all sub-services into one file)
-  const mountGroups = groupByMount(ctx);
+  const mountGroups = scopedMountGroups(ctx);
   const testEntries: Array<{ name: string; operations: Operation[]; resolvedOps?: ResolvedOperation[] }> =
-    mountGroups.size > 0
+    mountGroups.size > 0 || ctx.scopedServices?.size
       ? [...mountGroups].map(([name, group]) => ({
           name,
           operations: group.operations,

package/src/ruby/enums.ts

@@ -1,6 +1,7 @@
 import type { Enum, EmitterContext, GeneratedFile } from '@workos/oagen';
 import { toUpperSnakeCase } from '@workos/oagen';
 import { className, fileName } from './naming.js';
+import { isEnumInScope } from '../shared/resolved-ops.js';
 
 /**
  * Generate Ruby enum class files.
@@ -9,7 +10,6 @@ import { className, fileName } from './naming.js';
  * and a frozen `ALL` array of all values.
  */
 export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
-  void ctx;
   if (enums.length === 0) return [];
 
   const files: GeneratedFile[] = [];
@@ -17,6 +17,9 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
 
   for (const enumDef of enums) {
     const cls = className(enumDef.name);
+    // FR-1.4: write the per-enum file only when in scope. Out-of-scope enum
+    // files are left untouched on disk; Zeitwerk autoloads them by path.
+    const enumInScope = isEnumInScope(enumDef.name, ctx);
 
     // If this enum duplicates another (by value set), emit a Ruby constant
     // alias. Zeitwerk autoloads the canonical when the alias is first
@@ -30,12 +33,14 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
       lines.push(`    ${cls} = ${canonicalCls}`);
       lines.push('  end');
       lines.push('end');
-      files.push({
-        path: `lib/workos/types/${fileName(enumDef.name)}.rb`,
-        content: lines.join('\n'),
-        integrateTarget: true,
-        overwriteExisting: true,
-      });
+      if (enumInScope) {
+        files.push({
+          path: `lib/workos/types/${fileName(enumDef.name)}.rb`,
+          content: lines.join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
       continue;
     }
 
@@ -60,12 +65,14 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
       lines.push('    end');
       lines.push('  end');
       lines.push('end');
-      files.push({
-        path: `lib/workos/types/${fileName(enumDef.name)}.rb`,
-        content: lines.join('\n'),
-        integrateTarget: true,
-        overwriteExisting: true,
-      });
+      if (enumInScope) {
+        files.push({
+          path: `lib/workos/types/${fileName(enumDef.name)}.rb`,
+          content: lines.join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
       continue;
     }
 
@@ -108,12 +115,14 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     lines.push('  end');
     lines.push('end');
 
-    files.push({
-      path: `lib/workos/types/${fileName(enumDef.name)}.rb`,
-      content: lines.join('\n'),
-      integrateTarget: true,
-      overwriteExisting: true,
-    });
+    if (enumInScope) {
+      files.push({
+        path: `lib/workos/types/${fileName(enumDef.name)}.rb`,
+        content: lines.join('\n'),
+        integrateTarget: true,
+        overwriteExisting: true,
+      });
+    }
   }
 
   return files;

package/src/ruby/models.ts

@@ -6,6 +6,7 @@ import {
   isListMetadataModel,
   collectNonPaginatedResponseModelNames,
 } from '../shared/model-utils.js';
+import { isModelInScope } from '../shared/resolved-ops.js';
 
 /** Folder under lib/workos/ for models not owned by any service. */
 export const SHARED_MODEL_DIR = 'shared';
@@ -119,12 +120,17 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
       lines.push('module WorkOS');
       lines.push(`  ${cls} = ${canonCls}`);
       lines.push('end');
-      files.push({
-        path: `lib/workos/${dirFor(model.name)}/${file}.rb`,
-        content: lines.join('\n'),
-        integrateTarget: true,
-        overwriteExisting: true,
-      });
+      // FR-1.4: write the per-model file only when in scope. Zeitwerk autoloads
+      // by path, so there is no barrel to keep in sync; out-of-scope alias files
+      // are left untouched on disk.
+      if (isModelInScope(model.name, ctx)) {
+        files.push({
+          path: `lib/workos/${dirFor(model.name)}/${file}.rb`,
+          content: lines.join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
       continue;
     }
 
@@ -214,12 +220,17 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     lines.push('  end');
     lines.push('end');
 
-    files.push({
-      path: `lib/workos/${dirFor(model.name)}/${file}.rb`,
-      content: lines.join('\n'),
-      integrateTarget: true,
-      overwriteExisting: true,
-    });
+    // FR-1.4: write the per-model file only when in scope. Zeitwerk autoloads by
+    // path, so there is no barrel to keep in sync; out-of-scope model files are
+    // left untouched on disk.
+    if (isModelInScope(model.name, ctx)) {
+      files.push({
+        path: `lib/workos/${dirFor(model.name)}/${file}.rb`,
+        content: lines.join('\n'),
+        integrateTarget: true,
+        overwriteExisting: true,
+      });
+    }
   }
 
   return files;

package/src/ruby/rbi.ts

@@ -15,6 +15,8 @@ import {
 import {
   buildResolvedLookup,
   groupByMount,
+  isMountInScope,
+  isModelInScope,
   lookupResolved,
   buildHiddenParams,
   collectGroupedParamNames,
@@ -116,12 +118,17 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     lines.push('  end');
     lines.push('end');
 
-    files.push({
-      path: `rbi/workos/${fileName(model.name)}.rbi`,
-      content: lines.join('\n'),
-      integrateTarget: true,
-      overwriteExisting: true,
-    });
+    // FR-1.4: write the per-model .rbi only when in scope. The client.rbi
+    // aggregate (section 3) stays on the full set so sigs for out-of-scope
+    // services whose .rb/.rbi still exist keep resolving.
+    if (isModelInScope(model.name, ctx)) {
+      files.push({
+        path: `rbi/workos/${fileName(model.name)}.rbi`,
+        content: lines.join('\n'),
+        integrateTarget: true,
+        overwriteExisting: true,
+      });
+    }
   }
 
   // 2. Generate service RBI files
@@ -137,6 +144,10 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
   const exportedClasses = buildExportedClassNameSet(ctx);
 
   for (const [mountTarget, group] of groups) {
+    // Scoped run: emit per-service .rbi only for selected mount targets. The
+    // client.rbi aggregate loop below intentionally stays on the FULL `groups`
+    // set so it keeps emitting sigs for every service whose .rb still exists.
+    if (!isMountInScope(mountTarget, ctx)) continue;
     const resolvedTarget = resolveServiceTarget(mountTarget, exportedClasses);
     const cls = className(resolvedTarget);
     const lines: string[] = [];

package/src/ruby/resources.ts

@@ -15,7 +15,7 @@ import { mapTypeRefForYard } from './type-map.js';
 import {
   buildResolvedLookup,
   lookupResolved,
-  groupByMount,
+  scopedMountGroups,
   getOpDefaults,
   getOpInferFromClient,
   buildHiddenParams,
@@ -33,7 +33,7 @@ import { buildGroupOwnerMap, collectVariantsForMountTarget, emitInlineVariantCla
 export function generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {
   const files: GeneratedFile[] = [];
 
-  const groups = groupByMount(ctx);
+  const groups = scopedMountGroups(ctx);
   const lookup = buildResolvedLookup(ctx);
   const modelNames = new Set(ctx.spec.models.map((m) => m.name));
   const enumNames = new Set(ctx.spec.enums.map((e) => e.name));

package/src/ruby/tests.ts

@@ -13,7 +13,7 @@ import {
 } from './naming.js';
 import {
   buildResolvedLookup,
-  groupByMount,
+  scopedMountGroups,
   lookupResolved,
   buildHiddenParams,
   collectBodyFieldTypes,
@@ -34,7 +34,7 @@ import { buildGroupOwnerMap, pickVariantParamType } from './parameter-groups.js'
 export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
   const files: GeneratedFile[] = [];
 
-  const groups = groupByMount(ctx);
+  const groups = scopedMountGroups(ctx);
   const models = spec.models as Model[];
   const modelByName = new Map<string, Model>();
   for (const m of models) modelByName.set(m.name, m);

package/src/rust/enums.ts

@@ -1,5 +1,6 @@
 import type { Enum, EmitterContext, GeneratedFile } from '@workos/oagen';
 import { typeName, moduleName, variantName } from './naming.js';
+import { isEnumInScope } from '../shared/resolved-ops.js';
 
 /**
  * Generate one Rust source file per enum under `src/enums/`, plus a
@@ -17,7 +18,7 @@ import { typeName, moduleName, variantName } from './naming.js';
  *     variant and re-serialize as the canonical wire string.
  *   - `Display`, `FromStr`, and `AsRef<str>` are implemented for ergonomics.
  */
-export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFile[] {
+export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
   const files: GeneratedFile[] = [];
   const seen = new Set<string>();
   const moduleNames: string[] = [];
@@ -27,8 +28,15 @@ export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFil
     const mod = moduleName(e.name);
     if (seen.has(mod)) continue;
     seen.add(mod);
+    // The barrel (`src/enums/mod.rs`) must declare every enum's module so Rust
+    // compiles even in a scoped run — `moduleNames` is collected from the FULL
+    // enum set regardless of scope.
     moduleNames.push(mod);
 
+    // Only the per-enum `.rs` FILE write is scoped (FR-1.4). In a scoped run we
+    // skip emitting files for out-of-scope enums, but the barrel above still
+    // declares their modules (their existing `.rs` files stay untouched on disk).
+    if (!isEnumInScope(e.name, ctx)) continue;
     files.push({
       path: `src/enums/${mod}.rs`,
       content: renderEnum(e),

package/src/rust/models.ts

@@ -2,6 +2,7 @@ import type { Model, EmitterContext, GeneratedFile, Field, TypeRef } from '@work
 import { typeName, domainFieldName, moduleName } from './naming.js';
 import { mapTypeRef, makeOptional, UnionRegistry } from './type-map.js';
 import { applySecretRedaction } from './secret.js';
+import { isModelInScope } from '../shared/resolved-ops.js';
 
 const HEADER_PLACEHOLDER = ''; // engine prepends fileHeader()
 
@@ -32,15 +33,27 @@ export function generateModels(models: Model[], ctx: EmitterContext, registry: U
     const mod = moduleName(model.name);
     if (seen.has(mod)) continue;
     seen.add(mod);
+    // The barrel (`src/models/mod.rs`) must declare every model's module so
+    // Rust compiles even in a scoped run — `moduleNames` is collected from the
+    // FULL model set regardless of scope.
     moduleNames.push(mod);
 
+    // renderModel registers inline unions into `registry` as a side effect, and
+    // `_unions.rs` is rendered later (in generateClient) from that registry — so
+    // it MUST run for every model, even out-of-scope ones, or scoped runs drop
+    // unions. Compute content unconditionally; only the per-model `.rs` FILE write
+    // is scoped (FR-1.4). The barrel above still declares every module, and an
+    // out-of-scope model's existing `.rs` file stays untouched on disk.
     const hintPath = ctx.overlayLookup?.fileBySymbol?.get(model.name);
     const path = hintPath ?? `src/models/${mod}.rs`;
-    files.push({
-      path,
-      content: renderModel(model, registry, taggedVariantFields.get(model.name)),
-      overwriteExisting: true,
-    });
+    const content = renderModel(model, registry, taggedVariantFields.get(model.name));
+    if (isModelInScope(model.name, ctx)) {
+      files.push({
+        path,
+        content,
+        overwriteExisting: true,
+      });
+    }
   }
 
   // Always include the unions module in the barrel so downstream stages

package/src/rust/resources.ts

@@ -14,7 +14,7 @@ import { fieldName, domainFieldName, methodName, typeName, moduleName, variantNa
 import { mapTypeRef, makeOptional, UnionRegistry } from './type-map.js';
 import { applySecretRedaction } from './secret.js';
 import { parsePathTemplate } from '../shared/path-template.js';
-import { groupByMount, buildResolvedLookup } from '../shared/resolved-ops.js';
+import { groupByMount, buildResolvedLookup, isMountInScope } from '../shared/resolved-ops.js';
 import { resolveWrapperParams, type ResolvedWrapperParam } from '../shared/wrapper-utils.js';
 
 /**
@@ -32,7 +32,14 @@ export function generateResources(_services: Service[], ctx: EmitterContext, reg
     if (group.operations.length === 0) continue;
     const basename = moduleName(mountName);
     const struct = mountStructName(mountName);
+    // The barrel (`src/resources/mod.rs`) must list every mount's module so
+    // Rust compiles even in a scoped run — `exports` is collected from the
+    // FULL groupByMount set regardless of scope.
     exports.push({ module: basename, struct });
+    // Only the per-service resource `.rs` FILE write is scoped. In a scoped
+    // run we skip emitting files for out-of-scope mounts, but the barrel above
+    // still references their modules (their existing `.rs` files stay on disk).
+    if (!isMountInScope(mountName, ctx)) continue;
     files.push({
       path: `src/resources/${basename}.rs`,
       content: renderMountGroup(mountName, group.resolvedOps, ctx, registry, lookup),

package/src/rust/tests.ts

@@ -11,7 +11,7 @@ import type {
   TypeRef,
 } from '@workos/oagen';
 import { methodName, moduleName, typeName } from './naming.js';
-import { groupByMount } from '../shared/resolved-ops.js';
+import { scopedMountGroups } from '../shared/resolved-ops.js';
 import { exampleFor, generateFixtures } from './fixtures.js';
 import { resolveWrapperParams } from '../shared/wrapper-utils.js';
 import { isInlineEnvelopeList } from './resources.js';
@@ -43,7 +43,7 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
     overwriteExisting: true,
   });
 
-  const groups = groupByMount(ctx);
+  const groups = scopedMountGroups(ctx);
   const modelMap = new Map(spec.models.map((m) => [m.name, m]));
   const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
 

package/src/shared/resolved-ops.ts

@@ -94,6 +94,53 @@ export function groupByMount(ctx: EmitterContext): Map<string, MountGroup> {
   return groups;
 }
 
+/**
+ * Like {@link groupByMount}, but for a scoped (`--services`) run returns ONLY the
+ * mount groups the run selected (`ctx.scopedServices`, POST-MOUNT names). When
+ * scoping is inactive the full set is returned unchanged.
+ *
+ * Use this for PER-SERVICE resource/test emission. Do NOT use it for
+ * aggregate/barrel files (Rust `mod.rs`, Ruby `client.rbi`, the root client) —
+ * those must continue to list every service, so they keep calling
+ * {@link groupByMount} over the full set; otherwise a scoped run would drop
+ * sibling modules and break the build/type-check.
+ */
+export function scopedMountGroups(ctx: EmitterContext): Map<string, MountGroup> {
+  const groups = groupByMount(ctx);
+  const scope = ctx.scopedServices;
+  if (!scope || scope.size === 0) return groups;
+  return new Map([...groups].filter(([mountName]) => scope.has(mountName)));
+}
+
+/**
+ * True when a POST-MOUNT service name should be emitted in the current run.
+ * Inactive scoping (no `ctx.scopedServices`) ⇒ everything is in scope. Use this
+ * for inline per-service gates (e.g. manifest loops keyed by `getMountTarget`).
+ */
+export function isMountInScope(mountName: string, ctx: EmitterContext): boolean {
+  const scope = ctx.scopedServices;
+  return !scope || scope.size === 0 || scope.has(mountName);
+}
+
+/**
+ * True when a MODEL's per-model FILE should be written in the current run (FR-1.4).
+ * A scoped run sets `ctx.scopedModelNames` to the models reachable from the
+ * selected services; out-of-scope models are left untouched on disk. Inactive
+ * scoping ⇒ everything is in scope. NOTE: gate only the per-model FILE write —
+ * the model must still appear in barrels/indexes (built from the full set) so the
+ * untouched on-disk file stays importable.
+ */
+export function isModelInScope(modelName: string, ctx: EmitterContext): boolean {
+  const scope = ctx.scopedModelNames;
+  return !scope || scope.has(modelName);
+}
+
+/** Like {@link isModelInScope} but for an ENUM's per-enum file (`ctx.scopedEnumNames`). */
+export function isEnumInScope(enumName: string, ctx: EmitterContext): boolean {
+  const scope = ctx.scopedEnumNames;
+  return !scope || scope.has(enumName);
+}
+
 /**
  * Get the mount target for an IR service.
  * Checks the first resolved operation that belongs to this service.