@workos/oagen 0.0.1 → 0.1.1

package/dist/cli/index.js

@@ -284,17 +284,26 @@ function buildInlineModel(name, schema) {
 
 // src/parser/schemas.ts
 function extractSchemas(schemas) {
-  const models = [];
   const enums = [];
-  if (!schemas) return { models, enums };
+  if (!schemas) return { models: [], enums };
+  const modelsByCleanName = /* @__PURE__ */ new Map();
   for (const [name, schema] of Object.entries(schemas)) {
     const pascalName = cleanSchemaName(toPascalCase(name));
     if (schema.enum) {
       enums.push(extractEnum(pascalName, schema));
     } else {
-      models.push(extractModel(pascalName, schema, schemas));
+      const model = extractModel(pascalName, schema, schemas);
+      const existing = modelsByCleanName.get(pascalName);
+      if (existing) {
+        if (model.fields.length > existing.fields.length) {
+          modelsByCleanName.set(pascalName, model);
+        }
+      } else {
+        modelsByCleanName.set(pascalName, model);
+      }
     }
   }
+  const models = [...modelsByCleanName.values()];
   const modelNames = new Set(models.map((m) => m.name));
   const inlineQueue = [...models];
   while (inlineQueue.length > 0) {
@@ -385,9 +394,9 @@ function extractNestedSchema(name, schema) {
       if (variant.properties && (variant.type === "object" || !variant.type)) {
         const requiredSet = new Set(variant.required ?? []);
         const fields = [];
-        for (const [fn, fs4] of Object.entries(variant.properties)) {
-          if (!fs4) continue;
-          fields.push(buildFieldFromSchema(fn, fs4, name, requiredSet));
+        for (const [fn, fs2] of Object.entries(variant.properties)) {
+          if (!fs2) continue;
+          fields.push(buildFieldFromSchema(fn, fs2, name, requiredSet));
         }
         const variantName = models.length === 0 ? name : `${name}${models.length + 1}`;
         models.push({ name: variantName, description: variant.description, fields });
@@ -398,18 +407,18 @@ function extractNestedSchema(name, schema) {
   if (schema.properties && (schema.type === "object" || !schema.type)) {
     const requiredSet = new Set(schema.required ?? []);
     const fields = [];
-    for (const [fn, fs4] of Object.entries(schema.properties)) {
-      if (!fs4) continue;
-      fields.push(buildFieldFromSchema(fn, fs4, name, requiredSet));
+    for (const [fn, fs2] of Object.entries(schema.properties)) {
+      if (!fs2) continue;
+      fields.push(buildFieldFromSchema(fn, fs2, name, requiredSet));
     }
     return [{ name, description: schema.description, fields }];
   }
   if (schema.type === "array" && schema.items?.properties) {
     const requiredSet = new Set(schema.items.required ?? []);
     const fields = [];
-    for (const [fn, fs4] of Object.entries(schema.items.properties)) {
-      if (!fs4) continue;
-      fields.push(buildFieldFromSchema(fn, fs4, name, requiredSet));
+    for (const [fn, fs2] of Object.entries(schema.items.properties)) {
+      if (!fs2) continue;
+      fields.push(buildFieldFromSchema(fn, fs2, name, requiredSet));
     }
     return [{ name, description: schema.items.description, fields }];
   }
@@ -724,6 +733,18 @@ function classifyAndExtractResponse(schema, contextName) {
   }
   return extractDirectResource(schema, contextName);
 }
+var KNOWN_DATA_PATHS = /* @__PURE__ */ new Set(["data", "items", "results", "records", "entries", "values", "nodes", "edges"]);
+var PAGINATION_METADATA_PATTERNS = [
+  "metadata",
+  "pagination",
+  "cursor",
+  "has_more",
+  "page_info",
+  "total",
+  "next_page",
+  "previous_page",
+  "offset"
+];
 function detectListEnvelope(schema) {
   const propSources = [];
   if (schema.allOf) {
@@ -740,17 +761,26 @@ function detectListEnvelope(schema) {
     Object.assign(mergedProps, source);
   }
   const arrayProps = [];
-  let nonArrayCount = 0;
+  const nonArrayKeys = [];
   for (const [key, propSchema] of Object.entries(mergedProps)) {
     if (!propSchema) continue;
     if (propSchema.type === "array") {
       arrayProps.push(key);
     } else {
-      nonArrayCount++;
+      nonArrayKeys.push(key);
     }
   }
-  if (arrayProps.length === 1 && nonArrayCount >= 1) {
-    return { isEnvelope: true, dataPath: arrayProps[0] };
+  if (arrayProps.length === 1 && nonArrayKeys.length >= 1) {
+    const arrayPropName = arrayProps[0];
+    if (KNOWN_DATA_PATHS.has(arrayPropName)) {
+      return { isEnvelope: true, dataPath: arrayPropName };
+    }
+    const hasPaginationCompanion = nonArrayKeys.some(
+      (key) => PAGINATION_METADATA_PATTERNS.some((pattern) => key.toLowerCase().includes(pattern))
+    );
+    if (hasPaginationCompanion) {
+      return { isEnvelope: true, dataPath: arrayPropName };
+    }
   }
   return { isEnvelope: false, dataPath: null };
 }
@@ -1015,15 +1045,15 @@ function extractOperations(paths, operationIdTransform) {
   if (!paths) return { services: [], inlineModels: [] };
   const serviceMap = /* @__PURE__ */ new Map();
   const inlineModels = [];
-  for (const [path8, pathItem] of Object.entries(paths)) {
+  for (const [path6, pathItem] of Object.entries(paths)) {
     const pathLevelParams = pathItem.parameters ?? [];
     for (const method of HTTP_METHODS) {
       const op = pathItem[method];
       if (!op) continue;
-      const serviceName = inferServiceName(path8, op.tags?.[0]);
+      const serviceName = inferServiceName(path6, op.tags?.[0]);
       const { operation, inlineModels: opModels } = buildOperation(
         method,
-        path8,
+        path6,
         op,
         pathLevelParams,
         operationIdTransform
@@ -1043,28 +1073,28 @@ function extractOperations(paths, operationIdTransform) {
   }));
   return { services, inlineModels };
 }
-function inferServiceName(path8, tag) {
+function inferServiceName(path6, tag) {
   if (tag) {
     return toPascalCase(tag);
   }
-  const segments = path8.split("/").filter(Boolean);
+  const segments = path6.split("/").filter(Boolean);
   const first = segments[0] ?? "Default";
   if (first.startsWith("{")) return "Default";
   return toPascalCase(first);
 }
-function inferOperationName(method, path8, operationId, operationIdTransform) {
+function inferOperationName(method, path6, operationId, operationIdTransform) {
   if (operationId) {
     if (operationIdTransform) {
       return operationIdTransform(operationId);
     }
     return toCamelCase(operationId);
   }
-  const verb = inferVerb(method, path8);
-  const resource = inferResourceFromPath(path8);
+  const verb = inferVerb(method, path6);
+  const resource = inferResourceFromPath(path6);
   return resource ? toCamelCase(`${verb}_${resource}`) : verb;
 }
-function inferVerb(method, path8) {
-  const segments = path8.split("/").filter(Boolean);
+function inferVerb(method, path6) {
+  const segments = path6.split("/").filter(Boolean);
   const hasTrailingParam = segments.length > 0 && segments[segments.length - 1].startsWith("{");
   switch (method) {
     case "get":
@@ -1086,8 +1116,8 @@ function inferVerb(method, path8) {
       return method;
   }
 }
-function inferResourceFromPath(path8) {
-  const segments = path8.split("/").filter(Boolean);
+function inferResourceFromPath(path6) {
+  const segments = path6.split("/").filter(Boolean);
   if (segments.length <= 1) return null;
   let resourceSegment = null;
   for (let i = segments.length - 1; i >= 0; i--) {
@@ -1135,15 +1165,15 @@ function disambiguateOperationNames(operations) {
     }
   }
 }
-function inferDeeperContext(path8) {
-  const segments = path8.split("/").filter(Boolean);
+function inferDeeperContext(path6) {
+  const segments = path6.split("/").filter(Boolean);
   const nonParams = segments.filter((s) => !s.startsWith("{"));
   if (nonParams.length >= 3) {
     return toPascalCase(nonParams.slice(1, -1).join("_"));
   }
   return null;
 }
-function buildOperation(method, path8, op, pathLevelParams, operationIdTransform) {
+function buildOperation(method, path6, op, pathLevelParams, operationIdTransform) {
   const allParams = [...pathLevelParams, ...op.parameters ?? []];
   const hasIdempotencyHeader = allParams.some((p) => p.in === "header" && p.name.toLowerCase() === "idempotency-key");
   const pathParams = extractParams(allParams, "path");
@@ -1160,7 +1190,7 @@ function buildOperation(method, path8, op, pathLevelParams, operationIdTransform
     isPaginated,
     dataPath: responseDataPath,
     itemType: responseItemType
-  } = extractResponses(op.responses, op, path8, method);
+  } = extractResponses(op.responses, op, path6, method);
   inlineModels.push(...reqBodyModels);
   const paginationFromParams = detectPagination(response, queryParams, responseDataPath);
   let pagination;
@@ -1178,10 +1208,10 @@ function buildOperation(method, path8, op, pathLevelParams, operationIdTransform
   }
   return {
     operation: {
-      name: inferOperationName(method, path8, op.operationId, operationIdTransform),
+      name: inferOperationName(method, path6, op.operationId, operationIdTransform),
       description: buildDescription(op.summary, op.description),
       httpMethod: method,
-      path: path8,
+      path: path6,
       pathParams,
       queryParams,
       headerParams,
@@ -1312,15 +1342,15 @@ function deriveOneOfVariantName(variant, baseName, existingModels) {
   }
   return name;
 }
-function deriveResponseName(op, path8, method) {
+function deriveResponseName(op, path6, method) {
   if (op?.operationId) {
     return cleanSchemaName(toPascalCase(op.operationId) + "Response");
   }
-  const segments = path8.split("/").filter(Boolean);
+  const segments = path6.split("/").filter(Boolean);
   const resource = segments[0] ?? "Unknown";
   return toPascalCase(resource) + toPascalCase(method) + "Response";
 }
-function extractResponses(responses, op, path8, method) {
+function extractResponses(responses, op, path6, method) {
   const errors = [];
   let response = { kind: "primitive", type: "string" };
   let inlineModels = [];
@@ -1335,7 +1365,7 @@ function extractResponses(responses, op, path8, method) {
       let extractedType = { kind: "primitive", type: "unknown" };
       const jsonContent = resp.content?.["application/json"];
       if (jsonContent?.schema) {
-        const contextName = deriveResponseName(op, path8 ?? "/", method ?? "get");
+        const contextName = deriveResponseName(op, path6 ?? "/", method ?? "get");
         const result = classifyAndExtractResponse(jsonContent.schema, contextName);
         extractedType = result.response;
         inlineModels = result.inlineModels;
@@ -1354,7 +1384,7 @@ function extractResponses(responses, op, path8, method) {
             if (firstContent?.schema) {
               extractedType = schemaToTypeRef(
                 firstContent.schema,
-                deriveResponseName(op, path8 ?? "/", method ?? "get")
+                deriveResponseName(op, path6 ?? "/", method ?? "get")
               );
             }
           }
@@ -1387,20 +1417,24 @@ function keepLargestByName(models) {
   }
   return [...byName.values()];
 }
-function rewriteModelRefsInServices(services, oldName, newName) {
+function rewriteModelRef(ref, oldName, newName) {
+  walkTypeRef(ref, {
+    model: (r) => {
+      if (r.name === oldName) r.name = newName;
+    }
+  });
+}
+function rewriteModelRefs(models, services, oldName, newName) {
+  for (const model of models) {
+    for (const field of model.fields) {
+      rewriteModelRef(field.type, oldName, newName);
+    }
+  }
   for (const service of services) {
     for (const op of service.operations) {
-      walkTypeRef(op.response, {
-        model: (r) => {
-          if (r.name === oldName) r.name = newName;
-        }
-      });
+      rewriteModelRef(op.response, oldName, newName);
       if (op.requestBody) {
-        walkTypeRef(op.requestBody, {
-          model: (r) => {
-            if (r.name === oldName) r.name = newName;
-          }
-        });
+        rewriteModelRef(op.requestBody, oldName, newName);
       }
     }
   }
@@ -1449,9 +1483,30 @@ function mergeFieldInlineModels(existingModels, fieldInlineModels) {
   });
   return [...existingModels, ...keepLargestByName(deduplicatedFieldModels)];
 }
+function hasModelConstDiscriminant(model) {
+  return model.fields.some(
+    (f) => (f.name === "object" || f.name === "type") && f.type.kind === "literal" && typeof f.type.value === "string"
+  );
+}
+function isModelReferencedByOthers(name, models, excludeNames) {
+  for (const model of models) {
+    if (excludeNames.has(model.name)) continue;
+    for (const field of model.fields) {
+      let found = false;
+      walkTypeRef(field.type, {
+        model: (r) => {
+          if (r.name === name) found = true;
+        }
+      });
+      if (found) return true;
+    }
+  }
+  return false;
+}
 function collapseJsonSuffixModels(models, services) {
   const normalizedModels = [...models];
   const byName = new Map(normalizedModels.map((m) => [m.name, m]));
+  const mergeCandidates = [];
   for (const model of normalizedModels) {
     if (!model.name.endsWith("Json")) continue;
     const baseName = model.name.slice(0, -4);
@@ -1459,13 +1514,20 @@ function collapseJsonSuffixModels(models, services) {
     if (!baseModel || model.fields.length <= baseModel.fields.length) continue;
     const isSuperset = baseModel.fields.every((f) => model.fields.some((mf) => mf.name === f.name));
     if (!isSuperset) continue;
-    baseModel.fields = model.fields;
-    const jsonIdx = normalizedModels.indexOf(model);
-    if (jsonIdx !== -1) normalizedModels.splice(jsonIdx, 1);
-    rewriteModelRefsInServices(services, model.name, baseName);
-    console.warn(`[oagen] Merged "${model.name}" into "${baseName}" (${model.fields.length} fields, superset)`);
+    if (hasModelConstDiscriminant(model) && hasModelConstDiscriminant(baseModel)) continue;
+    if (isModelReferencedByOthers(model.name, normalizedModels, /* @__PURE__ */ new Set([model.name, baseName]))) continue;
+    mergeCandidates.push({ jsonModel: model, baseModel });
+  }
+  const toRemove = /* @__PURE__ */ new Set();
+  for (const { jsonModel, baseModel } of mergeCandidates) {
+    baseModel.fields = jsonModel.fields;
+    toRemove.add(jsonModel.name);
+    rewriteModelRefs(normalizedModels, services, jsonModel.name, baseModel.name);
+    console.warn(
+      `[oagen] Merged "${jsonModel.name}" into "${baseModel.name}" (${jsonModel.fields.length} fields, superset)`
+    );
   }
-  return normalizedModels;
+  return normalizedModels.filter((m) => !toRemove.has(m.name));
 }
 
 // src/parser/collect-inline-enums.ts
@@ -1527,11 +1589,11 @@ async function parseSpec(specPath, options) {
     options?.operationIdTransform
   );
   const responseNormalizedModels = mergeInlineResponseModels(models, inlineModels);
-  const jsonCollapsedModels = collapseJsonSuffixModels(responseNormalizedModels, services);
   const fieldInlineModels = extractInlineModelsFromSchemas(
     spec.components?.schemas
   );
-  const finalModels = mergeFieldInlineModels(jsonCollapsedModels, fieldInlineModels);
+  const fieldMergedModels = mergeFieldInlineModels(responseNormalizedModels, fieldInlineModels);
+  const finalModels = collapseJsonSuffixModels(fieldMergedModels, services);
   collectInlineEnumsFromModels(finalModels, enums);
   const auth = extractAuthSchemes(spec.components?.securitySchemes);
   const serverEntries = (spec.servers ?? []).map((s) => ({ url: s.url ?? "", description: s.description })).filter((s) => s.url);
@@ -1617,11 +1679,11 @@ function declarationKey(node) {
 function importEntries(node, source) {
   const entries = [];
   const collect = (spec) => {
-    const path8 = spec.childForFieldName("path")?.text ?? spec.text;
+    const path6 = spec.childForFieldName("path")?.text ?? spec.text;
     const name = spec.childForFieldName("name")?.text ?? "";
     const text = source.slice(spec.startIndex, spec.endIndex);
     entries.push({
-      key: `${name}:${path8.replace(/^"|"$/g, "")}`,
+      key: `${name}:${path6.replace(/^"|"$/g, "")}`,
       text
     });
   };
@@ -2427,75 +2489,11 @@ async function extractStatements(source, language) {
   const tree = safeParse(parser, source);
   return adapter.parseStatements(tree, source);
 }
-async function mergeIntoExisting(existingContent, generatedContent, language, header, options) {
+async function mergeIntoExisting(existingContent, generatedContent, language, header) {
   const adapter = getMergeAdapter(language);
   if (!adapter) {
     throw new Error(`No merge adapter configured for language "${language}"`);
   }
-  if (options?.docstringOnly) {
-    let result2 = existingContent;
-    let docstringUpdates2 = 0;
-    const parser = await getParser(language);
-    const resultTree = safeParse(parser, result2);
-    const generatedTree = safeParse(parser, generatedContent);
-    const resultDocs = adapter.extractDocstrings(resultTree, result2);
-    const generatedDocs = adapter.extractDocstrings(generatedTree, generatedContent);
-    const ignoredRegions = findIgnoredRegions(result2);
-    const ignoredSymbols = buildIgnoredSymbolNames(resultDocs, ignoredRegions);
-    const headerLine2 = header.trim();
-    const edits = [];
-    for (const [symbolName, genInfo] of generatedDocs) {
-      const existInfo = resultDocs.get(symbolName);
-      if (!existInfo) continue;
-      if (ignoredSymbols.has(symbolName)) continue;
-      const genDoc = genInfo.docstring && genInfo.docstring.text.trim() !== headerLine2 ? genInfo.docstring : null;
-      if (genDoc) {
-        if (existInfo.docstring) {
-          const isPreserved = existInfo.docstring.text.includes("@oagen-ignore");
-          if (!isPreserved && existInfo.docstring.text !== genDoc.text) {
-            edits.push({
-              start: existInfo.docstring.startIndex,
-              end: existInfo.docstring.endIndex,
-              newText: genDoc.text
-            });
-            docstringUpdates2++;
-          }
-        } else {
-          const lineStart = existInfo.declStartIndex - existInfo.declColumn;
-          const indent = " ".repeat(existInfo.declColumn);
-          edits.push({ start: lineStart, end: lineStart, newText: indent + genDoc.text + "\n" });
-          docstringUpdates2++;
-        }
-      }
-      for (const [memberName, genMember] of genInfo.members) {
-        const existMember = existInfo.members.get(memberName);
-        if (!existMember || !genMember.docstring) continue;
-        if (existMember.docstring) {
-          const isPreserved = existMember.docstring.text.includes("@oagen-ignore");
-          if (!isPreserved && existMember.docstring.text !== genMember.docstring.text) {
-            edits.push({
-              start: existMember.docstring.startIndex,
-              end: existMember.docstring.endIndex,
-              newText: genMember.docstring.text
-            });
-            docstringUpdates2++;
-          }
-        } else {
-          const lineStart = existMember.declStartIndex - existMember.declColumn;
-          const indent = " ".repeat(existMember.declColumn);
-          edits.push({ start: lineStart, end: lineStart, newText: indent + genMember.docstring.text + "\n" });
-          docstringUpdates2++;
-        }
-      }
-    }
-    if (edits.length > 0) {
-      edits.sort((a, b) => b.start - a.start);
-      for (const edit of edits) {
-        result2 = result2.slice(0, edit.start) + edit.newText + result2.slice(edit.end);
-      }
-    }
-    return { content: result2, added: 0, preserved: 0, changed: docstringUpdates2 > 0 };
-  }
   const existingStatements = await extractStatements(existingContent, language);
   const generatedStatements = await extractStatements(generatedContent, language);
   const existingKeys = /* @__PURE__ */ new Set();
@@ -2544,6 +2542,14 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
       preserved++;
       continue;
     }
+    const braceMatch = imp.text.match(/\{([^}]+)\}/);
+    if (braceMatch) {
+      const names = braceMatch[1].split(",").map((n) => n.replace(/\btype\b/, "").trim()).filter(Boolean);
+      if (names.length > 0 && names.every((n) => existingImportedNames.has(n))) {
+        preserved++;
+        continue;
+      }
+    }
     newImports.push(imp);
   }
   for (const stmt of generatedStatements.statements) {
@@ -2768,22 +2774,6 @@ async function writeFiles(files, outputDir, options) {
     }
     if (language && hasGrammar(language)) {
       try {
-        if (file.mergeMode === "docstring-only") {
-          const mergeResult2 = await mergeIntoExisting(existingContent, file.content, language, header, {
-            docstringOnly: true
-          });
-          let finalContent2 = mergeResult2.content;
-          if (header && !finalContent2.startsWith(header)) {
-            finalContent2 = header + "\n\n" + finalContent2;
-          }
-          if (finalContent2 === existingContent) {
-            result.identical.push(file.path);
-          } else {
-            await fs.writeFile(fullPath, finalContent2, "utf-8");
-            result.merged.push(file.path);
-          }
-          continue;
-        }
         const mergeResult = await mergeIntoExisting(existingContent, file.content, language, header);
         let finalContent = mergeResult.content;
         if (header && !finalContent.startsWith(header)) {
@@ -2849,24 +2839,20 @@ function generateFiles(spec, emitter, options) {
 }
 
 // src/engine/integrate.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-function mapFilesForTargetIntegration(files, language, targetDir) {
+function mapFilesForTargetIntegration(files, language) {
   const langPrefix = `${language}/`;
   return files.filter((f) => f.integrateTarget !== false).map((f) => {
     const stripped = f.path.startsWith(langPrefix) ? f.path.replace(langPrefix, "") : f.path;
-    const existsInTarget = targetDir ? fs2.existsSync(path2.join(targetDir, stripped)) : false;
     return {
       ...f,
       skipIfExists: false,
       // Always merge in target — never hard-skip
-      mergeMode: existsInTarget ? "docstring-only" : "full",
       path: stripped
     };
   });
 }
 async function integrateGeneratedFiles(opts) {
-  return writeFiles(mapFilesForTargetIntegration(opts.files, opts.language, opts.targetDir), opts.targetDir, {
+  return writeFiles(mapFilesForTargetIntegration(opts.files, opts.language), opts.targetDir, {
     language: opts.language,
     header: opts.header
   });
@@ -2933,8 +2919,8 @@ function getEmitter(language) {
 }
 
 // src/cli/overlay-loader.ts
-import { readFileSync, existsSync as existsSync2 } from "fs";
-import * as path3 from "path";
+import { readFileSync, existsSync } from "fs";
+import * as path2 from "path";
 
 // src/compat/language-hints.ts
 var UNTYPED_MAP_PATTERNS = /* @__PURE__ */ new Set([
@@ -3157,8 +3143,8 @@ function buildOverlayLookup(surface, manifest, spec, hints, options) {
   for (const name of Object.keys(surface.typeAliases)) {
     lookup.typeAliasByName.set(name, name);
   }
-  for (const [path8, symbols] of Object.entries(surface.exports)) {
-    lookup.requiredExports.set(path8, new Set(symbols));
+  for (const [path6, symbols] of Object.entries(surface.exports)) {
+    lookup.requiredExports.set(path6, new Set(symbols));
   }
   for (const record of [surface.classes, surface.interfaces, surface.typeAliases, surface.enums]) {
     for (const [name, item] of Object.entries(record)) {
@@ -3325,11 +3311,11 @@ function patchOverlay(overlay, violations, baseline) {
     if (v.category === "export-structure") {
       const match = v.symbolPath.match(/^exports\[(.+?)\]\.(.+)$/);
       if (match) {
-        const [, path8, symbol] = match;
-        if (!patched.requiredExports.has(path8)) {
-          patched.requiredExports.set(path8, /* @__PURE__ */ new Set());
+        const [, path6, symbol] = match;
+        if (!patched.requiredExports.has(path6)) {
+          patched.requiredExports.set(path6, /* @__PURE__ */ new Set());
         }
-        patched.requiredExports.get(path8).add(symbol);
+        patched.requiredExports.get(path6).add(symbol);
       }
     }
   }
@@ -3374,8 +3360,8 @@ function loadOverlayContext(opts) {
     );
   }
   let manifest;
-  const resolvedManifestPath = opts.manifestPath ?? path3.join(opts.outputDir, "smoke-manifest.json");
-  if (opts.manifestPath || existsSync2(resolvedManifestPath)) {
+  const resolvedManifestPath = opts.manifestPath ?? path2.join(opts.outputDir, "smoke-manifest.json");
+  if (opts.manifestPath || existsSync(resolvedManifestPath)) {
     try {
       const parsed = JSON.parse(readFileSync(resolvedManifestPath, "utf-8"));
       if (Array.isArray(parsed)) {
@@ -3862,288 +3848,21 @@ function summarize(changes) {
   return { added, removed, modified, breaking, additive };
 }
 
-// src/differ/file-map.ts
-function mapChangesToFiles(changes, emitter, ctx) {
-  const regenerate = /* @__PURE__ */ new Set();
-  const toDelete = /* @__PURE__ */ new Set();
-  const modelFiles = /* @__PURE__ */ new Map();
-  const enumFiles = /* @__PURE__ */ new Map();
-  const serviceFiles = /* @__PURE__ */ new Map();
-  for (const model of ctx.spec.models) {
-    const files = emitter.generateModels([model], ctx);
-    const sigs = emitter.generateTypeSignatures?.({ ...ctx.spec, models: [model], enums: [], services: [] }, ctx) ?? [];
-    modelFiles.set(
-      model.name,
-      [...files, ...sigs].map((f) => f.path)
-    );
-  }
-  for (const enumDef of ctx.spec.enums) {
-    const files = emitter.generateEnums([enumDef], ctx);
-    enumFiles.set(
-      enumDef.name,
-      files.map((f) => f.path)
-    );
-  }
-  for (const service of ctx.spec.services) {
-    const files = [
-      ...emitter.generateResources([service], ctx),
-      ...emitter.generateTests({ ...ctx.spec, services: [service], models: [], enums: [] }, ctx)
-    ];
-    const sigs = emitter.generateTypeSignatures?.({ ...ctx.spec, services: [service], models: [], enums: [] }, ctx) ?? [];
-    serviceFiles.set(
-      service.name,
-      [...files, ...sigs].map((f) => f.path)
-    );
-  }
-  const modelToServices = buildReferenceGraph(ctx.spec);
-  for (const change of changes) {
-    switch (change.kind) {
-      case "model-added":
-      case "model-modified": {
-        const files = modelFiles.get(change.name) ?? [];
-        files.forEach((f) => regenerate.add(f));
-        const refs = modelToServices.get(change.name) ?? [];
-        for (const svc of refs) {
-          const svcFiles = serviceFiles.get(svc) ?? [];
-          svcFiles.forEach((f) => regenerate.add(f));
-        }
-        break;
-      }
-      case "model-removed": {
-        const files = modelFiles.get(change.name) ?? [];
-        files.forEach((f) => toDelete.add(f));
-        const refs = modelToServices.get(change.name) ?? [];
-        for (const svc of refs) {
-          const svcFiles = serviceFiles.get(svc) ?? [];
-          svcFiles.forEach((f) => regenerate.add(f));
-        }
-        break;
-      }
-      case "enum-added":
-      case "enum-modified": {
-        const files = enumFiles.get(change.name) ?? [];
-        files.forEach((f) => regenerate.add(f));
-        const refs = modelToServices.get(change.name) ?? [];
-        for (const svc of refs) {
-          const svcFiles = serviceFiles.get(svc) ?? [];
-          svcFiles.forEach((f) => regenerate.add(f));
-        }
-        break;
-      }
-      case "enum-removed": {
-        const files = enumFiles.get(change.name) ?? [];
-        files.forEach((f) => toDelete.add(f));
-        const refs = modelToServices.get(change.name) ?? [];
-        for (const svc of refs) {
-          const svcFiles = serviceFiles.get(svc) ?? [];
-          svcFiles.forEach((f) => regenerate.add(f));
-        }
-        break;
-      }
-      case "service-added": {
-        const files = serviceFiles.get(change.name) ?? [];
-        files.forEach((f) => regenerate.add(f));
-        break;
-      }
-      case "service-removed": {
-        const files = serviceFiles.get(change.name) ?? [];
-        files.forEach((f) => toDelete.add(f));
-        break;
-      }
-      case "operation-added":
-      case "operation-removed":
-      case "operation-modified": {
-        const files = serviceFiles.get(change.serviceName) ?? [];
-        files.forEach((f) => regenerate.add(f));
-        break;
-      }
-    }
-  }
-  for (const f of toDelete) {
-    regenerate.delete(f);
-  }
-  return {
-    regenerate: [...regenerate].sort(),
-    delete: [...toDelete].sort()
-  };
-}
-function buildReferenceGraph(spec) {
-  const refs = /* @__PURE__ */ new Map();
-  function trackRef(typeRef, serviceName) {
-    const addName = (name) => {
-      if (!refs.has(name)) refs.set(name, /* @__PURE__ */ new Set());
-      refs.get(name).add(serviceName);
-    };
-    walkTypeRef(typeRef, {
-      model: (r) => addName(r.name),
-      enum: (r) => addName(r.name)
-    });
-  }
-  for (const service of spec.services) {
-    for (const op of service.operations) {
-      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams]) {
-        trackRef(p.type, service.name);
-      }
-      if (op.requestBody) trackRef(op.requestBody, service.name);
-      trackRef(op.response, service.name);
-    }
-  }
-  const modelDeps = /* @__PURE__ */ new Map();
-  function collectDeps(typeRef, deps) {
-    walkTypeRef(typeRef, {
-      model: (r) => deps.add(r.name),
-      enum: (r) => deps.add(r.name)
-    });
-  }
-  for (const model of spec.models) {
-    const deps = /* @__PURE__ */ new Set();
-    for (const field of model.fields) {
-      collectDeps(field.type, deps);
-    }
-    deps.delete(model.name);
-    if (deps.size > 0) {
-      modelDeps.set(model.name, deps);
-    }
-  }
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (const [modelName, services] of refs) {
-      const deps = modelDeps.get(modelName);
-      if (!deps) continue;
-      for (const dep of deps) {
-        if (!refs.has(dep)) refs.set(dep, /* @__PURE__ */ new Set());
-        const depServices = refs.get(dep);
-        for (const svc of services) {
-          if (!depServices.has(svc)) {
-            depServices.add(svc);
-            changed = true;
-          }
-        }
-      }
-    }
-  }
-  const result = /* @__PURE__ */ new Map();
-  for (const [name, svcSet] of refs) {
-    result.set(name, [...svcSet]);
-  }
-  return result;
-}
-
-// src/engine/incremental.ts
-import * as fs3 from "fs/promises";
-import * as path4 from "path";
-async function generateIncremental(oldSpec, newSpec, emitter, options) {
-  const diff = diffSpecs(oldSpec, newSpec);
-  if (diff.changes.length === 0) {
-    return { generated: [], deleted: [], diff };
-  }
-  const ctx = buildEmitterContext(newSpec, options);
-  const affected = mapChangesToFiles(diff.changes, emitter, ctx);
-  const allFiles = generateAllFiles(newSpec, emitter, ctx);
-  const header = emitter.fileHeader();
-  const affectedSet = new Set(affected.regenerate);
-  const generated = applyFileHeaders(
-    allFiles.filter((f) => affectedSet.has(f.path)),
-    header
-  );
-  if (!options.dryRun) {
-    const writeResult = await writeFiles(generated, options.outputDir, {
-      language: emitter.language,
-      header
-    });
-    if (writeResult.ignored.length > 0) {
-      console.log(`Ignored ${writeResult.ignored.length} files (@oagen-ignore-file)`);
-    }
-    if (options.target) {
-      const targetResult = await integrateGeneratedFiles({
-        files: generated,
-        language: emitter.language,
-        targetDir: options.target,
-        header
-      });
-      if (targetResult.written.length > 0) {
-        console.log(`Target: created ${targetResult.written.length} new files`);
-      }
-      if (targetResult.merged.length > 0) {
-        console.log(`Target: merged into ${targetResult.merged.length} existing files (additive only)`);
-      }
-      if (targetResult.skipped.length > 0) {
-        console.log(`Target: skipped ${targetResult.skipped.length} files (excluded or no grammar)`);
-      }
-      if (targetResult.ignored.length > 0) {
-        console.log(`Target: ignored ${targetResult.ignored.length} files (@oagen-ignore-file)`);
-      }
-    }
-    if (options.force) {
-      for (const filePath of affected.delete) {
-        const fullPath = path4.join(options.outputDir, filePath);
-        await fs3.rm(fullPath, { force: true });
-      }
-    }
-  }
-  return {
-    generated,
-    deleted: options.force ? affected.delete : [],
-    diff
-  };
-}
-
 // src/cli/diff.ts
 async function diffCommand(opts) {
   const parseOptions = { operationIdTransform: opts.operationIdTransform };
-  let [oldSpec, newSpec] = await Promise.all([
-    parseSpec(opts.old, parseOptions),
-    parseSpec(opts.new, parseOptions)
-  ]);
+  let [oldSpec, newSpec] = await Promise.all([parseSpec(opts.old, parseOptions), parseSpec(opts.new, parseOptions)]);
   if (opts.docUrl) {
     oldSpec = expandDocUrls(oldSpec, opts.docUrl);
     newSpec = expandDocUrls(newSpec, opts.docUrl);
   }
-  if (opts.report) {
-    const diff = diffSpecs(oldSpec, newSpec);
-    console.log(JSON.stringify(diff, null, 2));
-    throw new CommandError(
-      "",
-      "",
-      diff.summary.breaking > 0 ? 2 : diff.summary.modified > 0 || diff.summary.removed > 0 ? 1 : diff.summary.added > 0 ? 1 : 0
-    );
-  }
-  if (!opts.lang || !opts.output) {
-    throw new CommandError("--lang and --output are required for incremental generation", "", 1);
-  }
-  let apiSurface;
-  let overlayLookup;
-  if (opts.apiSurface) {
-    const ctx = loadOverlayContext({
-      apiSurfacePath: opts.apiSurface,
-      manifestPath: opts.manifest,
-      outputDir: opts.output,
-      lang: opts.lang
-    });
-    apiSurface = ctx.apiSurface;
-    overlayLookup = ctx.overlayLookup;
-  }
-  const emitter = getEmitter(opts.lang);
-  const result = await generateIncremental(oldSpec, newSpec, emitter, {
-    namespace: newSpec.name,
-    outputDir: opts.output,
-    force: opts.force,
-    target: opts.target,
-    apiSurface,
-    overlayLookup
-  });
-  if (result.diff.changes.length === 0) {
-    console.log("No changes detected");
-  } else {
-    console.log(`Regenerated ${result.generated.length} files`);
-    if (result.deleted.length > 0) {
-      console.log(`Deleted ${result.deleted.length} files`);
-    }
-    if (!opts.force && result.diff.changes.some((c) => c.kind.endsWith("-removed"))) {
-      console.log("Use --force to delete files for removed schemas");
-    }
-  }
+  const diff = diffSpecs(oldSpec, newSpec);
+  console.log(JSON.stringify(diff, null, 2));
+  throw new CommandError(
+    "",
+    "",
+    diff.summary.breaking > 0 ? 2 : diff.summary.modified > 0 || diff.summary.removed > 0 ? 1 : diff.summary.added > 0 ? 1 : 0
+  );
 }
 
 // src/cli/extract.ts
@@ -4158,7 +3877,7 @@ async function extractCommand(opts) {
 }
 
 // src/cli/verify.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 
 // src/compat/spec-filter.ts
 function specDerivedNames(spec, hints) {
@@ -4257,9 +3976,9 @@ function filterSurface(surface, allowedNames, opts) {
   let filteredClasses = filterRecord(surface.classes, allowedNames);
   if (methodPaths) {
     const serviceClassNames = /* @__PURE__ */ new Set();
-    for (const path8 of methodPaths) {
-      const dot = path8.indexOf(".");
-      if (dot !== -1) serviceClassNames.add(path8.slice(0, dot));
+    for (const path6 of methodPaths) {
+      const dot = path6.indexOf(".");
+      if (dot !== -1) serviceClassNames.add(path6.slice(0, dot));
     }
     const newClasses = {};
     for (const [name, cls] of Object.entries(filteredClasses)) {
@@ -4686,17 +4405,17 @@ function diffSurfaces(baseline, candidate, hints) {
       additions.push({ symbolPath: name, symbolType: "enum" });
     }
   }
-  for (const [path8, baseExports] of Object.entries(baseline.exports)) {
-    const candExports = candidate.exports[path8];
+  for (const [path6, baseExports] of Object.entries(baseline.exports)) {
+    const candExports = candidate.exports[path6];
     if (!candExports) {
       for (const exp of baseExports) {
         violations.push({
           category: "export-structure",
           severity: "warning",
-          symbolPath: `exports[${path8}].${exp}`,
+          symbolPath: `exports[${path6}].${exp}`,
           baseline: exp,
           candidate: "(missing)",
-          message: `Export "${exp}" from "${path8}" not found in generated output`
+          message: `Export "${exp}" from "${path6}" not found in generated output`
         });
       }
       continue;
@@ -4707,10 +4426,10 @@ function diffSurfaces(baseline, candidate, hints) {
         violations.push({
           category: "export-structure",
           severity: "warning",
-          symbolPath: `exports[${path8}].${exp}`,
+          symbolPath: `exports[${path6}].${exp}`,
           baseline: exp,
           candidate: "(missing)",
-          message: `Export "${exp}" from "${path8}" not found in generated output`
+          message: `Export "${exp}" from "${path6}" not found in generated output`
         });
       }
     }
@@ -4764,8 +4483,8 @@ async function runCompatCheck(baseline, outputDir, lang, spec) {
 }
 
 // src/verify/run-overlay-retry-loop.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync, unlinkSync, statSync, openSync, readSync, closeSync } from "fs";
-import * as path5 from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, unlinkSync, statSync, openSync, readSync, closeSync } from "fs";
+import * as path3 from "path";
 var PATCHABLE_CATEGORIES = /* @__PURE__ */ new Set(["public-api", "export-structure"]);
 var GENERATED_MARKERS = ["Code generated by oagen", "auto-generated by oagen", "This file is auto-generated"];
 function cleanGeneratedFiles(dir) {
@@ -4776,7 +4495,7 @@ function cleanGeneratedFiles(dir) {
     return;
   }
   for (const entry of entries) {
-    const full = path5.join(dir, entry);
+    const full = path3.join(dir, entry);
     let stat;
     try {
       stat = statSync(full);
@@ -4805,8 +4524,8 @@ function cleanGeneratedFiles(dir) {
   }
 }
 function loadManifestFromDir(outputDir) {
-  const manifestPath = path5.join(outputDir, "smoke-manifest.json");
-  if (!existsSync3(manifestPath)) return void 0;
+  const manifestPath = path3.join(outputDir, "smoke-manifest.json");
+  if (!existsSync2(manifestPath)) return void 0;
   try {
     const parsed = JSON.parse(readFileSync2(manifestPath, "utf-8"));
     if (Array.isArray(parsed)) return parsed;
@@ -4994,17 +4713,17 @@ function runStalenessCheck(baseline, oldSpec, newSpec, lang) {
 
 // src/verify/run-smoke-check.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath } from "url";
-import * as path6 from "path";
+import * as path4 from "path";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path6.dirname(__filename);
+var __dirname = path4.dirname(__filename);
 function resolveScript(scriptRelPath) {
-  const distScript = path6.resolve(__dirname, "..", "..", "dist", "scripts", scriptRelPath.replace(/\.ts$/, ".js"));
-  if (existsSync4(distScript)) {
+  const distScript = path4.resolve(__dirname, "..", "..", "dist", "scripts", scriptRelPath.replace(/\.ts$/, ".js"));
+  if (existsSync3(distScript)) {
     return { bin: "node", script: distScript };
   }
-  const srcScript = path6.resolve(__dirname, "..", "..", "scripts", scriptRelPath);
+  const srcScript = path4.resolve(__dirname, "..", "..", "scripts", scriptRelPath);
   return { bin: "npx", script: srcScript };
 }
 function runPackagedScript(scriptRelPath, args) {
@@ -5016,7 +4735,7 @@ function runSmokeCheck(opts) {
   const { spec, lang, output, rawResults, smokeConfig, smokeRunner } = opts;
   let baselinePath = rawResults ?? "smoke-results-raw.json";
   let generatedBaseline = false;
-  if (!rawResults && !existsSync4("smoke-results-raw.json")) {
+  if (!rawResults && !existsSync3("smoke-results-raw.json")) {
     if (!spec) {
       throw new CommandError(
         "error: --spec <path> or OPENAPI_SPEC_PATH env var is required when no raw baseline exists",
@@ -5045,10 +4764,10 @@ function runSmokeCheck(opts) {
     }
     return { passed: true, baselinePath, generatedBaseline };
   } catch {
-    if (existsSync4("smoke-compile-errors.json")) {
+    if (existsSync3("smoke-compile-errors.json")) {
       return { passed: false, compileErrors: true, baselinePath, generatedBaseline };
     }
-    const findingsCount = existsSync4("smoke-diff-findings.json") ? JSON.parse(readFileSync3("smoke-diff-findings.json", "utf-8")).length : void 0;
+    const findingsCount = existsSync3("smoke-diff-findings.json") ? JSON.parse(readFileSync3("smoke-diff-findings.json", "utf-8")).length : void 0;
     return { passed: false, findingsCount, baselinePath, generatedBaseline };
   }
 }
@@ -5206,7 +4925,7 @@ ${separator}`);
     }
     stepNum++;
   }
-  const needsBaselineStep = !rawResults && !existsSync5("smoke-results-raw.json");
+  const needsBaselineStep = !rawResults && !existsSync4("smoke-results-raw.json");
   if (needsBaselineStep) {
     console.log(`
 ${separator}`);
@@ -5259,7 +4978,7 @@ Remediation guide (by finding type):
 
 // src/cli/init.ts
 import { resolve as resolve3, relative } from "path";
-import { existsSync as existsSync6, mkdirSync, writeFileSync as writeFileSync3, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync5, mkdirSync, writeFileSync as writeFileSync3, readFileSync as readFileSync5 } from "fs";
 
 // src/cli/templates/init.ts
 function oagenScripts(lang) {
@@ -5425,7 +5144,7 @@ export const ${varName}: Emitter = {
 async function initCommand(opts) {
   const projectDir = resolve3(opts.project ?? ".");
   const lang = opts.lang;
-  if (existsSync6(resolve3(projectDir, "oagen.config.ts"))) {
+  if (existsSync5(resolve3(projectDir, "oagen.config.ts"))) {
     throw new Error("Project already initialized \u2014 oagen.config.ts exists");
   }
   const dirs = [`src/${lang}`, "test", "smoke", "docs/sdk-architecture"];
@@ -5442,7 +5161,7 @@ async function initCommand(opts) {
   ];
   const packageJsonPath = resolve3(projectDir, "package.json");
   let packageJsonContent;
-  if (existsSync6(packageJsonPath)) {
+  if (existsSync5(packageJsonPath)) {
     const existingContent = readFileSync5(packageJsonPath, "utf-8");
     const existingPkg = JSON.parse(existingContent);
     const newPkg = JSON.parse(packageJson(lang));
@@ -5467,7 +5186,7 @@ async function initCommand(opts) {
   }
   const gitignorePath = resolve3(projectDir, ".gitignore");
   let gitignoreContent;
-  if (existsSync6(gitignorePath)) {
+  if (existsSync5(gitignorePath)) {
     const existingContent = readFileSync5(gitignorePath, "utf-8");
     const newContent = gitignore();
     const existingLines = new Set(
@@ -5505,14 +5224,14 @@ async function initCommand(opts) {
 }
 
 // src/cli/config-loader.ts
-import * as path7 from "path";
-import { existsSync as existsSync7 } from "fs";
+import * as path5 from "path";
+import { existsSync as existsSync6 } from "fs";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var CONFIG_NAMES = ["oagen.config.ts", "oagen.config.js", "oagen.config.mjs"];
 async function loadConfig(cwd = process.cwd()) {
   for (const name of CONFIG_NAMES) {
-    const configPath = path7.resolve(cwd, name);
-    if (!existsSync7(configPath)) continue;
+    const configPath = path5.resolve(cwd, name);
+    if (!existsSync6(configPath)) continue;
     try {
       const mod = await import(pathToFileURL2(configPath).href);
       const config = mod.default ?? mod;
@@ -5578,7 +5297,7 @@ program.command("generate").description("Run a registered emitter against an Ope
     handleError
   );
 });
-program.command("diff").description("Incrementally generate from spec changes").requiredOption("--old <path>", "Path to old spec").requiredOption("--new <path>", "Path to new spec").option("--lang <language>", "Target language (required unless --report)").option("--output <dir>", "Output directory").option("--report", "Output diff report as JSON").option("--force", "Allow file deletions without confirmation").option("--target <dir>", "Target directory for live SDK integration (merged output)").option("--api-surface <path>", "Path to baseline API surface JSON for compat overlay").option("--manifest <path>", "Path to smoke-manifest.json for method overlay").action((opts) => {
+program.command("diff").description("Compare two OpenAPI specs and output a diff report").requiredOption("--old <path>", "Path to old spec").requiredOption("--new <path>", "Path to new spec").action((opts) => {
   diffCommand({ ...opts, operationIdTransform: configOperationIdTransform, docUrl: configDocUrl }).catch(handleError);
 });
 program.command("extract").description("Extract public API surface from a live SDK").requiredOption("--sdk-path <path>", "Path to the live SDK").requiredOption("--lang <language>", "Target language").option("--output <path>", "Output file path").action((opts) => {