@workos/oagen-emitters 0.18.4 → 0.19.1

package/dist/plugin.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.18.4",
+  "version": "0.19.1",
   "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/fixtures.ts

@@ -1,7 +1,16 @@
-import type { Model, TypeRef, Enum } from '@workos/oagen';
+import type { Model, TypeRef, Enum, EmitterContext } from '@workos/oagen';
 import { fixtureFileName, domainFieldName } from './naming.js';
 import { isListMetadataModel, isListWrapperModel } from './models.js';
 import { collectNonPaginatedResponseModelNames } from '../shared/model-utils.js';
+import { isModelInScope, fileExistsAfterRun } from '../shared/resolved-ops.js';
+
+/**
+ * Prefix the per-model fixture path with the .NET test project layout so the
+ * scoped-run gate can compare it against the prefixed paths recorded in the
+ * prior manifest. Must mirror `TEST_PREFIX` in index.ts; the fixture path
+ * itself (`testdata/<name>.json`) is what `prefixTestPaths` later prepends to.
+ */
+const TEST_PREFIX = 'test/WorkOSTests/';
 
 /**
  * Prefix mapping for generating realistic ID fixture values.
@@ -25,11 +34,14 @@ export const ID_PREFIXES: Record<string, string> = {
 /**
  * Generate JSON fixture files for test data.
  */
-export function generateFixtures(spec: {
-  models: Model[];
-  enums: Enum[];
-  services: any[];
-}): { path: string; content: string }[] {
+export function generateFixtures(
+  spec: {
+    models: Model[];
+    enums: Enum[];
+    services: any[];
+  },
+  ctx: EmitterContext,
+): { path: string; content: string }[] {
   if (spec.models.length === 0) return [];
 
   const modelMap = new Map(spec.models.map((m) => [m.name, m]));
@@ -50,10 +62,19 @@ export function generateFixtures(spec: {
     if (isListMetadataModel(model)) continue;
     if (isListWrapperModel(model) && !nonPaginatedWrapperRefs.has(model.name)) continue;
 
+    // Scoped-run gate: only emit a per-model fixture whose file will exist on
+    // disk after the run (in-scope, or already present from a prior manifest).
+    // A brand-new out-of-scope model's fixture would be a stray file for a
+    // model no in-scope test can reference; a renamed/removed-but-on-disk one
+    // is retained. Full runs emit everything. `relPath` carries the
+    // `test/WorkOSTests/` prefix so it matches the prefixed prior-manifest paths.
+    const fixturePath = `testdata/${fixtureFileName(model.name)}.json`;
+    if (!fileExistsAfterRun(`${TEST_PREFIX}${fixturePath}`, isModelInScope(model.name, ctx), ctx)) continue;
+
     const fixture = model.fields.length === 0 ? {} : generateModelFixture(model, modelMap, enumMap);
 
     files.push({
-      path: `testdata/${fixtureFileName(model.name)}.json`,
+      path: fixturePath,
       content: JSON.stringify(fixture, null, 2),
     });
 

package/src/dotnet/index.ts

@@ -19,7 +19,7 @@ import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
 import { buildOperationsMap } from './manifest.js';
 import { generateWrapperOptionsClasses } from './wrappers.js';
-import { groupByMount } from '../shared/resolved-ops.js';
+import { groupByMount, isModelInScope, fileExistsAfterRun } from '../shared/resolved-ops.js';
 import { AUTOGEN_NOTICE } from '../shared/file-header.js';
 import { discriminatedUnions, resolveModelName } from './type-map.js';
 import { modelClassName } from './naming.js';
@@ -66,6 +66,28 @@ function prefixTestPaths(files: GeneratedFile[]): GeneratedFile[] {
   return files;
 }
 
+/**
+ * Scoped-run gate for a discriminated-union variant referenced by a generated
+ * converter (the event-registry / polymorphic dispatch aggregate). A converter
+ * may only name a variant whose per-model `Entities/<Class>.cs` file will exist
+ * on disk after the run — otherwise the `new <Class>()` / `ToObject<<Class>>`
+ * arm references a type whose file is never emitted (CS0246). The set that
+ * exists after the run is: in-scope variants (emitted this run) ∪ variants
+ * already on disk from a prior manifest (scoped runs never prune), so a
+ * renamed/removed-but-still-on-disk variant is RETAINED while a brand-new
+ * out-of-scope variant is EXCLUDED. A full run includes everything.
+ *
+ * The variant name is resolved through the model-alias map first, exactly as
+ * the converter emits it (`modelClassName(resolveModelName(name))`), and the
+ * candidate path carries the `src/WorkOS.net/` prefix so it matches the
+ * prefixed paths recorded in `priorTargetManifestPaths`.
+ */
+function variantFileExistsAfterRun(variantModelName: string, ctx: EmitterContext): boolean {
+  const canonical = resolveModelName(variantModelName);
+  const relPath = `${SRC_PREFIX}Entities/${modelClassName(canonical)}.cs`;
+  return fileExistsAfterRun(relPath, isModelInScope(canonical, ctx), ctx);
+}
+
 export const dotnetEmitter: Emitter = {
   language: 'dotnet',
 
@@ -146,6 +168,11 @@ export const dotnetEmitter: Emitter = {
         lines.push('            switch (discriminatorValue)');
         lines.push('            {');
         for (const [value, modelName] of Object.entries(disc.mapping)) {
+          // Scoped-run gate: only dispatch to a variant whose `Entities/*.cs`
+          // file will exist after the run. A brand-new out-of-scope variant is
+          // skipped (its `.cs` is never emitted ⇒ CS0246); unmatched discriminator
+          // values fall through to the `default` arm below.
+          if (!variantFileExistsAfterRun(modelName, c)) continue;
           const csName = modelClassName(resolveModelName(modelName));
           lines.push(`                case "${value}": return jObject.ToObject<${csName}>(serializer);`);
         }
@@ -177,6 +204,12 @@ export const dotnetEmitter: Emitter = {
     // CanWrite is false so serialization uses the default path and never
     // re-enters WriteJson.
     for (const [baseName, disc] of modelDiscriminators) {
+      // Skip the converter entirely when the base model's own `Entities/*.cs`
+      // won't exist after a scoped run (brand-new out-of-scope base): its
+      // `new <baseClass>()` default arm and `[JsonConverter]` attribute would
+      // both dangle. When the base is already on disk we still emit it — the
+      // untouched base class references this converter by name.
+      if (!variantFileExistsAfterRun(baseName, c)) continue;
       const baseClass = modelClassName(baseName);
       const converterName = `${baseClass}DiscriminatorConverter`;
       const lines: string[] = [];
@@ -210,6 +243,14 @@ export const dotnetEmitter: Emitter = {
       lines.push('            switch (discriminatorValue)');
       lines.push('            {');
       for (const [value, variantModelName] of Object.entries(disc.mapping)) {
+        // Scoped-run gate: only construct a variant whose `Entities/*.cs` file
+        // will exist after the run. This is the event-registry aggregate
+        // (`EventSchema` enumerates every event payload model): a brand-new
+        // out-of-scope event type is skipped (its `.cs` is never emitted ⇒
+        // CS0246), while a renamed/removed-but-still-on-disk one is retained.
+        // Unmatched discriminator values fall through to the `default` arm,
+        // which deserializes into the base class.
+        if (!variantFileExistsAfterRun(variantModelName, c)) continue;
         const csName = modelClassName(variantModelName);
         lines.push(`                case "${value}": target = new ${csName}(); break;`);
       }

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,
@@ -30,7 +30,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,
@@ -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/enums.ts

@@ -1,6 +1,8 @@
 import type { Enum, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
 import { walkTypeRef } from '@workos/oagen';
 import { className } from './naming.js';
+import { isEnumInScope, isScopedRun } from '../shared/resolved-ops.js';
+import { reconcileFlatBlocks, readPriorFile, type NamedBlock } from './flat-merge.js';
 
 /**
  * Generate Go typed string enum constants from IR Enum definitions.
@@ -16,6 +18,16 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
   if (enums.length === 0) return [];
 
   const aliasOf = collectEnumAliasOf(enums);
+  // An in-scope enum alias emits `type Alias = Canonical` against the current
+  // spec; the canonical may itself be out of scope and brand-new, which the
+  // reconciler would drop, leaving the alias dangling. Force-retain any
+  // canonical referenced by an in-scope alias.
+  const forcedCanonicals = new Set<string>();
+  if (isScopedRun(ctx)) {
+    for (const [aliasName, canonical] of aliasOf) {
+      if (isEnumInScope(aliasName, ctx)) forcedCanonicals.add(canonical);
+    }
+  }
   const files: GeneratedFile[] = [];
 
   // Group all enums into a single file per SDK
@@ -23,6 +35,12 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
   lines.push(`package ${ctx.namespace}`);
   lines.push('');
 
+  // Build one NamedBlock per emitted enum type so a scoped run can reconcile
+  // them against the prior enums.go (drop brand-new out-of-scope enums, retain
+  // renamed/removed ones still referenced by un-regenerated code). A full run
+  // emits every block unchanged.
+  const enumBlocks: NamedBlock[] = [];
+
   for (const enumDef of enums) {
     // If this enum is an alias, emit a simple type alias
     const canonicalName = aliasOf.get(enumDef.name);
@@ -33,9 +51,11 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
       // enums from enrichModelsFromSpec whose underscore names collapse to the
       // same PascalCase as the original enum).
       if (aliasType === canonicalType) continue;
-      lines.push(`// ${aliasType} is an alias for ${canonicalType}.`);
-      lines.push(`type ${aliasType} = ${canonicalType}`);
-      lines.push('');
+      enumBlocks.push({
+        names: [aliasType],
+        text: [`// ${aliasType} is an alias for ${canonicalType}.`, `type ${aliasType} = ${canonicalType}`].join('\n'),
+        inScope: isEnumInScope(enumDef.name, ctx),
+      });
       continue;
     }
 
@@ -43,9 +63,11 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
 
     if (enumDef.values.length === 0) {
       const humanized = humanize(enumDef.name);
-      lines.push(`// ${typeName} represents ${humanized} values.`);
-      lines.push(`type ${typeName} = string`);
-      lines.push('');
+      enumBlocks.push({
+        names: [typeName],
+        text: [`// ${typeName} represents ${humanized} values.`, `type ${typeName} = string`].join('\n'),
+        inScope: isEnumInScope(enumDef.name, ctx) || forcedCanonicals.has(enumDef.name),
+      });
       continue;
     }
 
@@ -61,10 +83,11 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     }
 
     const humanized = humanize(enumDef.name);
-    lines.push(`// ${typeName} represents ${humanized} values.`);
-    lines.push(`type ${typeName} string`);
-    lines.push('');
-    lines.push('const (');
+    const blockLines: string[] = [];
+    blockLines.push(`// ${typeName} represents ${humanized} values.`);
+    blockLines.push(`type ${typeName} string`);
+    blockLines.push('');
+    blockLines.push('const (');
 
     const usedNames = new Set<string>();
     for (const v of uniqueValues) {
@@ -79,15 +102,25 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
       usedNames.add(constName);
       const valueStr = typeof v.value === 'string' ? `"${v.value}"` : String(v.value);
       if (v.description) {
-        lines.push(`\t// ${constName} is ${v.description}.`);
+        blockLines.push(`\t// ${constName} is ${v.description}.`);
       }
       if (v.deprecated) {
-        if (v.description) lines.push(`\t//`);
-        lines.push(`\t// Deprecated: this value is deprecated.`);
+        if (v.description) blockLines.push(`\t//`);
+        blockLines.push(`\t// Deprecated: this value is deprecated.`);
       }
-      lines.push(`\t${constName} ${typeName} = ${valueStr}`);
+      blockLines.push(`\t${constName} ${typeName} = ${valueStr}`);
     }
-    lines.push(')');
+    blockLines.push(')');
+    enumBlocks.push({
+      names: [typeName],
+      text: blockLines.join('\n'),
+      inScope: isEnumInScope(enumDef.name, ctx) || forcedCanonicals.has(enumDef.name),
+    });
+  }
+
+  const reconciled = reconcileFlatBlocks(enumBlocks, 'enums.go', ctx);
+  for (const text of reconciled) {
+    lines.push(text);
     lines.push('');
   }
 
@@ -96,7 +129,7 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     content: lines.join('\n'),
     overwriteExisting: true,
   });
-  const eventConstantsFile = generateEventConstantsFile(enums);
+  const eventConstantsFile = generateEventConstantsFile(enums, ctx);
   if (eventConstantsFile) files.push(eventConstantsFile);
 
   return files;
@@ -175,10 +208,28 @@ function collectEnumAliasOf(enums: Enum[]): Map<string, string> {
   return aliasOf;
 }
 
-function generateEventConstantsFile(enums: Enum[]): GeneratedFile | null {
+const EVENTS_FILE_PATH = 'pkg/events/events.go';
+
+function generateEventConstantsFile(enums: Enum[], ctx: EmitterContext): GeneratedFile | null {
   const enumDef = findWebhookEventEnum(enums);
   if (!enumDef) return null;
 
+  // Scoped-run gate for the flat events file. Unlike models/enums, an event
+  // value can't be mapped to a single selected service, so there is no
+  // per-event "in scope" signal. The correct Option-B behavior is therefore to
+  // keep this aggregate byte-stable in a scoped run: emit only event constants
+  // that already existed in the prior events.go (dropping brand-new additions
+  // such as `session.reauthenticated` from an out-of-scope service) and never
+  // drop a constant that was present before. Equivalent to: in a scoped run,
+  // emit exactly the prior file's constant set.
+  let priorEventConsts: Set<string> | null = null;
+  if (isScopedRun(ctx)) {
+    const prior = readPriorFile(EVENTS_FILE_PATH, ctx);
+    if (prior !== null) {
+      priorEventConsts = collectPriorEventConstNames(prior);
+    }
+  }
+
   const lines: string[] = [];
   lines.push('package events');
   lines.push('');
@@ -195,6 +246,13 @@ function generateEventConstantsFile(enums: Enum[]): GeneratedFile | null {
     seenValues.add(valueStr);
 
     const constName = uniqueEventConstantName(valueStr, usedNames);
+
+    // Scoped run: skip a constant that wasn't in the prior file (a brand-new,
+    // out-of-scope event). When there's no prior file to compare against, fall
+    // through and emit everything (first generation / non-target run).
+    if (priorEventConsts !== null && !priorEventConsts.has(constName)) {
+      continue;
+    }
     usedNames.add(constName);
 
     if (value.description) {
@@ -213,12 +271,27 @@ function generateEventConstantsFile(enums: Enum[]): GeneratedFile | null {
   lines.push('');
 
   return {
-    path: 'pkg/events/events.go',
+    path: EVENTS_FILE_PATH,
     content: lines.join('\n'),
     overwriteExisting: true,
   };
 }
 
+/**
+ * Collect the constant names declared in a prior `pkg/events/events.go`. Each
+ * event constant is emitted as `\tConstName = "wire.value"` inside the single
+ * `const (...)` block, so a simple line scan recovers the prior name set used
+ * to keep the file byte-stable across scoped runs.
+ */
+function collectPriorEventConstNames(content: string): Set<string> {
+  const names = new Set<string>();
+  for (const raw of content.split('\n')) {
+    const m = raw.trim().match(/^(\w+)\s*=\s*"/);
+    if (m) names.add(m[1]);
+  }
+  return names;
+}
+
 function findWebhookEventEnum(enums: Enum[]): Enum | null {
   return (
     enums.find((enumDef) => enumDef.name === 'CreateWebhookEndpointEvents') ??

package/src/go/fixtures.ts

@@ -1,7 +1,8 @@
-import type { Model, TypeRef, Enum } from '@workos/oagen';
+import type { Model, TypeRef, Enum, EmitterContext } from '@workos/oagen';
 import { fileName, domainFieldName } from './naming.js';
 import { isListMetadataModel, isListWrapperModel } from './models.js';
 import { collectNonPaginatedResponseModelNames, collectReferencedListMetadataModels } from '../shared/model-utils.js';
+import { isModelInScope, fileExistsAfterRun } from '../shared/resolved-ops.js';
 
 /**
  * Prefix mapping for generating realistic ID fixture values.
@@ -24,8 +25,18 @@ export const ID_PREFIXES: Record<string, string> = {
 
 /**
  * Generate JSON fixture files for test data.
+ *
+ * Scoped runs only emit a fixture for a model whose per-model fixture FILE will
+ * exist on disk after the run (in-scope, or already present from a prior run —
+ * the fixture path is per-model so the prior manifest records it directly).
+ * This drops brand-new out-of-scope fixtures (the round-trip ADDITION case) and
+ * keeps prior fixtures untouched, mirroring the Rust fixtures fix. `ctx` is
+ * optional so unit tests that assert raw content can call it for a full run.
  */
-export function generateFixtures(spec: { models: Model[]; enums: Enum[]; services: any[] }): {
+export function generateFixtures(
+  spec: { models: Model[]; enums: Enum[]; services: any[] },
+  ctx?: EmitterContext,
+): {
   files: { path: string; content: string }[];
   pathRewrites: Map<string, string>;
 } {
@@ -38,14 +49,21 @@ export function generateFixtures(spec: { models: Model[]; enums: Enum[]; service
   const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
   const listMetadataNeeded = collectReferencedListMetadataModels(spec.models, nonPaginatedRefs);
 
+  // Full run (no ctx / no scoping): every fixture is in scope.
+  const fixtureInScope = (relPath: string, modelName: string): boolean =>
+    !ctx || fileExistsAfterRun(relPath, isModelInScope(modelName, ctx), ctx);
+
   for (const model of spec.models) {
     if (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
     if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
 
+    const path = `testdata/${fileName(model.name)}.json`;
+    if (!fixtureInScope(path, model.name)) continue;
+
     const fixture = model.fields.length === 0 ? {} : generateModelFixture(model, modelMap, enumMap);
 
     files.push({
-      path: `testdata/${fileName(model.name)}.json`,
+      path,
       content: JSON.stringify(fixture, null, 2),
     });
   }
@@ -67,6 +85,10 @@ export function generateFixtures(spec: { models: Model[]; enums: Enum[]; service
           const path = `testdata/list_${fileName(itemModel.name)}.json`;
           if (seenListPaths.has(path)) continue;
           seenListPaths.add(path);
+          // Scoped run: only emit a list fixture whose file will exist after the
+          // run (in-scope item model, or already on disk). Keyed on the item
+          // model so an out-of-scope paginated endpoint doesn't add a new file.
+          if (!fixtureInScope(path, itemModel.name)) continue;
           const fixture = generateModelFixture(itemModel, modelMap, enumMap);
           const listFixture = {
             data: [fixture],