@workos/oagen-emitters 0.5.0 → 0.6.0

package/dist/plugin.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -40,20 +40,20 @@
   "devDependencies": {
     "@commitlint/cli": "^20.5.0",
     "@commitlint/config-conventional": "^20.5.0",
-    "@types/node": "^25.3.3",
+    "@types/node": "^25.6.0",
     "husky": "^9.1.7",
-    "oxfmt": "^0.45.0",
-    "oxlint": "^1.51.0",
-    "prettier": "^3.8.1",
-    "tsdown": "^0.21.5",
-    "tsx": "^4.19.0",
-    "typescript": "^6.0.0-dev.20260324",
-    "vitest": "^3.0.0"
+    "oxfmt": "^0.46.0",
+    "oxlint": "^1.61.0",
+    "prettier": "^3.8.3",
+    "tsdown": "^0.21.10",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
   },
   "engines": {
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.7.0"
+    "@workos/oagen": "^0.9.0"
   }
 }

package/smoke/sdk-dotnet.ts

@@ -152,15 +152,21 @@ function createProxyServer(apiKey: string, captures: ProxyCapture[]): Promise<{
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
-    console.warn('  Method resolution will rely on heuristic tiers — most operations may be skipped.');
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-elixir.ts

@@ -196,15 +196,21 @@ function startProxy(
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
-    console.warn('  Method resolution will rely on heuristic tiers — most operations may be skipped.');
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-go.ts

@@ -126,15 +126,21 @@ function goFieldName(name: string): string {
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
     console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-kotlin.ts

@@ -175,15 +175,21 @@ function createProxyServer(
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
-    console.warn('  Method resolution will rely on heuristic tiers — most operations may be skipped.');
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-node.ts

@@ -107,15 +107,21 @@ function restoreFetch(): void {
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`⚠ No smoke-manifest.json found at ${manifestPath}`);
-    console.warn('  Method resolution will rely on heuristic tiers — most operations may be skipped.');
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-php.ts

@@ -166,14 +166,19 @@ class CaptureProxy {
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-python.ts

@@ -191,15 +191,21 @@ function createProxyServer(
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
     console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-ruby.ts

@@ -78,15 +78,21 @@ interface MethodResolution {
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
     console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-rust.ts

@@ -167,15 +167,21 @@ function createProxyServer(
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
-    console.warn('  Method resolution will rely on heuristic tiers — most operations may be skipped.');
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/src/dotnet/index.ts

@@ -17,7 +17,7 @@ import { generateEnums, primeEnumAliases } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 import { generateWrapperOptionsClasses } from './wrappers.js';
 import { groupByMount } from '../shared/resolved-ops.js';
 import { discriminatedUnions } from './type-map.js';
@@ -206,8 +206,8 @@ export const dotnetEmitter: Emitter = {
     return prefixTestPaths(ensureTrailingNewlines(generateTests(spec, c)));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateManifest(spec, fixNamespace(ctx)));
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
+    return buildOperationsMap(spec, fixNamespace(ctx));
   },
 
   fileHeader(): string {

package/src/dotnet/manifest.ts

@@ -1,13 +1,13 @@
-import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
 import { resolveMethodName } from './naming.js';
 import { buildServiceAccessPaths } from './client.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
 
 /**
- * Generate smoke test manifest mapping HTTP operations to SDK methods.
+ * Build operation-to-SDK-method mapping for the manifest.
  */
-export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-  const manifest: Record<string, { sdkMethod: string; service: string }> = {};
+export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
+  const manifest: OperationsMap = {};
   const accessPaths = buildServiceAccessPaths(spec.services, ctx);
 
   for (const service of spec.services) {
@@ -26,11 +26,5 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     }
   }
 
-  return [
-    {
-      path: 'smoke-manifest.json',
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false,
-    },
-  ];
+  return manifest;
 }

package/src/go/index.ts

@@ -15,7 +15,7 @@ import { generateEnums } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 
 /** Ensure every generated file's content ends with a trailing newline. */
 function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
@@ -64,8 +64,8 @@ export const goEmitter: Emitter = {
     return ensureTrailingNewlines(generateTests(spec, ctx));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateManifest(spec, ctx));
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
+    return buildOperationsMap(spec, ctx);
   },
 
   fileHeader(): string {

package/src/go/manifest.ts

@@ -1,13 +1,13 @@
-import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
 import { resolveMethodName } from './naming.js';
 import { buildServiceAccessPaths } from './client.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
 
 /**
- * Generate smoke test manifest mapping HTTP operations to SDK methods.
+ * Build operation-to-SDK-method mapping for the manifest.
  */
-export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-  const manifest: Record<string, { sdkMethod: string; service: string }> = {};
+export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
+  const manifest: OperationsMap = {};
   const accessPaths = buildServiceAccessPaths(spec.services, ctx);
 
   for (const service of spec.services) {
@@ -26,11 +26,5 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     }
   }
 
-  return [
-    {
-      path: 'smoke-manifest.json',
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false,
-    },
-  ];
+  return manifest;
 }

package/src/kotlin/index.ts

@@ -16,7 +16,7 @@ import { generateEnums } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
 
 /** Ensure every generated file ends with a trailing newline. */
@@ -69,8 +69,8 @@ export const kotlinEmitter: Emitter = {
     return ensureTrailingNewlines(generateTests(enrichedSpec, { ...ctx, spec: enrichedSpec }));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateManifest(spec, ctx));
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
+    return buildOperationsMap(spec, ctx);
   },
 
   fileHeader(): string {

package/src/kotlin/manifest.ts

@@ -1,20 +1,20 @@
-import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
 import { resolveMethodName, servicePropertyName, resolveClassName } from './naming.js';
 import { buildResolvedLookup, lookupResolved, getMountTarget } from '../shared/resolved-ops.js';
 import { propertyName } from './naming.js';
 import { isHandwrittenOverride } from './overrides.js';
 
 /**
- * Generate the smoke-test manifest mapping `"HTTP_METHOD /path"` to
- * `{ sdkMethod, service }`. The `service` is the camelCase accessor property
- * on the main `WorkOS` client (e.g., `organizations`).
+ * Build the operation-to-SDK-method mapping for the manifest.
+ *
+ * The `service` is the camelCase accessor property on the main `WorkOS`
+ * client (e.g., `organizations`).
  *
  * For polymorphic/split operations (e.g., authenticate -> 8 methods), the
- * manifest emits one entry per wrapper method so each variant is addressable.
+ * manifest emits an array of methods so each variant is addressable.
  */
-export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-  const manifest: Record<string, { sdkMethod: string; service: string } | { sdkMethod: string; service: string }[]> =
-    {};
+export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
+  const manifest: OperationsMap = {};
   const resolvedLookup = buildResolvedLookup(ctx);
 
   for (const service of spec.services) {
@@ -45,11 +45,5 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     }
   }
 
-  return [
-    {
-      path: 'smoke-manifest.json',
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false,
-    },
-  ];
+  return manifest;
 }

package/src/node/index.ts

@@ -18,7 +18,7 @@ import { generateClient } from './client.js';
 import { generateErrors } from './errors.js';
 
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 
 /** Ensure every generated file's content ends with a trailing newline. */
 function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
@@ -62,8 +62,8 @@ export const nodeEmitter: Emitter = {
     return ensureTrailingNewlines(generateTests(spec, ctx));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateManifest(spec, ctx));
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
+    return buildOperationsMap(spec, ctx);
   },
 
   fileHeader(): string {

package/src/node/manifest.ts

@@ -1,9 +1,9 @@
-import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
 import { resolveMethodName, servicePropertyName } from './naming.js';
 import { resolveResourceClassName } from './resources.js';
 
-export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-  const manifest: Record<string, { sdkMethod: string; service: string }> = {};
+export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
+  const manifest: OperationsMap = {};
 
   for (const service of spec.services) {
     const propName = servicePropertyName(resolveResourceClassName(service, ctx));
@@ -14,12 +14,5 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     }
   }
 
-  return [
-    {
-      path: 'smoke-manifest.json',
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false,
-      overwriteExisting: true,
-    },
-  ];
+  return manifest;
 }

package/src/php/index.ts

@@ -16,7 +16,7 @@ import { generateEnums } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 import { initializeEnumDedup } from './naming.js';
 
 /** Initialize enum deduplication from spec data. */
@@ -71,9 +71,9 @@ export const phpEmitter: Emitter = {
     return ensureTrailingNewlines(generateTests(spec, ctx));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
     ensureNamingInitialized(ctx);
-    return ensureTrailingNewlines(generateManifest(spec, ctx));
+    return buildOperationsMap(spec, ctx);
   },
 
   fileHeader(): string {

package/src/php/manifest.ts

@@ -1,13 +1,13 @@
-import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
 import { resolveMethodName } from './naming.js';
 import { buildServiceAccessPaths } from './client.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
 
 /**
- * Generate smoke test manifest mapping HTTP operations to SDK methods.
+ * Build operation-to-SDK-method mapping for the manifest.
  */
-export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-  const manifest: Record<string, { sdkMethod: string; service: string }> = {};
+export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
+  const manifest: OperationsMap = {};
   const accessPaths = buildServiceAccessPaths(spec.services, ctx);
 
   for (const service of spec.services) {
@@ -26,11 +26,5 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     }
   }
 
-  return [
-    {
-      path: 'smoke-manifest.json',
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false,
-    },
-  ];
+  return manifest;
 }

package/src/python/index.ts

@@ -15,7 +15,7 @@ import { generateEnums } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 /** Ensure every generated file's content ends with a trailing newline. */
 function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
   for (const f of files) {
@@ -81,8 +81,8 @@ export const pythonEmitter: Emitter = {
     return ensureTrailingNewlines(generateTests(testSpec, { ...ctx, spec: testSpec }));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateManifest(spec, ctx));
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
+    return buildOperationsMap(spec, ctx);
   },
 
   fileHeader(): string {

package/src/python/manifest.ts

@@ -1,13 +1,13 @@
-import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
 import { resolveMethodName } from './naming.js';
 import { buildServiceAccessPaths } from './client.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
 
 /**
- * Generate smoke test manifest mapping HTTP operations to SDK methods.
+ * Build operation-to-SDK-method mapping for the manifest.
  */
-export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-  const manifest: Record<string, { sdkMethod: string; service: string }> = {};
+export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
+  const manifest: OperationsMap = {};
   const accessPaths = buildServiceAccessPaths(spec.services, ctx);
 
   for (const service of spec.services) {
@@ -27,12 +27,5 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     }
   }
 
-  return [
-    {
-      path: 'smoke-manifest.json',
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false,
-      overwriteExisting: true,
-    },
-  ];
+  return manifest;
 }

package/src/ruby/index.ts

@@ -13,7 +13,7 @@ import { generateEnums } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 import { generateRbiFiles } from './rbi.js';
 
 /** Ensure every generated file's content ends with a trailing newline. */
@@ -61,8 +61,8 @@ export const rubyEmitter: Emitter = {
     return ensureTrailingNewlines(generateTests(spec, ctx));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateManifest(spec, ctx));
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
+    return buildOperationsMap(spec, ctx);
   },
 
   fileHeader(): string {