@workos/oagen-emitters 0.19.0 → 0.19.1

package/test/go/scoping.test.ts

@@ -0,0 +1,324 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import type { EmitterContext, ApiSpec, Model, Enum } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { generateModels } from '../../src/go/models.js';
+import { generateEnums } from '../../src/go/enums.js';
+
+const emptySpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [],
+  models: [],
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+function strField(name: string, required = true) {
+  return { name, type: { kind: 'primitive', type: 'string' } as const, required };
+}
+
+let outputDir: string;
+
+beforeEach(() => {
+  outputDir = mkdtempSync(join(tmpdir(), 'oagen-go-scope-'));
+});
+afterEach(() => {
+  rmSync(outputDir, { recursive: true, force: true });
+});
+
+/** Build a scoped EmitterContext pointing at the temp outputDir. */
+function scopedCtx(opts: {
+  spec?: ApiSpec;
+  scopedServices: string[];
+  scopedModelNames?: string[];
+  scopedEnumNames?: string[];
+  priorManifestPaths: string[];
+}): EmitterContext {
+  return {
+    namespace: 'workos',
+    namespacePascal: 'WorkOS',
+    spec: opts.spec ?? emptySpec,
+    outputDir,
+    scopedServices: new Set(opts.scopedServices),
+    scopedModelNames: opts.scopedModelNames ? new Set(opts.scopedModelNames) : undefined,
+    scopedEnumNames: opts.scopedEnumNames ? new Set(opts.scopedEnumNames) : undefined,
+    priorTargetManifestPaths: new Set(opts.priorManifestPaths),
+  };
+}
+
+function writePrior(relPath: string, content: string) {
+  const abs = join(outputDir, relPath);
+  mkdirSync(join(abs, '..'), { recursive: true });
+  writeFileSync(abs, content, 'utf-8');
+}
+
+describe('go scoped flat-file reconciliation (models.go)', () => {
+  it('drops a brand-new out-of-scope model (ADDITION fix / Option B)', () => {
+    // Prior models.go has only InScopeThing. The new spec adds OutOfScopeNew,
+    // which belongs to a service NOT selected this run.
+    writePrior(
+      'models.go',
+      [
+        '// Code generated by oagen. DO NOT EDIT.',
+        '',
+        'package workos',
+        '',
+        '// InScopeThing represents an in scope thing.',
+        'type InScopeThing struct {',
+        '\tID string `json:"id"`',
+        '}',
+        '',
+      ].join('\n'),
+    );
+
+    const models: Model[] = [
+      { name: 'InScopeThing', fields: [strField('id')] },
+      // Structurally distinct so a "missing" result can't be confused with dedup.
+      { name: 'OutOfScopeNew', fields: [strField('id'), strField('extra')] },
+    ];
+    const ctx = scopedCtx({
+      scopedServices: ['InScope'],
+      scopedModelNames: ['InScopeThing'], // OutOfScopeNew NOT in scope
+      priorManifestPaths: ['models.go'],
+    });
+
+    const content = generateModels(models, ctx)[0].content;
+    expect(content).toContain('type InScopeThing struct {');
+    // Brand-new out-of-scope model must NOT be added to the flat file.
+    expect(content).not.toContain('OutOfScopeNew');
+  });
+
+  it('retains a renamed/removed type still referenced by out-of-scope code (REMOVAL fix)', () => {
+    // Prior models.go has OrganizationDomainStandAlone. The new spec renamed it
+    // to OrganizationDomain (so the old name is gone from the model set), and
+    // OrganizationDomain belongs to an out-of-scope service. The old name must
+    // be carried over so out-of-scope resource code keeps compiling.
+    writePrior(
+      'models.go',
+      [
+        '// Code generated by oagen. DO NOT EDIT.',
+        '',
+        'package workos',
+        '',
+        '// InScopeThing represents an in scope thing.',
+        'type InScopeThing struct {',
+        '\tID string `json:"id"`',
+        '}',
+        '',
+        '// OrganizationDomainStandAlone represents an organization domain stand alone.',
+        'type OrganizationDomainStandAlone struct {',
+        '\tID string `json:"id"`',
+        '\tDomain string `json:"domain"`',
+        '}',
+        '',
+      ].join('\n'),
+    );
+
+    const models: Model[] = [
+      { name: 'InScopeThing', fields: [strField('id')] },
+      // The renamed model exists in the new spec but is out of scope this run.
+      { name: 'OrganizationDomain', fields: [strField('id'), strField('domain')] },
+    ];
+    const ctx = scopedCtx({
+      scopedServices: ['InScope'],
+      scopedModelNames: ['InScopeThing'],
+      priorManifestPaths: ['models.go'],
+    });
+
+    const content = generateModels(models, ctx)[0].content;
+    expect(content).toContain('type InScopeThing struct {');
+    // The renamed-away type is preserved verbatim from the prior file.
+    expect(content).toContain('type OrganizationDomainStandAlone struct {');
+    // The new out-of-scope rename is NOT freshly added (it didn't exist before).
+    expect(content).not.toContain('type OrganizationDomain struct {');
+  });
+
+  it('regenerates an in-scope model with its new fields', () => {
+    writePrior(
+      'models.go',
+      [
+        'package workos',
+        '',
+        '// InScopeThing represents an in scope thing.',
+        'type InScopeThing struct {',
+        '\tID string `json:"id"`',
+        '}',
+        '',
+      ].join('\n'),
+    );
+
+    const models: Model[] = [{ name: 'InScopeThing', fields: [strField('id'), strField('new_field')] }];
+    const ctx = scopedCtx({
+      scopedServices: ['InScope'],
+      scopedModelNames: ['InScopeThing'],
+      priorManifestPaths: ['models.go'],
+    });
+
+    const content = generateModels(models, ctx)[0].content;
+    expect(content).toContain('NewField string `json:"new_field"`');
+  });
+
+  it('force-retains an out-of-scope canonical referenced by an in-scope alias', () => {
+    // Two structurally-identical models. The alphabetically-first is the dedup
+    // canonical but is brand-new AND out of scope; the other is in scope and is
+    // emitted as `type InScopeAliasModel = AaaCanonical`. Without force-retain
+    // the canonical would be dropped, leaving the alias dangling
+    // (undefined: AaaCanonical) and the package failing to build.
+    writePrior('models.go', ['package workos', ''].join('\n'));
+
+    const fields = [strField('id'), strField('label')];
+    const models: Model[] = [
+      { name: 'AaaCanonical', fields }, // sorts first -> canonical; out of scope, brand-new
+      { name: 'InScopeAliasModel', fields }, // in scope -> alias to AaaCanonical
+    ];
+    const ctx = scopedCtx({
+      scopedServices: ['InScope'],
+      scopedModelNames: ['InScopeAliasModel'],
+      priorManifestPaths: ['models.go'],
+    });
+
+    const content = generateModels(models, ctx)[0].content;
+    expect(content).toContain('type InScopeAliasModel = AaaCanonical');
+    // The canonical must be present so the alias resolves.
+    expect(content).toContain('type AaaCanonical struct {');
+  });
+
+  it('full run (no scoping) emits every model unchanged', () => {
+    const models: Model[] = [
+      { name: 'InScopeThing', fields: [strField('id')] },
+      // Structurally distinct so it isn't deduped into a type alias.
+      { name: 'OutOfScopeNew', fields: [strField('id'), strField('extra')] },
+    ];
+    const ctx: EmitterContext = { namespace: 'workos', namespacePascal: 'WorkOS', spec: emptySpec };
+    const content = generateModels(models, ctx)[0].content;
+    expect(content).toContain('type InScopeThing struct {');
+    expect(content).toContain('type OutOfScopeNew struct {');
+  });
+});
+
+describe('go scoped flat-file reconciliation (enums.go)', () => {
+  it('drops a brand-new out-of-scope enum and retains a renamed-away one', () => {
+    writePrior(
+      'enums.go',
+      [
+        'package workos',
+        '',
+        '// InScopeStatus represents in scope status values.',
+        'type InScopeStatus string',
+        '',
+        'const (',
+        '\tInScopeStatusActive InScopeStatus = "active"',
+        ')',
+        '',
+        '// OldRenamedState represents old renamed state values.',
+        'type OldRenamedState string',
+        '',
+        'const (',
+        '\tOldRenamedStatePending OldRenamedState = "pending"',
+        ')',
+        '',
+      ].join('\n'),
+    );
+
+    const enums: Enum[] = [
+      { name: 'InScopeStatus', values: [{ name: 'active', value: 'active' }] },
+      // brand-new, out of scope
+      { name: 'OutOfScopeNewEnum', values: [{ name: 'x', value: 'x' }] },
+      // renamed away: OldRenamedState -> NewRenamedState (out of scope)
+      { name: 'NewRenamedState', values: [{ name: 'pending', value: 'pending' }] },
+    ];
+    const ctx = scopedCtx({
+      scopedServices: ['InScope'],
+      scopedEnumNames: ['InScopeStatus'],
+      priorManifestPaths: ['enums.go'],
+    });
+
+    const content = generateEnums(enums, ctx).find((f) => f.path === 'enums.go')!.content;
+    expect(content).toContain('type InScopeStatus string');
+    // brand-new out-of-scope enum dropped
+    expect(content).not.toContain('type OutOfScopeNewEnum string');
+    // renamed-away enum retained verbatim from prior file
+    expect(content).toContain('type OldRenamedState string');
+    // the new (out-of-scope) name is not freshly added
+    expect(content).not.toContain('type NewRenamedState string');
+  });
+
+  it('force-retains an out-of-scope canonical enum referenced by an in-scope alias', () => {
+    writePrior('enums.go', ['package workos', ''].join('\n'));
+
+    const enums: Enum[] = [
+      // identical values -> deduped; alphabetically-first is the canonical
+      { name: 'AaaCanonicalStatus', values: [{ name: 'active', value: 'active' }] }, // out of scope, brand-new
+      { name: 'InScopeAliasStatus', values: [{ name: 'active', value: 'active' }] }, // in scope -> alias
+    ];
+    const ctx = scopedCtx({
+      scopedServices: ['InScope'],
+      scopedEnumNames: ['InScopeAliasStatus'],
+      priorManifestPaths: ['enums.go'],
+    });
+
+    const content = generateEnums(enums, ctx).find((f) => f.path === 'enums.go')!.content;
+    expect(content).toContain('type InScopeAliasStatus = AaaCanonicalStatus');
+    // The canonical enum must be present so the alias resolves.
+    expect(content).toContain('type AaaCanonicalStatus string');
+  });
+});
+
+describe('go scoped flat-file reconciliation (events.go)', () => {
+  it('keeps the prior event const set: drops new events, retains existing', () => {
+    writePrior(
+      'pkg/events/events.go',
+      [
+        'package events',
+        '',
+        '// Event is a WorkOS event type.',
+        'type Event string',
+        '',
+        'const (',
+        '\tOrganizationCreated = "organization.created"',
+        ')',
+        '',
+      ].join('\n'),
+    );
+
+    const enums: Enum[] = [
+      {
+        name: 'CreateWebhookEndpointEvents',
+        values: [
+          { name: 'organization.created', value: 'organization.created' },
+          // brand-new event from an out-of-scope service
+          { name: 'session.reauthenticated', value: 'session.reauthenticated' },
+        ],
+      },
+    ];
+    const ctx = scopedCtx({
+      scopedServices: ['InScope'],
+      priorManifestPaths: ['pkg/events/events.go'],
+    });
+
+    const events = generateEnums(enums, ctx).find((f) => f.path === 'pkg/events/events.go')!.content;
+    expect(events).toContain('OrganizationCreated = "organization.created"');
+    // brand-new out-of-scope event must not be added to the flat events file
+    expect(events).not.toContain('session.reauthenticated');
+  });
+
+  it('full run emits all events', () => {
+    const enums: Enum[] = [
+      {
+        name: 'CreateWebhookEndpointEvents',
+        values: [
+          { name: 'organization.created', value: 'organization.created' },
+          { name: 'session.reauthenticated', value: 'session.reauthenticated' },
+        ],
+      },
+    ];
+    const ctx: EmitterContext = { namespace: 'workos', namespacePascal: 'WorkOS', spec: emptySpec };
+    const events = generateEnums(enums, ctx).find((f) => f.path === 'pkg/events/events.go')!.content;
+    expect(events).toContain('organization.created');
+    expect(events).toContain('session.reauthenticated');
+  });
+});

package/test/kotlin/models.test.ts

@@ -101,6 +101,80 @@ describe('kotlin/models', () => {
     expect(filePaths.some((p) => p.includes('ListMetadata.kt'))).toBe(false);
   });
 
+  it('scoped run: WorkOSEvent registry omits brand-new out-of-scope events but retains on-disk ones', () => {
+    // An event envelope model: id + event(literal) + created_at + data.
+    const eventModel = (name: string, wire: string): Model => ({
+      name,
+      fields: [
+        { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'event', type: { kind: 'literal', value: wire }, required: true },
+        { name: 'created_at', type: { kind: 'primitive', type: 'string', format: 'date-time' }, required: true },
+        { name: 'data', type: { kind: 'map', valueType: { kind: 'primitive', type: 'unknown' } }, required: true },
+      ],
+    });
+
+    const models: Model[] = [
+      eventModel('OrganizationMembershipCreated', 'organization_membership.created'), // in scope
+      eventModel('SessionReauthenticated', 'session.reauthenticated'), // brand-new, out of scope, NOT on disk
+      eventModel('PipesConnectedAccountConnectionFailed', 'connected_account.connection_failed'), // out of scope, ON disk
+    ];
+    const spec: ApiSpec = { ...emptySpec, models };
+
+    // Scoped run: only OrganizationMembershipCreated is in scope this run.
+    // PipesConnectedAccountConnectionFailed is out of scope but its .kt file is
+    // still on disk (recorded in the prior manifest), so it must be retained.
+    // SessionReauthenticated is brand new + out of scope ⇒ its file is never
+    // emitted ⇒ it must be omitted from the registry.
+    const scopedCtx: EmitterContext = {
+      ...ctx,
+      spec,
+      scopedServices: new Set(['OrganizationMembership']),
+      scopedModelNames: new Set(['OrganizationMembershipCreated']),
+      priorTargetManifestPaths: new Set(['src/main/kotlin/com/workos/models/PipesConnectedAccountConnectionFailed.kt']),
+    };
+
+    generateEnums([], scopedCtx);
+    const files = generateModels(models, scopedCtx);
+
+    const registry = files.find((f) => f.path.endsWith('WorkOSEvent.kt'));
+    expect(registry).toBeDefined();
+    const content = registry!.content;
+
+    // In scope ⇒ listed.
+    expect(content).toContain('OrganizationMembershipCreated::class');
+    // Out of scope but on disk ⇒ retained.
+    expect(content).toContain('PipesConnectedAccountConnectionFailed::class');
+    // Brand-new + out of scope ⇒ omitted (this was the build break).
+    expect(content).not.toContain('SessionReauthenticated::class');
+
+    // The per-model FILE for the out-of-scope events must NOT be emitted.
+    expect(files.some((f) => f.path.endsWith('SessionReauthenticated.kt'))).toBe(false);
+    expect(files.some((f) => f.path.endsWith('PipesConnectedAccountConnectionFailed.kt'))).toBe(false);
+  });
+
+  it('full run: WorkOSEvent registry lists every event model', () => {
+    const eventModel = (name: string, wire: string): Model => ({
+      name,
+      fields: [
+        { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'event', type: { kind: 'literal', value: wire }, required: true },
+        { name: 'created_at', type: { kind: 'primitive', type: 'string', format: 'date-time' }, required: true },
+        { name: 'data', type: { kind: 'map', valueType: { kind: 'primitive', type: 'unknown' } }, required: true },
+      ],
+    });
+    const models: Model[] = [
+      eventModel('OrganizationMembershipCreated', 'organization_membership.created'),
+      eventModel('SessionReauthenticated', 'session.reauthenticated'),
+    ];
+    const spec: ApiSpec = { ...emptySpec, models };
+
+    generateEnums([], { ...ctx, spec });
+    const files = generateModels(models, { ...ctx, spec });
+    const registry = files.find((f) => f.path.endsWith('WorkOSEvent.kt'))!;
+    expect(registry.content).toContain('OrganizationMembershipCreated::class');
+    expect(registry.content).toContain('SessionReauthenticated::class');
+  });
+
   it('deduplicates structurally identical models preferring shorter names', () => {
     const models: Model[] = [
       {

package/test/kotlin/tests.test.ts

@@ -142,6 +142,39 @@ describe('kotlin/tests', () => {
     expect(content).toContain('assertEquals(parsed.toInstant(), reparsed.toInstant())');
   });
 
+  it('scoped run: round-trip test omits brand-new out-of-scope models, retains on-disk ones', () => {
+    const roundTripModel = (name: string): Model => ({
+      name,
+      fields: [
+        { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+      ],
+    });
+    const scopedModels: Model[] = [
+      roundTripModel('Organization'), // in scope
+      roundTripModel('PipesPipe'), // brand-new, out of scope, NOT on disk
+      roundTripModel('Directory'), // out of scope but ON disk
+    ];
+    const scopedSpec: ApiSpec = { ...spec, models: scopedModels };
+    const scopedCtx: EmitterContext = {
+      ...ctx,
+      spec: scopedSpec,
+      resolvedOperations: buildResolvedOps(services),
+      scopedServices: new Set(['Organizations']),
+      scopedModelNames: new Set(['Organization']),
+      priorTargetManifestPaths: new Set(['src/main/kotlin/com/workos/models/Directory.kt']),
+    };
+
+    generateEnums([], scopedCtx);
+    const files = generateTests(scopedSpec, scopedCtx);
+    const roundTrip = files.find((f) => f.path.includes('GeneratedModelRoundTripTest.kt'))!;
+    const content = roundTrip.content;
+
+    expect(content).toContain('Organization round-trips through Jackson');
+    expect(content).toContain('Directory round-trips through Jackson'); // retained (on disk)
+    expect(content).not.toContain('PipesPipe round-trips through Jackson'); // omitted (brand-new)
+  });
+
   it('emits valid ISO-8601 for date-time fields in round-trip fixtures', () => {
     const dtModels: Model[] = [
       {

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

@@ -0,0 +1,205 @@
+import { describe, it, expect } from 'vitest';
+import { generateModels } from '../../src/python/models.js';
+import { generateTests } from '../../src/python/tests.js';
+import type { EmitterContext, ApiSpec, Service, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+
+// A scoped run selects the `Widgets` mount and pulls in only `WidgetA`. The
+// spec ALSO contains models belonging to the out-of-scope `Gadgets` service:
+//   - GadgetBrandNew  : brand-new, NOT in the prior manifest  → must NOT be
+//                       referenced by any aggregate (the ADDITION bug).
+//   - GadgetOnDisk    : already on disk (recorded in the prior manifest) →
+//                       must be RETAINED by the barrel.
+// The prior manifest also records `gadget_renamed.py`, a per-model file for a
+// model that the current spec no longer produces (renamed/removed) → must be
+// RETAINED via a wholesale `import *` so stale out-of-scope code still resolves.
+const services: Service[] = [
+  {
+    name: 'Widgets',
+    operations: [
+      {
+        name: 'getWidget',
+        httpMethod: 'get',
+        path: '/widgets/{id}',
+        pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+        queryParams: [],
+        headerParams: [],
+        response: { kind: 'model', name: 'WidgetA' },
+        errors: [],
+        injectIdempotencyKey: false,
+      },
+    ],
+  },
+  {
+    name: 'Gadgets',
+    operations: [
+      {
+        name: 'getGadgetBrandNew',
+        httpMethod: 'get',
+        path: '/gadgets/brand-new/{id}',
+        pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+        queryParams: [],
+        headerParams: [],
+        response: { kind: 'model', name: 'GadgetBrandNew' },
+        errors: [],
+        injectIdempotencyKey: false,
+      },
+      {
+        name: 'getGadgetOnDisk',
+        httpMethod: 'get',
+        path: '/gadgets/on-disk/{id}',
+        pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+        queryParams: [],
+        headerParams: [],
+        response: { kind: 'model', name: 'GadgetOnDisk' },
+        errors: [],
+        injectIdempotencyKey: false,
+      },
+    ],
+  },
+];
+
+const models: Model[] = [
+  {
+    name: 'WidgetA',
+    fields: [
+      { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+      { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+    ],
+  },
+  {
+    name: 'GadgetBrandNew',
+    fields: [
+      { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+      { name: 'color', type: { kind: 'primitive', type: 'string' }, required: true },
+    ],
+  },
+  {
+    name: 'GadgetOnDisk',
+    fields: [
+      { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+      { name: 'size', type: { kind: 'primitive', type: 'string' }, required: true },
+    ],
+  },
+];
+
+const spec: ApiSpec = {
+  name: 'TestAPI',
+  version: '1.0.0',
+  baseUrl: 'https://api.workos.com',
+  services,
+  models,
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+// Scoped to the Widgets mount: only WidgetA is in-scope. The prior manifest
+// records GadgetOnDisk's file plus a now-removed gadget_renamed.py file.
+function scopedCtx(): EmitterContext {
+  return {
+    namespace: 'workos',
+    namespacePascal: 'WorkOS',
+    spec,
+    scopedServices: new Set(['Widgets']),
+    scopedModelNames: new Set(['WidgetA']),
+    scopedEnumNames: new Set<string>(),
+    priorTargetManifestPaths: new Set([
+      'src/workos/widgets/models/widget_a.py',
+      'src/workos/gadgets/models/gadget_on_disk.py',
+      'src/workos/gadgets/models/gadget_renamed.py',
+      // Fixtures live under tests/fixtures/ and are recorded in the manifest too;
+      // the on-disk gadget's fixture is retained the same way its model file is.
+      'tests/fixtures/widget_a.json',
+      'tests/fixtures/gadget_on_disk.json',
+    ]),
+  } as EmitterContext;
+}
+
+describe('python scoped aggregates', () => {
+  describe('models barrel (__init__.py)', () => {
+    it('writes only the in-scope per-model file', () => {
+      const files = generateModels(models, scopedCtx());
+      const modelFiles = files.filter((f) => f.path.endsWith('.py') && f.path.includes('/models/'));
+      const writtenModelFiles = modelFiles.filter((f) => !f.path.endsWith('__init__.py'));
+      // Only WidgetA's file is emitted; the two out-of-scope gadget files are not.
+      expect(writtenModelFiles.map((f) => f.path)).toEqual(['src/workos/widgets/models/widget_a.py']);
+    });
+
+    it('does NOT reference a brand-new out-of-scope model in any barrel (ADDITION fix)', () => {
+      const files = generateModels(models, scopedCtx());
+      const barrels = files.filter((f) => f.path.endsWith('__init__.py'));
+      for (const barrel of barrels) {
+        expect(barrel.content).not.toContain('GadgetBrandNew');
+        expect(barrel.content).not.toContain('gadget_brand_new');
+      }
+    });
+
+    it('RETAINS an on-disk out-of-scope model in its barrel (no dangling drop)', () => {
+      const files = generateModels(models, scopedCtx());
+      const gadgetBarrel = files.find((f) => f.path === 'src/workos/gadgets/models/__init__.py');
+      expect(gadgetBarrel).toBeDefined();
+      // GadgetOnDisk is still in the spec but out of scope; its file already
+      // exists on disk (prior manifest), so the barrel keeps re-exporting it.
+      expect(gadgetBarrel!.content).toContain('from .gadget_on_disk import GadgetOnDisk as GadgetOnDisk');
+    });
+
+    it('RETAINS a renamed/removed on-disk file via wholesale import (REMOVAL fix)', () => {
+      const files = generateModels(models, scopedCtx());
+      const gadgetBarrel = files.find((f) => f.path === 'src/workos/gadgets/models/__init__.py');
+      expect(gadgetBarrel).toBeDefined();
+      // gadget_renamed.py is on disk (prior manifest) but no longer produced by
+      // the spec; retain it wholesale so stale out-of-scope imports resolve.
+      expect(gadgetBarrel!.content).toContain('from .gadget_renamed import *  # noqa: F401,F403');
+    });
+
+    it('still references the in-scope model in its own barrel', () => {
+      const files = generateModels(models, scopedCtx());
+      const widgetBarrel = files.find((f) => f.path === 'src/workos/widgets/models/__init__.py');
+      expect(widgetBarrel).toBeDefined();
+      expect(widgetBarrel!.content).toContain('from .widget_a import WidgetA as WidgetA');
+    });
+  });
+
+  describe('round-trip test + fixtures', () => {
+    it('does not reference or fixture a brand-new out-of-scope model', () => {
+      const files = generateTests(spec, scopedCtx());
+      const roundTrip = files.find((f) => f.path === 'tests/test_models_round_trip.py');
+      expect(roundTrip).toBeDefined();
+      expect(roundTrip!.content).not.toContain('GadgetBrandNew');
+      // No fixture for the brand-new out-of-scope model.
+      expect(files.find((f) => f.path === 'tests/fixtures/gadget_brand_new.json')).toBeUndefined();
+    });
+
+    it('keeps the in-scope model and retains the on-disk out-of-scope model', () => {
+      const files = generateTests(spec, scopedCtx());
+      const roundTrip = files.find((f) => f.path === 'tests/test_models_round_trip.py');
+      expect(roundTrip!.content).toContain('WidgetA');
+      // GadgetOnDisk's per-model file exists on disk (prior manifest), so the
+      // round-trip test may still import it and its fixture is emitted.
+      expect(roundTrip!.content).toContain('GadgetOnDisk');
+      expect(files.find((f) => f.path === 'tests/fixtures/gadget_on_disk.json')).toBeDefined();
+      expect(files.find((f) => f.path === 'tests/fixtures/widget_a.json')).toBeDefined();
+    });
+  });
+
+  describe('full (non-scoped) run is unaffected', () => {
+    it('references every model in its barrel and round-trip test', () => {
+      const fullCtx: EmitterContext = {
+        namespace: 'workos',
+        namespacePascal: 'WorkOS',
+        spec,
+      };
+      const modelFiles = generateModels(models, fullCtx);
+      const gadgetBarrel = modelFiles.find((f) => f.path === 'src/workos/gadgets/models/__init__.py');
+      expect(gadgetBarrel!.content).toContain('GadgetBrandNew');
+      expect(gadgetBarrel!.content).toContain('GadgetOnDisk');
+      // No retention import on a full run.
+      expect(gadgetBarrel!.content).not.toContain('import *');
+
+      const testFiles = generateTests(spec, fullCtx);
+      const roundTrip = testFiles.find((f) => f.path === 'tests/test_models_round_trip.py');
+      expect(roundTrip!.content).toContain('GadgetBrandNew');
+      expect(testFiles.find((f) => f.path === 'tests/fixtures/gadget_brand_new.json')).toBeDefined();
+    });
+  });
+});