@workos/oagen-emitters 0.19.0 → 0.19.1

package/src/python/tests.ts

@@ -30,6 +30,8 @@ import {
   lookupResolved,
   buildHiddenParams,
   collectGroupedParamNames,
+  isModelInScope,
+  fileExistsAfterRun,
 } from '../shared/resolved-ops.js';
 import { resolveWrapperParams } from '../shared/wrapper-utils.js';
 import { pythonLiteral } from './wrappers.js';
@@ -100,7 +102,7 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   const files: GeneratedFile[] = [];
 
   // Generate fixture JSON files
-  const fixtures = generateFixtures(spec);
+  const fixtures = generateFixtures(spec, ctx);
   for (const fixture of fixtures) {
     files.push({
       path: fixture.path,
@@ -1461,22 +1463,39 @@ function generateModelRoundTripTests(spec: ApiSpec, ctx: EmitterContext): Genera
 
   const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
   const listMetadataNeeded = collectReferencedListMetadataModels(spec.models, nonPaginatedRefs);
-  const models = spec.models.filter(
-    (m) =>
-      !(isListWrapperModel(m) && !nonPaginatedRefs.has(m.name)) &&
-      !(isListMetadataModel(m) && !listMetadataNeeded.has(m.name)) &&
-      !requestOnlyModelNames.has(m.name),
-  );
-  if (models.length === 0) return null;
 
   // The round-trip test imports models from their *natural* (pre-relocation)
   // service so existing callers keep working — those imports resolve via the
   // BC re-exports that the model emitter writes into each service barrel.
-  const modelToService = computeSchemaPlacement(spec, ctx).originalModelToService;
+  const placement = computeSchemaPlacement(spec, ctx);
+  const modelToService = placement.originalModelToService;
+  // The per-model FILE is written to the RELOCATED dir; use it to compute the
+  // gate's relPath so it lines up with the prior manifest.
+  const relocatedModelToService = placement.modelToService;
   const roundTripDirMap = buildMountDirMap(ctx);
   const resolveDir = (irService: string | undefined) =>
     irService ? (roundTripDirMap.get(irService) ?? 'common') : 'common';
 
+  // Scoped runs: the round-trip test must only reference a model whose per-model
+  // file exists on disk after the run (in-scope, or already present from the
+  // prior manifest). A brand-new out-of-scope model is excluded — its file is
+  // never emitted, so importing it would raise ModuleNotFoundError. A full run
+  // keeps every model (fileExistsAfterRun ⇒ true).
+  const modelFileExists = (name: string): boolean => {
+    const dir = resolveDir(relocatedModelToService.get(name));
+    const path = `src/${ctx.namespace}/${dir}/models/${fileName(name)}.py`;
+    return fileExistsAfterRun(path, isModelInScope(name, ctx), ctx);
+  };
+
+  const models = spec.models.filter(
+    (m) =>
+      !(isListWrapperModel(m) && !nonPaginatedRefs.has(m.name)) &&
+      !(isListMetadataModel(m) && !listMetadataNeeded.has(m.name)) &&
+      !requestOnlyModelNames.has(m.name) &&
+      modelFileExists(m.name),
+  );
+  if (models.length === 0) return null;
+
   const lines: string[] = [];
   lines.push('"""Model round-trip tests: from_dict(to_dict()) preserves data."""');
   lines.push('');

package/src/ruby/tests.ts

@@ -1,4 +1,5 @@
 import type { ApiSpec, EmitterContext, GeneratedFile, Model, Operation, ResolvedWrapper, TypeRef } from '@workos/oagen';
+import { assignModelsToServices } from '@workos/oagen';
 import {
   className,
   fileName,
@@ -10,6 +11,7 @@ import {
   resolveMethodName,
   buildExportedClassNameSet,
   resolveServiceTarget,
+  buildMountDirMap,
 } from './naming.js';
 import {
   buildResolvedLookup,
@@ -17,8 +19,11 @@ import {
   lookupResolved,
   buildHiddenParams,
   collectBodyFieldTypes,
+  isModelInScope,
+  fileExistsAfterRun,
 } from '../shared/resolved-ops.js';
 import { isListWrapperModel, isListMetadataModel } from '../shared/model-utils.js';
+import { classifyUnassignedModel } from './models.js';
 import { resolveWrapperParams } from '../shared/wrapper-utils.js';
 import { buildGroupOwnerMap, pickVariantParamType } from './parameter-groups.js';
 
@@ -203,7 +208,7 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
     });
   }
 
-  files.push(generateModelRoundTripTest(spec));
+  files.push(generateModelRoundTripTest(spec, ctx));
 
   return files;
 }
@@ -212,8 +217,19 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
  * Emit test/workos/model_round_trip_test.rb that round-trips every non-wrapper
  * model through `.new(json)` and `.to_json`, asserting the result is a Hash and
  * that required fields appear with the seeded values.
+ *
+ * This is a whole-suite AGGREGATE: it references `WorkOS::<Class>` for every
+ * model. Under a scoped (`--services`) run only the selected services' per-model
+ * `.rb` files are (re)written, so a test referencing a brand-new out-of-scope
+ * model whose file was never emitted would raise `NameError: uninitialized
+ * constant`. Each per-model test is therefore gated by {@link fileExistsAfterRun}
+ * on the SAME path `models.ts` writes (`lib/workos/<dir>/<file>.rb`): emit only
+ * when that file will exist on disk after the run — in-scope (emitted this run)
+ * OR already present from a prior run (`priorTargetManifestPaths`). Brand-new
+ * out-of-scope models are excluded; renamed/removed-but-on-disk models are
+ * retained. A full run (scoping inert) keeps every model.
  */
-function generateModelRoundTripTest(spec: ApiSpec): GeneratedFile {
+function generateModelRoundTripTest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
   const lines: string[] = [];
   lines.push(`require 'test_helper'`);
   lines.push('');
@@ -223,7 +239,24 @@ function generateModelRoundTripTest(spec: ApiSpec): GeneratedFile {
   const enumNames = new Set(spec.enums.map((e) => e.name));
   const emitted = new Set<string>();
 
+  // Resolve each model's per-model file path EXACTLY as models.ts does, so the
+  // scope gate keys on the same path the per-model FILE writer uses.
+  const modelToService = assignModelsToServices(models, ctx.spec.services, ctx.modelHints);
+  const mountDirMap = buildMountDirMap(ctx);
+  const dirFor = (modelName: string): string => {
+    const service = modelToService.get(modelName);
+    if (!service) return classifyUnassignedModel(modelName);
+    return mountDirMap.get(service) ?? classifyUnassignedModel(modelName);
+  };
+
   for (const model of models) {
+    // Skip models whose per-model `.rb` file will NOT exist on disk after this
+    // run (brand-new + out-of-scope under `--services`). Without this gate the
+    // aggregate would reference an undefined constant. The path mirrors
+    // models.ts's `lib/workos/${dirFor}/${fileName}.rb`.
+    const modelFilePath = `lib/workos/${dirFor(model.name)}/${fileName(model.name)}.rb`;
+    if (!fileExistsAfterRun(modelFilePath, isModelInScope(model.name, ctx), ctx)) continue;
+
     // Avoid duplicate test names when two IR model names collapse to the same
     // snake_case file name (we use the file name as the test suffix).
     const fileBase = fileName(model.name);

package/src/rust/enums.ts

@@ -1,6 +1,6 @@
 import type { Enum, EmitterContext, GeneratedFile } from '@workos/oagen';
 import { typeName, moduleName, variantName } from './naming.js';
-import { isEnumInScope } from '../shared/resolved-ops.js';
+import { isEnumInScope, fileExistsAfterRun, priorManifestBasenames } from '../shared/resolved-ops.js';
 
 /**
  * Generate one Rust source file per enum under `src/enums/`, plus a
@@ -28,20 +28,34 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     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),
-      overwriteExisting: true,
-    });
+
+    // Only the per-enum `.rs` FILE write is scoped (FR-1.4); an out-of-scope
+    // enum's existing `.rs` file stays untouched on disk.
+    const inScope = isEnumInScope(e.name, ctx);
+    const path = `src/enums/${mod}.rs`;
+    if (inScope) {
+      files.push({
+        path,
+        content: renderEnum(e),
+        overwriteExisting: true,
+      });
+    }
+
+    // Declare the module only if its file will exist on disk after this run, so
+    // a scoped run never declares a brand-new out-of-scope enum it doesn't emit.
+    if (fileExistsAfterRun(path, inScope, ctx)) {
+      moduleNames.push(mod);
+    }
+  }
+
+  // Scoped runs: retain barrel entries for enum files still on disk (prior
+  // manifest) that the current spec no longer produces (e.g. renamed for
+  // another service), since out-of-scope code may still reference them.
+  for (const base of priorManifestBasenames(ctx, 'src/enums', '.rs', new Set(['mod']))) {
+    if (!seen.has(base)) {
+      seen.add(base);
+      moduleNames.push(base);
+    }
   }
 
   files.push({

package/src/rust/fixtures.ts

@@ -1,12 +1,19 @@
-import type { ApiSpec, GeneratedFile, Model, Enum, TypeRef } from '@workos/oagen';
+import type { ApiSpec, GeneratedFile, Model, Enum, TypeRef, EmitterContext } from '@workos/oagen';
 import { walkTypeRef } from '@workos/oagen';
 import { moduleName } from './naming.js';
+import { isModelInScope, fileExistsAfterRun } from '../shared/resolved-ops.js';
 
 /**
  * Generate JSON test fixture files under `tests/fixtures/`. The Rust tests
  * pull these in via `include_str!` so no I/O is required at test time.
+ *
+ * Scoped runs only emit a fixture for a model whose file will exist on disk
+ * after the run (in-scope, or already present from a prior run). Emitting a
+ * fixture for a brand-new out-of-scope model would add a stray file for a model
+ * the SDK can't even reference yet; in-scope tests only `include_str!` fixtures
+ * for in-scope models, so gating here is safe.
  */
-export function generateFixtures(spec: ApiSpec): GeneratedFile[] {
+export function generateFixtures(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
   const files: GeneratedFile[] = [];
   const modelMap = new Map(spec.models.map((m) => [m.name, m]));
   const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
@@ -17,8 +24,10 @@ export function generateFixtures(spec: ApiSpec): GeneratedFile[] {
     if (model.fields.length === 0) continue;
     seen.add(model.name);
 
-    const fixture = generateModelFixture(model, modelMap, enumMap, new Set());
     const path = `tests/fixtures/${moduleName(model.name)}.json`;
+    if (!fileExistsAfterRun(path, isModelInScope(model.name, ctx), ctx)) continue;
+
+    const fixture = generateModelFixture(model, modelMap, enumMap, new Set());
     files.push({
       path,
       content: JSON.stringify(fixture, null, 2) + '\n',

package/src/rust/models.ts

@@ -2,7 +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';
+import { isModelInScope, fileExistsAfterRun, priorManifestBasenames } from '../shared/resolved-ops.js';
 
 const HEADER_PLACEHOLDER = ''; // engine prepends fileHeader()
 
@@ -33,27 +33,45 @@ 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.
+    // is scoped (FR-1.4) — an out-of-scope model's existing `.rs` file stays
+    // untouched on disk.
+    const inScope = isModelInScope(model.name, ctx);
     const hintPath = ctx.overlayLookup?.fileBySymbol?.get(model.name);
     const path = hintPath ?? `src/models/${mod}.rs`;
     const content = renderModel(model, registry, taggedVariantFields.get(model.name));
-    if (isModelInScope(model.name, ctx)) {
+    if (inScope) {
       files.push({
         path,
         content,
         overwriteExisting: true,
       });
     }
+
+    // Declare the module only if its `.rs` file will exist on disk after this
+    // run: in-scope (emitted just now) or already present from a prior run. A
+    // scoped run must NOT declare a brand-new out-of-scope model whose file it
+    // never emits — that dangling `mod` is what broke the build. A full run
+    // declares every module (fileExistsAfterRun ⇒ true when scoping is inert).
+    if (fileExistsAfterRun(path, inScope, ctx)) {
+      moduleNames.push(mod);
+    }
+  }
+
+  // Scoped runs: retain barrel entries for model files still on disk (prior
+  // manifest) that the current spec no longer produces — e.g. a model renamed
+  // for another service. Out-of-scope code we did not regenerate may still
+  // reference them, so dropping the `mod` would break the build. De-duped
+  // against the modules declared above; a full run yields nothing here.
+  for (const base of priorManifestBasenames(ctx, 'src/models', '.rs', new Set([UNIONS_MODULE, 'mod']))) {
+    if (!seen.has(base)) {
+      seen.add(base);
+      moduleNames.push(base);
+    }
   }
 
   // Always include the unions module in the barrel so downstream stages

package/src/rust/tests.ts

@@ -35,7 +35,7 @@ import { isInlineEnvelopeList } from './resources.js';
 export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
   const files: GeneratedFile[] = [];
 
-  files.push(...generateFixtures(spec));
+  files.push(...generateFixtures(spec, ctx));
 
   files.push({
     path: 'tests/common/mod.rs',

package/src/shared/resolved-ops.ts

@@ -141,6 +141,63 @@ export function isEnumInScope(enumName: string, ctx: EmitterContext): boolean {
   return !scope || scope.has(enumName);
 }
 
+/** True when a scoped (`--services`) run is active. */
+export function isScopedRun(ctx: EmitterContext): boolean {
+  return !!ctx.scopedServices && ctx.scopedServices.size > 0;
+}
+
+/**
+ * Barrel/index inclusion gate for one item (model, enum, fixture) under a
+ * scoped run. A barrel/index may only reference an item whose per-item FILE
+ * EXISTS ON DISK after the run — otherwise the reference dangles and the SDK
+ * fails to compile (the bug this guards: a brand-new model belonging to an
+ * out-of-scope service gets declared in `mod.rs`/`__init__.py` but its source
+ * file is never emitted). That on-disk set is:
+ *   in-scope items (freshly emitted this run) ∪ items already on disk
+ *   (recorded in the prior manifest, left untouched because scoped runs never
+ *   prune).
+ * Inactive scoping ⇒ always true (a full run emits and declares everything).
+ *
+ * `relPath` is the per-item file path the emitter writes (e.g.
+ * `src/models/foo.rs`); `inScope` is the per-item scope predicate result
+ * (`isModelInScope` / `isEnumInScope`).
+ */
+export function fileExistsAfterRun(relPath: string, inScope: boolean, ctx: EmitterContext): boolean {
+  if (!isScopedRun(ctx)) return true;
+  return inScope || (ctx.priorTargetManifestPaths?.has(relPath) ?? false);
+}
+
+/**
+ * Per-item basenames recorded in the prior manifest directly under `dir` (e.g.
+ * `src/models`) with extension `ext` (e.g. `.rs`), EXCLUDING `reserved` names
+ * (barrels such as `mod`, `_unions`, `__init__`). A scoped run uses this to
+ * RETAIN barrel declarations for items that were renamed/removed from the spec
+ * but whose files still sit on disk — and may still be referenced by
+ * out-of-scope code the scoped run did not regenerate (e.g. a stale resource
+ * file). Returns `[]` for a full run or when no prior manifest is available;
+ * the caller is responsible for de-duping against items it already emitted.
+ */
+export function priorManifestBasenames(
+  ctx: EmitterContext,
+  dir: string,
+  ext: string,
+  reserved: Set<string> = new Set(),
+): string[] {
+  if (!isScopedRun(ctx)) return [];
+  const paths = ctx.priorTargetManifestPaths;
+  if (!paths) return [];
+  const prefix = dir.endsWith('/') ? dir : `${dir}/`;
+  const out: string[] = [];
+  for (const p of paths) {
+    if (!p.startsWith(prefix) || !p.endsWith(ext)) continue;
+    const base = p.slice(prefix.length, p.length - ext.length);
+    if (base.includes('/')) continue; // direct children only
+    if (reserved.has(base)) continue;
+    out.push(base);
+  }
+  return out;
+}
+
 /**
  * Get the mount target for an IR service.
  * Checks the first resolved operation that belongs to this service.

package/test/dotnet/scoped-aggregates.test.ts

@@ -0,0 +1,247 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { dotnetEmitter } from '../../src/dotnet/index.js';
+import { generateTests } from '../../src/dotnet/tests.js';
+import { discriminatedUnions } from '../../src/dotnet/type-map.js';
+import { primeEnumAliases } from '../../src/dotnet/enums.js';
+import type { EmitterContext, ApiSpec, Model, Service } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+
+/**
+ * Scoped (`--services`) runs emit per-model `Entities/*.cs` only for in-scope
+ * models, but the polymorphic-dispatch aggregates (discriminated-union JSON
+ * converters, per-model test fixtures) were previously built from the FULL
+ * spec. A brand-new out-of-scope variant would then be referenced by a
+ * converter whose `.cs` file is never emitted (CS0246). These tests assert the
+ * `fileExistsAfterRun` gate excludes brand-new out-of-scope items while
+ * retaining renamed/removed-but-still-on-disk ones.
+ */
+const emptySpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [],
+  models: [],
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+describe('dotnet/scoped aggregates', () => {
+  beforeEach(() => {
+    // discriminatedUnions is module-global and accumulates across mapTypeRef
+    // calls; clear it so each test sees only the unions it registers.
+    discriminatedUnions.clear();
+    primeEnumAliases([]);
+  });
+
+  it('gates the discriminated-union converter to variants whose .cs exists after a scoped run', () => {
+    // Parent model has a field typed as a discriminated union over three
+    // event-payload variants:
+    //   - UserCreated:             in-scope this run (emitted now)
+    //   - OrganizationDomainStandAlone: NOT in scope, but on disk (prior run) → retained
+    //   - SessionReauthenticated:  brand-new, NOT in scope, NOT on disk → excluded
+    const models: Model[] = [
+      {
+        name: 'WebhookEnvelope',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          {
+            name: 'payload',
+            type: {
+              kind: 'union',
+              variants: [
+                { kind: 'model', name: 'UserCreated' },
+                { kind: 'model', name: 'OrganizationDomainStandAlone' },
+                { kind: 'model', name: 'SessionReauthenticated' },
+              ],
+              discriminator: {
+                property: 'event',
+                mapping: {
+                  'user.created': 'UserCreated',
+                  'organization_domain.verified': 'OrganizationDomainStandAlone',
+                  'session.reauthenticated': 'SessionReauthenticated',
+                },
+              },
+            },
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'UserCreated',
+        fields: [{ name: 'user_id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'OrganizationDomainStandAlone',
+        fields: [{ name: 'domain', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'SessionReauthenticated',
+        fields: [{ name: 'session_id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+
+    const ctx: EmitterContext = {
+      namespace: 'workos',
+      namespacePascal: 'WorkOS',
+      spec: { ...emptySpec, models },
+      // Scoped to the WebhookEnvelope + UserCreated surface only.
+      scopedServices: new Set(['Webhooks']),
+      scopedModelNames: new Set(['WebhookEnvelope', 'UserCreated']),
+      // OrganizationDomainStandAlone exists on disk from a prior full run; the
+      // brand-new SessionReauthenticated does not.
+      priorTargetManifestPaths: new Set([
+        'src/WorkOS.net/Entities/WebhookEnvelope.cs',
+        'src/WorkOS.net/Entities/UserCreated.cs',
+        'src/WorkOS.net/Entities/OrganizationDomainStandAlone.cs',
+      ]),
+    };
+
+    const files = dotnetEmitter.generateModels!(models, ctx);
+    const converter = files.find((f) => f.path.includes('DiscriminatorConverter.cs'));
+    expect(converter).toBeDefined();
+    const content = converter!.content;
+
+    // In-scope variant is dispatched.
+    expect(content).toContain('case "user.created": return jObject.ToObject<UserCreated>(serializer);');
+    // Renamed/removed-but-on-disk variant is retained.
+    expect(content).toContain(
+      'case "organization_domain.verified": return jObject.ToObject<OrganizationDomainStandAlone>(serializer);',
+    );
+    // Brand-new out-of-scope variant is EXCLUDED (its .cs is never emitted → CS0246).
+    expect(content).not.toContain('SessionReauthenticated');
+    expect(content).not.toContain('session.reauthenticated');
+  });
+
+  it('emits all converter variants on a full (unscoped) run', () => {
+    const models: Model[] = [
+      {
+        name: 'WebhookEnvelope',
+        fields: [
+          {
+            name: 'payload',
+            type: {
+              kind: 'union',
+              variants: [
+                { kind: 'model', name: 'UserCreated' },
+                { kind: 'model', name: 'SessionReauthenticated' },
+              ],
+              discriminator: {
+                property: 'event',
+                mapping: {
+                  'user.created': 'UserCreated',
+                  'session.reauthenticated': 'SessionReauthenticated',
+                },
+              },
+            },
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'UserCreated',
+        fields: [{ name: 'user_id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'SessionReauthenticated',
+        fields: [{ name: 'session_id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+
+    // No scopedServices → full run; every variant is dispatched.
+    const ctx: EmitterContext = {
+      namespace: 'workos',
+      namespacePascal: 'WorkOS',
+      spec: { ...emptySpec, models },
+    };
+
+    const files = dotnetEmitter.generateModels!(models, ctx);
+    const converter = files.find((f) => f.path.includes('DiscriminatorConverter.cs'))!;
+    expect(converter.content).toContain('ToObject<UserCreated>');
+    expect(converter.content).toContain('ToObject<SessionReauthenticated>');
+  });
+
+  it('gates per-model fixtures to models whose file exists after a scoped run', () => {
+    const models: Model[] = [
+      {
+        name: 'OrganizationMembership',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'OrganizationDomainStandAlone',
+        fields: [{ name: 'domain', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'SessionReauthenticated',
+        fields: [{ name: 'session_id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+
+    const services: Service[] = [
+      {
+        name: 'OrganizationMemberships',
+        operations: [
+          {
+            name: 'getOrganizationMembership',
+            httpMethod: 'get',
+            path: '/organization_memberships/{id}',
+            pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'model', name: 'OrganizationMembership' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+
+    const spec: ApiSpec = { ...emptySpec, services, models };
+    const ctx: EmitterContext = {
+      namespace: 'workos',
+      namespacePascal: 'WorkOS',
+      spec,
+      scopedServices: new Set(['OrganizationMemberships']),
+      scopedModelNames: new Set(['OrganizationMembership']),
+      // The renamed/removed model is on disk; the brand-new one is not.
+      priorTargetManifestPaths: new Set([
+        'test/WorkOSTests/testdata/organization_membership.json',
+        'test/WorkOSTests/testdata/organization_domain_stand_alone.json',
+      ]),
+    };
+
+    const files = generateTests(spec, ctx);
+    const paths = files.map((f) => f.path);
+
+    // In-scope model fixture is emitted.
+    expect(paths).toContain('testdata/organization_membership.json');
+    // Renamed/removed-but-on-disk fixture is retained.
+    expect(paths).toContain('testdata/organization_domain_stand_alone.json');
+    // Brand-new out-of-scope fixture is EXCLUDED (stray file for an
+    // unreferenceable model).
+    expect(paths.some((p) => p.includes('session_reauthenticated'))).toBe(false);
+  });
+
+  it('emits all per-model fixtures on a full (unscoped) run', () => {
+    const models: Model[] = [
+      {
+        name: 'OrganizationMembership',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'SessionReauthenticated',
+        fields: [{ name: 'session_id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+    const spec: ApiSpec = { ...emptySpec, models };
+    const ctx: EmitterContext = {
+      namespace: 'workos',
+      namespacePascal: 'WorkOS',
+      spec,
+    };
+
+    const files = generateTests(spec, ctx);
+    const paths = files.map((f) => f.path);
+    expect(paths).toContain('testdata/organization_membership.json');
+    expect(paths.some((p) => p.includes('session_reauthenticated'))).toBe(true);
+  });
+});