@workos/oagen 0.1.0 → 0.2.0

package/dist/chunk-VUSRNIG2.js

@@ -1,1661 +0,0 @@
-import {
-  RegistryError,
-  assertNever,
-  normalizeJsExtension,
-  safeParse,
-  toSnakeCase
-} from "./chunk-CIX5NOBF.js";
-
-// src/engine/generate-files.ts
-function buildEmitterContext(spec, options) {
-  return {
-    namespace: toSnakeCase(options.namespace),
-    namespacePascal: options.namespace,
-    spec,
-    outputDir: options.outputDir,
-    apiSurface: options.apiSurface,
-    overlayLookup: options.overlayLookup
-  };
-}
-function generateAllFiles(spec, emitter, ctx) {
-  return [
-    ...emitter.generateModels(spec.models, ctx),
-    ...emitter.generateEnums(spec.enums, ctx),
-    ...emitter.generateResources(spec.services, ctx),
-    ...emitter.generateClient(spec, ctx),
-    ...emitter.generateErrors(ctx),
-    ...emitter.generateConfig(ctx),
-    ...emitter.generateTypeSignatures?.(spec, ctx) ?? [],
-    ...emitter.generateTests(spec, ctx),
-    ...emitter.generateManifest?.(spec, ctx) ?? []
-  ];
-}
-function applyFileHeaders(files, header) {
-  return files.map((f) => ({
-    ...f,
-    content: !header || f.path.endsWith(".json") || f.headerPlacement === "skip" ? f.content : header + "\n\n" + f.content,
-    skipIfExists: f.skipIfExists ?? false
-  }));
-}
-function generateFiles(spec, emitter, options) {
-  const ctx = buildEmitterContext(spec, options);
-  const files = generateAllFiles(spec, emitter, ctx);
-  const header = emitter.fileHeader();
-  return { files: applyFileHeaders(files, header), ctx, header };
-}
-
-// src/engine/writer.ts
-import * as fs from "fs/promises";
-import * as path from "path";
-
-// src/engine/merger.ts
-import Parser from "tree-sitter";
-
-// src/engine/merge-adapters/go.ts
-function lastIdentifier(text) {
-  const matches = [...text.matchAll(/[A-Za-z_][A-Za-z0-9_]*/g)];
-  return matches.length > 0 ? matches[matches.length - 1][0] : null;
-}
-function receiverKey(node) {
-  const receiver = node.childForFieldName("receiver");
-  if (!receiver) return null;
-  return lastIdentifier(receiver.text);
-}
-function declarationKey(node) {
-  switch (node.type) {
-    case "package_clause": {
-      const pkg = lastIdentifier(node.text);
-      return pkg ? `__package:${pkg}` : "__package:";
-    }
-    case "type_declaration": {
-      const spec = node.firstNamedChild?.type === "type_spec" ? node.firstNamedChild : node.namedChildren[0];
-      const nameNode = spec?.childForFieldName("name");
-      return nameNode?.text ?? null;
-    }
-    case "function_declaration": {
-      return node.childForFieldName("name")?.text ?? null;
-    }
-    case "method_declaration": {
-      const name = node.childForFieldName("name")?.text ?? null;
-      const receiver = receiverKey(node);
-      return name && receiver ? `method:${receiver}.${name}` : name;
-    }
-    case "const_declaration":
-    case "var_declaration": {
-      return node.text.split(/\s+/).slice(0, 3).join(" ");
-    }
-    default:
-      return null;
-  }
-}
-function importEntries(node, source) {
-  const entries = [];
-  const collect = (spec) => {
-    const path2 = spec.childForFieldName("path")?.text ?? spec.text;
-    const name = spec.childForFieldName("name")?.text ?? "";
-    const text = source.slice(spec.startIndex, spec.endIndex);
-    entries.push({
-      key: `${name}:${path2.replace(/^"|"$/g, "")}`,
-      text
-    });
-  };
-  for (const child of node.namedChildren) {
-    if (child.type === "import_spec") {
-      collect(child);
-      continue;
-    }
-    if (child.type === "import_spec_list") {
-      for (const spec of child.namedChildren) {
-        if (spec.type === "import_spec") collect(spec);
-      }
-    }
-  }
-  return entries;
-}
-function collectPrecedingGoComments(children, index, source) {
-  let lastIdx = -1;
-  let firstIdx = -1;
-  for (let k = index - 1; k >= 0; k--) {
-    const prev = children[k];
-    if (prev.type === "comment") {
-      const text = source.slice(prev.startIndex, prev.endIndex);
-      if (text.startsWith("//")) {
-        if (lastIdx === -1) lastIdx = k;
-        firstIdx = k;
-      } else {
-        break;
-      }
-    } else {
-      break;
-    }
-  }
-  if (firstIdx === -1) return null;
-  const first = children[firstIdx];
-  const last = children[lastIdx];
-  return { text: source.slice(first.startIndex, last.endIndex), startIndex: first.startIndex, endIndex: last.endIndex };
-}
-var goMergeAdapter = {
-  language: "go",
-  grammarModule: "tree-sitter-go",
-  parseStatements(tree, source) {
-    const imports = [];
-    const importAnchors = [];
-    let importInsertionAnchor;
-    const statements = [];
-    for (const child of tree.rootNode.children) {
-      if (child.type === "comment") continue;
-      if (child.type === "package_clause") {
-        importInsertionAnchor = source.slice(child.startIndex, child.endIndex);
-      }
-      if (child.type === "import_declaration") {
-        imports.push(...importEntries(child, source));
-        importAnchors.push(source.slice(child.startIndex, child.endIndex));
-        continue;
-      }
-      const key = declarationKey(child);
-      statements.push({
-        key,
-        kind: key ? "declaration" : "other",
-        text: source.slice(child.startIndex, child.endIndex)
-      });
-    }
-    return { imports, importAnchors, importInsertionAnchor, statements };
-  },
-  renderImports(imports) {
-    if (imports.length === 0) return [];
-    if (imports.length === 1) return [`import ${imports[0].text}`];
-    return [`import (
-${imports.map((entry) => `  ${entry.text}`).join("\n")}
-)`];
-  },
-  extractDocstrings(tree, source) {
-    const result = /* @__PURE__ */ new Map();
-    const rootChildren = tree.rootNode.children;
-    for (let i = 0; i < rootChildren.length; i++) {
-      const child = rootChildren[i];
-      const key = declarationKey(child);
-      if (!key || key.startsWith("__package:")) continue;
-      const docstring = collectPrecedingGoComments(rootChildren, i, source);
-      result.set(key, {
-        docstring,
-        declStartIndex: child.startIndex,
-        declColumn: child.startPosition.column,
-        members: /* @__PURE__ */ new Map()
-      });
-    }
-    return result;
-  }
-};
-
-// src/engine/merge-adapters/node.ts
-var REEXPORT_PREFIX = "__export:";
-function extractDeclName(node) {
-  const nameNode = node.childForFieldName("name");
-  if (nameNode) return nameNode.text;
-  if (node.type === "lexical_declaration") {
-    const declarator = node.firstNamedChild;
-    if (declarator?.type === "variable_declarator") {
-      const name = declarator.childForFieldName("name");
-      if (name) return name.text;
-    }
-  }
-  return null;
-}
-function extractNodeKey(node) {
-  if (node.type === "export_statement") {
-    const decl = node.childForFieldName("declaration");
-    if (decl) {
-      return { key: extractDeclName(decl), kind: "declaration" };
-    }
-    const source = node.childForFieldName("source");
-    if (source) {
-      return { key: `${REEXPORT_PREFIX}${normalizeJsExtension(source.text)}`, kind: "reexport" };
-    }
-    return { key: null, kind: "other" };
-  }
-  return { key: extractDeclName(node), kind: extractDeclName(node) ? "declaration" : "other" };
-}
-function extractClassMembers(classBody, source) {
-  const members = [];
-  for (const child of classBody.namedChildren) {
-    if (child.type === "method_definition") {
-      const nameNode = child.childForFieldName("name");
-      if (nameNode && nameNode.text !== "constructor") {
-        members.push({ key: nameNode.text, text: source.slice(child.startIndex, child.endIndex) });
-      }
-    } else if (child.type === "public_field_definition") {
-      const nameNode = child.childForFieldName("name");
-      if (nameNode) {
-        members.push({ key: nameNode.text, text: source.slice(child.startIndex, child.endIndex) });
-      }
-    }
-  }
-  return members;
-}
-function extractInterfaceMembers(body, source) {
-  const members = [];
-  for (const child of body.namedChildren) {
-    if (child.type === "property_signature" || child.type === "method_signature") {
-      const nameNode = child.childForFieldName("name");
-      if (nameNode) {
-        members.push({ key: nameNode.text, text: source.slice(child.startIndex, child.endIndex) });
-      }
-    }
-  }
-  return members;
-}
-function extractEnumMembers(body, source) {
-  const members = [];
-  for (const child of body.namedChildren) {
-    if (child.type === "enum_assignment") {
-      const nameNode = child.childForFieldName("name");
-      if (nameNode) {
-        members.push({ key: nameNode.text, text: source.slice(child.startIndex, child.endIndex) });
-      }
-    } else if (child.type === "property_identifier") {
-      members.push({ key: child.text, text: source.slice(child.startIndex, child.endIndex) });
-    }
-  }
-  return members;
-}
-function isCommentNode(node) {
-  return node.type === "comment" || node.grammarType === "comment";
-}
-function findPrecedingDocstring(children, index, source) {
-  for (let k = index - 1; k >= 0; k--) {
-    const prev = children[k];
-    if (isCommentNode(prev)) {
-      const text = source.slice(prev.startIndex, prev.endIndex);
-      if (text.startsWith("/**")) {
-        return { text, startIndex: prev.startIndex, endIndex: prev.endIndex };
-      }
-      return null;
-    }
-    if (prev.type === "," || prev.type === ";" || prev.type === "{") continue;
-    return null;
-  }
-  return null;
-}
-var CLASS_MEMBER_TYPES = /* @__PURE__ */ new Set(["method_definition", "public_field_definition"]);
-var INTERFACE_MEMBER_TYPES = /* @__PURE__ */ new Set(["property_signature", "method_signature"]);
-var ENUM_MEMBER_TYPES = /* @__PURE__ */ new Set(["enum_assignment", "property_identifier"]);
-function extractBodyMemberDocstrings(body, source, memberTypes) {
-  const result = /* @__PURE__ */ new Map();
-  const allChildren = body.children;
-  for (let i = 0; i < allChildren.length; i++) {
-    const child = allChildren[i];
-    if (!memberTypes.has(child.type)) continue;
-    let memberName = null;
-    if (child.type === "property_identifier") {
-      memberName = child.text;
-    } else {
-      const nameNode = child.childForFieldName("name");
-      if (nameNode) memberName = nameNode.text;
-    }
-    if (!memberName || memberName === "constructor") continue;
-    const docstring = findPrecedingDocstring(allChildren, i, source);
-    result.set(memberName, {
-      docstring,
-      declStartIndex: child.startIndex,
-      declColumn: child.startPosition.column
-    });
-  }
-  return result;
-}
-var nodeMergeAdapter = {
-  language: "node",
-  grammarModule: "tree-sitter-typescript/bindings/node/typescript.js",
-  normalizeReexport: normalizeJsExtension,
-  parseStatements(tree, source) {
-    const imports = [];
-    const importAnchors = [];
-    const statements = [];
-    for (const child of tree.rootNode.children) {
-      if (child.type === "comment") continue;
-      if (child.type === "import_statement") {
-        const text = source.slice(child.startIndex, child.endIndex);
-        const sourceNode = child.childForFieldName("source");
-        const modulePath = sourceNode ? normalizeJsExtension(sourceNode.text) : normalizeJsExtension(text.trim());
-        imports.push({ key: modulePath, text });
-        importAnchors.push(text);
-        continue;
-      }
-      const { key, kind } = extractNodeKey(child);
-      statements.push({
-        key,
-        kind,
-        text: source.slice(child.startIndex, child.endIndex)
-      });
-    }
-    return { imports, importAnchors, statements };
-  },
-  renderImports(imports) {
-    return imports.map((entry) => entry.text);
-  },
-  extractMembers(tree, source) {
-    const result = /* @__PURE__ */ new Map();
-    for (const child of tree.rootNode.children) {
-      if (child.type !== "export_statement") continue;
-      const decl = child.childForFieldName("declaration");
-      if (!decl) continue;
-      const nameNode = decl.childForFieldName("name");
-      if (!nameNode) continue;
-      const symbolName = nameNode.text;
-      if (decl.type === "class_declaration") {
-        const body = decl.childForFieldName("body");
-        if (!body) continue;
-        const members = extractClassMembers(body, source);
-        result.set(symbolName, { members, bodyEndLine: body.endPosition.row });
-      } else if (decl.type === "interface_declaration") {
-        const body = decl.childForFieldName("body");
-        if (!body) continue;
-        const members = extractInterfaceMembers(body, source);
-        result.set(symbolName, { members, bodyEndLine: body.endPosition.row });
-      } else if (decl.type === "enum_declaration") {
-        const body = decl.childForFieldName("body");
-        if (!body) continue;
-        const members = extractEnumMembers(body, source);
-        result.set(symbolName, { members, bodyEndLine: body.endPosition.row });
-      }
-    }
-    return result;
-  },
-  extractDocstrings(tree, source) {
-    const result = /* @__PURE__ */ new Map();
-    const rootChildren = tree.rootNode.children;
-    for (let i = 0; i < rootChildren.length; i++) {
-      const child = rootChildren[i];
-      if (child.type !== "export_statement") continue;
-      const decl = child.childForFieldName("declaration");
-      if (!decl) continue;
-      const nameNode = decl.childForFieldName("name");
-      if (!nameNode) continue;
-      const docstring = findPrecedingDocstring(rootChildren, i, source);
-      let members = /* @__PURE__ */ new Map();
-      const body = decl.childForFieldName("body");
-      if (body) {
-        if (decl.type === "class_declaration") {
-          members = extractBodyMemberDocstrings(body, source, CLASS_MEMBER_TYPES);
-        } else if (decl.type === "interface_declaration") {
-          members = extractBodyMemberDocstrings(body, source, INTERFACE_MEMBER_TYPES);
-        } else if (decl.type === "enum_declaration") {
-          members = extractBodyMemberDocstrings(body, source, ENUM_MEMBER_TYPES);
-        }
-      }
-      result.set(nameNode.text, {
-        docstring,
-        declStartIndex: child.startIndex,
-        declColumn: child.startPosition.column,
-        members
-      });
-    }
-    return result;
-  }
-};
-
-// src/engine/merge-adapters/php.ts
-function extractPhpDeclarationName(node) {
-  switch (node.type) {
-    case "class_declaration":
-    case "interface_declaration":
-    case "trait_declaration":
-    case "enum_declaration":
-    case "function_definition": {
-      const nameNode = node.childForFieldName("name");
-      return nameNode?.text ?? null;
-    }
-    case "namespace_definition": {
-      const nameNode = node.childForFieldName("name");
-      return nameNode ? `__namespace:${nameNode.text}` : "__namespace:";
-    }
-    default:
-      return null;
-  }
-}
-function findPhpDocstring(children, index, source) {
-  for (let k = index - 1; k >= 0; k--) {
-    const prev = children[k];
-    if (prev.type === "comment") {
-      const text = source.slice(prev.startIndex, prev.endIndex);
-      if (text.startsWith("/**")) {
-        return { text, startIndex: prev.startIndex, endIndex: prev.endIndex };
-      }
-      return null;
-    }
-    if (prev.type === ";" || prev.type === "{") continue;
-    return null;
-  }
-  return null;
-}
-var phpMergeAdapter = {
-  language: "php",
-  grammarModule: "tree-sitter-php",
-  resolveGrammar: (mod) => {
-    if (typeof mod === "object" && mod !== null && "php" in mod) return mod.php;
-    return mod;
-  },
-  parseStatements(tree, source) {
-    const imports = [];
-    const importAnchors = [];
-    let importInsertionAnchor;
-    const statements = [];
-    for (const child of tree.rootNode.children) {
-      if (child.type === "comment") continue;
-      if (child.type === "namespace_definition") {
-        importInsertionAnchor = source.slice(child.startIndex, child.endIndex);
-      }
-      if (child.type === "namespace_use_declaration") {
-        const text = source.slice(child.startIndex, child.endIndex);
-        imports.push({ key: text.trim(), text });
-        importAnchors.push(text);
-        continue;
-      }
-      const declarationName = extractPhpDeclarationName(child);
-      const kind = declarationName ? "declaration" : "other";
-      statements.push({
-        key: declarationName,
-        kind,
-        text: source.slice(child.startIndex, child.endIndex)
-      });
-    }
-    return { imports, importAnchors, importInsertionAnchor, statements };
-  },
-  renderImports(imports) {
-    return imports.map((entry) => entry.text);
-  },
-  extractDocstrings(tree, source) {
-    const result = /* @__PURE__ */ new Map();
-    const rootChildren = tree.rootNode.children;
-    for (let i = 0; i < rootChildren.length; i++) {
-      const child = rootChildren[i];
-      const name = extractPhpDeclarationName(child);
-      if (!name || name.startsWith("__namespace:")) continue;
-      const docstring = findPhpDocstring(rootChildren, i, source);
-      const members = /* @__PURE__ */ new Map();
-      const body = child.childForFieldName("body");
-      if (body) {
-        const bodyChildren = body.children;
-        for (let j = 0; j < bodyChildren.length; j++) {
-          const member = bodyChildren[j];
-          if (member.type !== "method_declaration") continue;
-          const memberName = member.childForFieldName("name")?.text;
-          if (!memberName) continue;
-          const memberDoc = findPhpDocstring(bodyChildren, j, source);
-          members.set(memberName, {
-            docstring: memberDoc,
-            declStartIndex: member.startIndex,
-            declColumn: member.startPosition.column
-          });
-        }
-      }
-      result.set(name, {
-        docstring,
-        declStartIndex: child.startIndex,
-        declColumn: child.startPosition.column,
-        members
-      });
-    }
-    return result;
-  }
-};
-
-// src/engine/merge-adapters/python.ts
-function extractPythonDeclarationName(node) {
-  if (node.type === "class_definition" || node.type === "function_definition") {
-    const nameNode = node.childForFieldName("name");
-    return nameNode?.text ?? null;
-  }
-  if (node.type === "expression_statement") {
-    const firstChild = node.firstNamedChild;
-    if (firstChild?.type === "assignment") {
-      const left = firstChild.childForFieldName("left");
-      if (left?.type === "identifier" && left.text === "__all__") {
-        return "__all__";
-      }
-    }
-  }
-  return null;
-}
-function extractPythonDocstring(bodyNode, source) {
-  for (const child of bodyNode.namedChildren) {
-    if (child.type === "expression_statement") {
-      const expr = child.firstNamedChild;
-      if (expr?.type === "string") {
-        const text = source.slice(child.startIndex, child.endIndex);
-        return { text, startIndex: child.startIndex, endIndex: child.endIndex };
-      }
-    }
-    break;
-  }
-  return null;
-}
-function collectPrecedingPythonComments(children, index, source) {
-  let lastIdx = -1;
-  let firstIdx = -1;
-  for (let k = index - 1; k >= 0; k--) {
-    const prev = children[k];
-    if (prev.type === "comment") {
-      if (lastIdx === -1) lastIdx = k;
-      firstIdx = k;
-    } else {
-      break;
-    }
-  }
-  if (firstIdx === -1) return null;
-  const first = children[firstIdx];
-  const last = children[lastIdx];
-  return { text: source.slice(first.startIndex, last.endIndex), startIndex: first.startIndex, endIndex: last.endIndex };
-}
-var pythonMergeAdapter = {
-  language: "python",
-  grammarModule: "tree-sitter-python",
-  parseStatements(tree, source) {
-    const imports = [];
-    const importAnchors = [];
-    const statements = [];
-    for (const child of tree.rootNode.children) {
-      if (child.type === "comment") continue;
-      if (child.type === "import_statement" || child.type === "import_from_statement") {
-        const text = source.slice(child.startIndex, child.endIndex);
-        imports.push({ key: text.trim(), text });
-        importAnchors.push(text);
-        continue;
-      }
-      const declarationName = extractPythonDeclarationName(child);
-      const kind = declarationName ? "declaration" : "other";
-      statements.push({
-        key: declarationName,
-        kind,
-        text: source.slice(child.startIndex, child.endIndex)
-      });
-    }
-    return { imports, importAnchors, statements };
-  },
-  renderImports(imports) {
-    return imports.map((entry) => entry.text);
-  },
-  extractDocstrings(tree, source) {
-    const result = /* @__PURE__ */ new Map();
-    const rootChildren = tree.rootNode.children;
-    for (let i = 0; i < rootChildren.length; i++) {
-      const child = rootChildren[i];
-      const name = extractPythonDeclarationName(child);
-      if (!name) continue;
-      let docstring = null;
-      const body = child.childForFieldName("body");
-      if (body) {
-        docstring = extractPythonDocstring(body, source);
-      }
-      if (!docstring) {
-        docstring = collectPrecedingPythonComments(rootChildren, i, source);
-      }
-      const members = /* @__PURE__ */ new Map();
-      if (child.type === "class_definition" && body) {
-        for (const member of body.namedChildren) {
-          if (member.type !== "function_definition") continue;
-          const memberName = member.childForFieldName("name")?.text;
-          if (!memberName) continue;
-          let memberDoc = null;
-          const memberBody = member.childForFieldName("body");
-          if (memberBody) {
-            memberDoc = extractPythonDocstring(memberBody, source);
-          }
-          members.set(memberName, {
-            docstring: memberDoc,
-            declStartIndex: member.startIndex,
-            declColumn: member.startPosition.column
-          });
-        }
-      }
-      result.set(name, {
-        docstring,
-        declStartIndex: child.startIndex,
-        declColumn: child.startPosition.column,
-        members
-      });
-    }
-    return result;
-  }
-};
-
-// src/engine/merge-adapters/ruby.ts
-function isRequireCall(node) {
-  if (node.type !== "call") return false;
-  const method = node.childForFieldName("method");
-  if (!method) return false;
-  return method.text === "require" || method.text === "require_relative";
-}
-function extractRubyDeclarationName(node) {
-  if (node.type !== "class" && node.type !== "module") return null;
-  const nameNode = node.childForFieldName("name");
-  return nameNode?.text ?? null;
-}
-function collectPrecedingRubyComments(children, index, source) {
-  let lastIdx = -1;
-  let firstIdx = -1;
-  for (let k = index - 1; k >= 0; k--) {
-    const prev = children[k];
-    const nodeType = prev.grammarType ?? prev.type;
-    if (nodeType === "comment") {
-      const text = source.slice(prev.startIndex, prev.endIndex);
-      if (text.startsWith("#")) {
-        if (lastIdx === -1) lastIdx = k;
-        firstIdx = k;
-      } else {
-        break;
-      }
-    } else {
-      break;
-    }
-  }
-  if (firstIdx === -1) return null;
-  const first = children[firstIdx];
-  const last = children[lastIdx];
-  return { text: source.slice(first.startIndex, last.endIndex), startIndex: first.startIndex, endIndex: last.endIndex };
-}
-var rubyMergeAdapter = {
-  language: "ruby",
-  grammarModule: "tree-sitter-ruby",
-  parseStatements(tree, source) {
-    const imports = [];
-    const importAnchors = [];
-    const statements = [];
-    for (const child of tree.rootNode.children) {
-      if (child.type === "comment") continue;
-      const declarationName = extractRubyDeclarationName(child);
-      if (isRequireCall(child)) {
-        const text = source.slice(child.startIndex, child.endIndex);
-        imports.push({ key: text.trim(), text });
-        importAnchors.push(text);
-        continue;
-      }
-      const kind = declarationName ? "declaration" : "other";
-      statements.push({
-        key: declarationName,
-        kind,
-        text: source.slice(child.startIndex, child.endIndex)
-      });
-    }
-    return { imports, importAnchors, statements };
-  },
-  renderImports(imports) {
-    return imports.map((entry) => entry.text);
-  },
-  extractDocstrings(tree, source) {
-    const result = /* @__PURE__ */ new Map();
-    const rootChildren = tree.rootNode.children;
-    for (let i = 0; i < rootChildren.length; i++) {
-      const child = rootChildren[i];
-      const name = extractRubyDeclarationName(child);
-      if (!name) continue;
-      const docstring = collectPrecedingRubyComments(rootChildren, i, source);
-      const members = /* @__PURE__ */ new Map();
-      if (child.type === "class" || child.type === "module") {
-        const allClassChildren = child.children;
-        const body = child.childForFieldName("body");
-        let firstMethodDocFromClass = null;
-        for (let j = 0; j < allClassChildren.length; j++) {
-          if (allClassChildren[j] === body || allClassChildren[j].type === "body_statement") {
-            firstMethodDocFromClass = collectPrecedingRubyComments(allClassChildren, j, source);
-            break;
-          }
-        }
-        if (body) {
-          const bodyChildren = body.children;
-          let firstMethodHandled = false;
-          for (let j = 0; j < bodyChildren.length; j++) {
-            const member = bodyChildren[j];
-            if (member.type !== "method") continue;
-            const memberName = member.childForFieldName("name")?.text;
-            if (!memberName) continue;
-            let memberDoc;
-            if (!firstMethodHandled && firstMethodDocFromClass) {
-              memberDoc = firstMethodDocFromClass;
-              firstMethodHandled = true;
-            } else {
-              memberDoc = collectPrecedingRubyComments(bodyChildren, j, source);
-              firstMethodHandled = true;
-            }
-            members.set(memberName, {
-              docstring: memberDoc,
-              declStartIndex: member.startIndex,
-              declColumn: member.startPosition.column
-            });
-          }
-        }
-      }
-      result.set(name, {
-        docstring,
-        declStartIndex: child.startIndex,
-        declColumn: child.startPosition.column,
-        members
-      });
-    }
-    return result;
-  }
-};
-
-// src/engine/merge-adapters/rust.ts
-function declarationKey2(node) {
-  switch (node.type) {
-    case "struct_item":
-    case "enum_item":
-    case "function_item":
-    case "trait_item":
-    case "type_item":
-    case "const_item": {
-      return node.childForFieldName("name")?.text ?? null;
-    }
-    case "impl_item": {
-      const typeName = node.childForFieldName("type")?.text ?? "unknown";
-      const traitName = node.childForFieldName("trait")?.text;
-      return traitName ? `impl:${traitName}->${typeName}` : `impl:${typeName}`;
-    }
-    default:
-      return null;
-  }
-}
-function collectPrecedingRustDocComments(children, index, source) {
-  let lastIdx = -1;
-  let firstIdx = -1;
-  for (let k = index - 1; k >= 0; k--) {
-    const prev = children[k];
-    if (prev.type === "line_comment") {
-      const text = source.slice(prev.startIndex, prev.endIndex);
-      if (text.startsWith("///")) {
-        if (lastIdx === -1) lastIdx = k;
-        firstIdx = k;
-      } else {
-        break;
-      }
-    } else {
-      break;
-    }
-  }
-  if (firstIdx === -1) return null;
-  const first = children[firstIdx];
-  const last = children[lastIdx];
-  return { text: source.slice(first.startIndex, last.endIndex), startIndex: first.startIndex, endIndex: last.endIndex };
-}
-var rustMergeAdapter = {
-  language: "rust",
-  grammarModule: "tree-sitter-rust",
-  parseStatements(tree, source) {
-    const imports = [];
-    const importAnchors = [];
-    const statements = [];
-    for (const child of tree.rootNode.children) {
-      if (child.type === "comment") continue;
-      if (child.type === "use_declaration") {
-        const text = source.slice(child.startIndex, child.endIndex);
-        imports.push({ key: text.trim(), text });
-        importAnchors.push(text);
-        continue;
-      }
-      const key = declarationKey2(child);
-      statements.push({
-        key,
-        kind: key ? "declaration" : "other",
-        text: source.slice(child.startIndex, child.endIndex)
-      });
-    }
-    return { imports, importAnchors, statements };
-  },
-  renderImports(imports) {
-    return imports.map((entry) => entry.text);
-  },
-  extractDocstrings(tree, source) {
-    const result = /* @__PURE__ */ new Map();
-    const rootChildren = tree.rootNode.children;
-    for (let i = 0; i < rootChildren.length; i++) {
-      const child = rootChildren[i];
-      const key = declarationKey2(child);
-      if (!key) continue;
-      const docstring = collectPrecedingRustDocComments(rootChildren, i, source);
-      result.set(key, {
-        docstring,
-        declStartIndex: child.startIndex,
-        declColumn: child.startPosition.column,
-        members: /* @__PURE__ */ new Map()
-      });
-    }
-    return result;
-  }
-};
-
-// src/engine/merge-adapters/index.ts
-var adapters = /* @__PURE__ */ new Map([
-  ["go", goMergeAdapter],
-  ["node", nodeMergeAdapter],
-  ["php", phpMergeAdapter],
-  ["python", pythonMergeAdapter],
-  ["ruby", rubyMergeAdapter],
-  ["rust", rustMergeAdapter]
-]);
-function getMergeAdapter(language) {
-  return adapters.get(language);
-}
-
-// src/engine/merger.ts
-var parserCache = /* @__PURE__ */ new Map();
-function findIgnoredRegions(source) {
-  const regions = [];
-  const startTag = "@oagen-ignore-start";
-  const endTag = "@oagen-ignore-end";
-  let searchFrom = 0;
-  while (true) {
-    const startIdx = source.indexOf(startTag, searchFrom);
-    if (startIdx === -1) break;
-    const endIdx = source.indexOf(endTag, startIdx + startTag.length);
-    if (endIdx === -1) break;
-    regions.push({ startIndex: startIdx, endIndex: endIdx + endTag.length });
-    searchFrom = endIdx + endTag.length;
-  }
-  return regions;
-}
-function buildIgnoredSymbolNames(docstrings, regions) {
-  if (regions.length === 0) return /* @__PURE__ */ new Set();
-  const ignored = /* @__PURE__ */ new Set();
-  for (const [name, info] of docstrings) {
-    if (regions.some((r) => info.declStartIndex >= r.startIndex && info.declStartIndex <= r.endIndex)) {
-      ignored.add(name);
-    }
-  }
-  return ignored;
-}
-function hasGrammar(language) {
-  return getMergeAdapter(language) !== void 0;
-}
-async function getParser(language) {
-  const cached = parserCache.get(language);
-  if (cached) return cached;
-  const adapter = getMergeAdapter(language);
-  if (!adapter) {
-    throw new Error(
-      `No tree-sitter grammar configured for language "${language}". Add a merge adapter and install the corresponding tree-sitter grammar package.`
-    );
-  }
-  const mod = await import(adapter.grammarModule);
-  const exported = adapter.resolveGrammar ? adapter.resolveGrammar(mod) : mod;
-  const grammar = exported.default ?? exported;
-  const parser = new Parser();
-  parser.setLanguage(grammar);
-  parserCache.set(language, parser);
-  return parser;
-}
-async function extractStatements(source, language) {
-  const parser = await getParser(language);
-  const adapter = getMergeAdapter(language);
-  if (!adapter) {
-    throw new Error(`No merge adapter configured for language "${language}"`);
-  }
-  const tree = safeParse(parser, source);
-  return adapter.parseStatements(tree, source);
-}
-async function mergeIntoExisting(existingContent, generatedContent, language, header) {
-  const adapter = getMergeAdapter(language);
-  if (!adapter) {
-    throw new Error(`No merge adapter configured for language "${language}"`);
-  }
-  const existingStatements = await extractStatements(existingContent, language);
-  const generatedStatements = await extractStatements(generatedContent, language);
-  const existingKeys = /* @__PURE__ */ new Set();
-  const existingUnnamedTexts = /* @__PURE__ */ new Set();
-  const existingImportKeys = /* @__PURE__ */ new Set();
-  const existingReexports = /* @__PURE__ */ new Set();
-  let lastImportEndIndex = -1;
-  const existingImportedNames = /* @__PURE__ */ new Set();
-  for (const imp of existingStatements.imports) {
-    existingImportKeys.add(imp.key);
-    const braceMatch = imp.text.match(/\{([^}]+)\}/);
-    if (braceMatch) {
-      for (const name of braceMatch[1].split(",")) {
-        const trimmed = name.replace(/\btype\b/, "").trim();
-        if (trimmed) existingImportedNames.add(trimmed);
-      }
-    }
-  }
-  for (const anchor of existingStatements.importAnchors) {
-    const linesBefore = existingContent.slice(0, existingContent.indexOf(anchor)).split("\n").length - 1;
-    const stmtLines = anchor.split("\n").length;
-    lastImportEndIndex = linesBefore + stmtLines - 1;
-  }
-  if (lastImportEndIndex === -1 && existingStatements.importInsertionAnchor) {
-    const linesBefore = existingContent.slice(0, existingContent.indexOf(existingStatements.importInsertionAnchor)).split("\n").length - 1;
-    const stmtLines = existingStatements.importInsertionAnchor.split("\n").length;
-    lastImportEndIndex = linesBefore + stmtLines - 1;
-  }
-  for (const stmt of existingStatements.statements) {
-    if (stmt.kind === "reexport") {
-      existingReexports.add(adapter.normalizeReexport ? adapter.normalizeReexport(stmt.text.trim()) : stmt.text.trim());
-    }
-    if (stmt.key) {
-      existingKeys.add(stmt.key);
-    } else {
-      existingUnnamedTexts.add(stmt.text.trim());
-    }
-  }
-  const headerLine = header.trim();
-  const newImports = [];
-  const toAppend = [];
-  let preserved = 0;
-  for (const imp of generatedStatements.imports) {
-    if (imp.text.trim() === headerLine) continue;
-    if (existingImportKeys.has(imp.key)) {
-      preserved++;
-      continue;
-    }
-    newImports.push(imp);
-  }
-  for (const stmt of generatedStatements.statements) {
-    if (stmt.text.trim() === headerLine) continue;
-    if (stmt.kind === "reexport") {
-      const normalizedText = adapter.normalizeReexport ? adapter.normalizeReexport(stmt.text.trim()) : stmt.text.trim();
-      if (existingReexports.has(normalizedText) || stmt.key !== null && existingKeys.has(stmt.key)) {
-        preserved++;
-        continue;
-      }
-    }
-    if (stmt.key && (existingKeys.has(stmt.key) || existingImportedNames.has(stmt.key))) {
-      preserved++;
-      continue;
-    }
-    if (!stmt.key) {
-      if (existingUnnamedTexts.has(stmt.text.trim())) {
-        preserved++;
-        continue;
-      }
-    }
-    toAppend.push(stmt.text);
-  }
-  if (newImports.length === 0 && toAppend.length === 0) {
-    if (!adapter.extractMembers) {
-    }
-  }
-  let result = existingContent;
-  if (toAppend.length > 0) {
-    result = result.trimEnd() + "\n\n" + toAppend.join("\n\n") + "\n";
-  }
-  let deepAdded = 0;
-  if (adapter.extractMembers) {
-    const parser = await getParser(language);
-    const resultTree = safeParse(parser, result);
-    const generatedTree = safeParse(parser, generatedContent);
-    const resultSymbols = adapter.extractMembers(resultTree, result);
-    const generatedSymbols = adapter.extractMembers(generatedTree, generatedContent);
-    const existingTree = safeParse(parser, existingContent);
-    const existingDocs = adapter.extractDocstrings(existingTree, existingContent);
-    const deepIgnoredRegions = findIgnoredRegions(existingContent);
-    const deepIgnoredSymbols = buildIgnoredSymbolNames(existingDocs, deepIgnoredRegions);
-    const insertions = [];
-    for (const [symbolName, genSymbol] of generatedSymbols) {
-      if (deepIgnoredSymbols.has(symbolName)) continue;
-      const existSymbol = resultSymbols.get(symbolName);
-      if (!existSymbol) continue;
-      const existingMemberKeys = new Set(existSymbol.members.map((m) => m.key));
-      const newMembers = genSymbol.members.filter((m) => !existingMemberKeys.has(m.key));
-      if (newMembers.length > 0) {
-        const insertText = newMembers.map((m) => "  " + m.text).join("\n");
-        insertions.push({ line: existSymbol.bodyEndLine, text: insertText });
-        deepAdded += newMembers.length;
-      }
-    }
-    if (insertions.length > 0) {
-      insertions.sort((a, b) => b.line - a.line);
-      const resultLines = result.split("\n");
-      for (const ins of insertions) {
-        resultLines.splice(ins.line, 0, ins.text);
-      }
-      result = resultLines.join("\n");
-    }
-  }
-  if (newImports.length > 0 && (toAppend.length > 0 || deepAdded > 0)) {
-    const renderedImports = adapter.renderImports ? adapter.renderImports(newImports) : newImports.map((entry) => entry.text);
-    const lines = result.split("\n");
-    const insertIdx = lastImportEndIndex + 1;
-    lines.splice(insertIdx, 0, ...renderedImports);
-    result = lines.join("\n");
-  }
-  let docstringUpdates = 0;
-  {
-    const parser = await getParser(language);
-    const resultTree = safeParse(parser, result);
-    const generatedTree = safeParse(parser, generatedContent);
-    const resultDocs = adapter.extractDocstrings(resultTree, result);
-    const generatedDocs = adapter.extractDocstrings(generatedTree, generatedContent);
-    const docIgnoredRegions = findIgnoredRegions(result);
-    const docIgnoredSymbols = buildIgnoredSymbolNames(resultDocs, docIgnoredRegions);
-    const edits = [];
-    for (const [symbolName, genInfo] of generatedDocs) {
-      const existInfo = resultDocs.get(symbolName);
-      if (!existInfo) continue;
-      if (docIgnoredSymbols.has(symbolName)) continue;
-      const genDoc = genInfo.docstring && genInfo.docstring.text.trim() !== headerLine ? 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
-            });
-            docstringUpdates++;
-          }
-        } else {
-          const lineStart = existInfo.declStartIndex - existInfo.declColumn;
-          const indent = " ".repeat(existInfo.declColumn);
-          edits.push({
-            start: lineStart,
-            end: lineStart,
-            newText: indent + genDoc.text + "\n"
-          });
-          docstringUpdates++;
-        }
-      }
-      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
-            });
-            docstringUpdates++;
-          }
-        } else {
-          const lineStart = existMember.declStartIndex - existMember.declColumn;
-          const indent = " ".repeat(existMember.declColumn);
-          edits.push({
-            start: lineStart,
-            end: lineStart,
-            newText: indent + genMember.docstring.text + "\n"
-          });
-          docstringUpdates++;
-        }
-      }
-    }
-    if (edits.length > 0) {
-      edits.sort((a, b) => b.start - a.start);
-      for (const edit of edits) {
-        result = result.slice(0, edit.start) + edit.newText + result.slice(edit.end);
-      }
-    }
-  }
-  const importsActuallyAdded = toAppend.length > 0 || deepAdded > 0 ? adapter.renderImports ? adapter.renderImports(newImports).length : newImports.length : 0;
-  const topLevelAdded = importsActuallyAdded + toAppend.length;
-  const totalAdded = topLevelAdded + deepAdded;
-  if (totalAdded === 0 && docstringUpdates === 0) {
-    return { content: existingContent, added: 0, preserved, changed: false };
-  }
-  return {
-    content: result,
-    added: totalAdded,
-    preserved,
-    changed: true
-  };
-}
-
-// src/engine/json-merge.ts
-function deepMergeJson(existing, generated) {
-  if (typeof existing === "object" && existing !== null && !Array.isArray(existing) && typeof generated === "object" && generated !== null && !Array.isArray(generated)) {
-    const merged = { ...existing };
-    for (const [key, value] of Object.entries(generated)) {
-      if (key in merged) {
-        merged[key] = deepMergeJson(merged[key], value);
-      } else {
-        merged[key] = value;
-      }
-    }
-    return merged;
-  }
-  return generated;
-}
-
-// src/engine/writer.ts
-async function writeFiles(files, outputDir, options) {
-  const result = { written: [], merged: [], skipped: [], identical: [], ignored: [] };
-  const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
-  const language = options?.language;
-  const header = options?.header ?? "";
-  for (const file of sorted) {
-    const fullPath = path.join(outputDir, file.path);
-    let existingContent = null;
-    try {
-      existingContent = await fs.readFile(fullPath, "utf-8");
-    } catch {
-    }
-    if (existingContent === null) {
-      await fs.mkdir(path.dirname(fullPath), { recursive: true });
-      await fs.writeFile(fullPath, file.content, "utf-8");
-      result.written.push(file.path);
-      continue;
-    }
-    if (file.skipIfExists) {
-      if (header && !existingContent.startsWith(header)) {
-        await fs.writeFile(fullPath, header + "\n\n" + existingContent, "utf-8");
-      }
-      result.skipped.push(file.path);
-      continue;
-    }
-    if (existingContent.includes("@oagen-ignore-file")) {
-      result.ignored.push(file.path);
-      continue;
-    }
-    if (existingContent === file.content) {
-      result.identical.push(file.path);
-      continue;
-    }
-    if (file.path.endsWith(".json")) {
-      try {
-        const existingJson = JSON.parse(existingContent);
-        const generatedJson = JSON.parse(file.content);
-        const merged = deepMergeJson(existingJson, generatedJson);
-        const mergedContent = JSON.stringify(merged, null, 2) + "\n";
-        if (mergedContent === existingContent) {
-          result.identical.push(file.path);
-        } else {
-          await fs.writeFile(fullPath, mergedContent, "utf-8");
-          result.merged.push(file.path);
-        }
-      } catch {
-        await fs.writeFile(fullPath, file.content, "utf-8");
-        result.written.push(file.path);
-      }
-      continue;
-    }
-    if (language && hasGrammar(language)) {
-      try {
-        const mergeResult = await mergeIntoExisting(existingContent, file.content, language, header);
-        let finalContent = mergeResult.content;
-        if (header && !finalContent.startsWith(header)) {
-          finalContent = header + "\n\n" + finalContent;
-        }
-        if (!mergeResult.changed && finalContent === existingContent) {
-          result.identical.push(file.path);
-          continue;
-        }
-        await fs.writeFile(fullPath, finalContent, "utf-8");
-        result.merged.push(file.path);
-        continue;
-      } catch (err) {
-        console.warn(
-          `[oagen] AST merge failed for ${file.path}, falling back to overwrite.${err instanceof Error ? ` ${err.message}` : ""}`
-        );
-        await fs.writeFile(fullPath, file.content, "utf-8");
-        result.written.push(file.path);
-        continue;
-      }
-    }
-    result.skipped.push(file.path);
-  }
-  return result;
-}
-
-// src/engine/integrate.ts
-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;
-    return {
-      ...f,
-      skipIfExists: false,
-      // Always merge in target — never hard-skip
-      path: stripped
-    };
-  });
-}
-async function integrateGeneratedFiles(opts) {
-  return writeFiles(mapFilesForTargetIntegration(opts.files, opts.language), opts.targetDir, {
-    language: opts.language,
-    header: opts.header
-  });
-}
-
-// src/engine/orchestrator.ts
-async function generate(spec, emitter, options) {
-  const { files: withHeaders, header } = generateFiles(spec, emitter, options);
-  if (options.dryRun) {
-    if (options.target) {
-      console.log(`
-Target integration (${options.target}):`);
-      for (const f of withHeaders) {
-        console.log(`  ${f.path}`);
-      }
-    }
-    return withHeaders;
-  }
-  const writeResult = await writeFiles(withHeaders, options.outputDir, {
-    language: emitter.language,
-    header
-  });
-  if (writeResult.merged.length > 0) {
-    console.log(`Merged into ${writeResult.merged.length} existing files (additive only)`);
-  }
-  if (writeResult.ignored.length > 0) {
-    console.log(`Ignored ${writeResult.ignored.length} files (@oagen-ignore-file)`);
-  }
-  if (options.target) {
-    const targetResult = await integrateGeneratedFiles({
-      files: withHeaders,
-      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)`);
-    }
-  }
-  return withHeaders;
-}
-
-// src/engine/registry.ts
-var emitters = /* @__PURE__ */ new Map();
-function registerEmitter(emitter) {
-  emitters.set(emitter.language, emitter);
-}
-function getEmitter(language) {
-  const emitter = emitters.get(language);
-  if (!emitter) {
-    const available = [...emitters.keys()].join(", ") || "(none)";
-    throw new RegistryError(
-      `Unknown language: ${language}. Available: ${available}`,
-      `Register an emitter for "${language}" via registerEmitter() or check your oagen.config.ts plugin configuration.`
-    );
-  }
-  return emitter;
-}
-
-// src/differ/classify.ts
-function classifyFieldChange(kind, fieldName, isRequired) {
-  switch (kind) {
-    case "field-added":
-      return {
-        kind,
-        fieldName,
-        classification: isRequired ? "breaking" : "additive"
-      };
-    case "field-removed":
-      return { kind, fieldName, classification: "breaking" };
-    case "field-type-changed":
-      return { kind, fieldName, classification: "breaking" };
-    case "field-required-changed":
-      return {
-        kind,
-        fieldName,
-        classification: isRequired ? "breaking" : "additive",
-        details: isRequired ? "optional \u2192 required" : "required \u2192 optional"
-      };
-    case "field-access-changed":
-      return { kind, fieldName, classification: "breaking" };
-  }
-}
-function classifyParamChange(kind, paramName, isRequired) {
-  switch (kind) {
-    case "param-added":
-      return {
-        kind,
-        paramName,
-        classification: isRequired ? "breaking" : "additive"
-      };
-    case "param-removed":
-      return { kind, paramName, classification: "breaking" };
-    case "param-type-changed":
-      return { kind, paramName, classification: "breaking" };
-    case "param-required-changed":
-      return {
-        kind,
-        paramName,
-        classification: isRequired ? "breaking" : "additive"
-      };
-  }
-}
-
-// src/differ/models.ts
-function diffModels(oldModels, newModels) {
-  const changes = [];
-  const oldByName = new Map(oldModels.map((m) => [m.name, m]));
-  const newByName = new Map(newModels.map((m) => [m.name, m]));
-  for (const [name] of newByName) {
-    if (!oldByName.has(name)) {
-      changes.push({ kind: "model-added", name, classification: "additive" });
-    }
-  }
-  for (const [name] of oldByName) {
-    if (!newByName.has(name)) {
-      changes.push({ kind: "model-removed", name, classification: "breaking" });
-    }
-  }
-  for (const [name, newModel] of newByName) {
-    const oldModel = oldByName.get(name);
-    if (!oldModel) continue;
-    const fieldChanges = diffFields(oldModel, newModel);
-    if (fieldChanges.length > 0) {
-      const hasBreaking = fieldChanges.some((fc) => fc.classification === "breaking");
-      changes.push({
-        kind: "model-modified",
-        name,
-        fieldChanges,
-        classification: hasBreaking ? "breaking" : "additive"
-      });
-    }
-  }
-  return changes;
-}
-function diffFields(oldModel, newModel) {
-  const changes = [];
-  const oldByName = new Map(oldModel.fields.map((f) => [f.name, f]));
-  const newByName = new Map(newModel.fields.map((f) => [f.name, f]));
-  for (const [name, field] of newByName) {
-    if (!oldByName.has(name)) {
-      changes.push(classifyFieldChange("field-added", name, field.required));
-    }
-  }
-  for (const [name] of oldByName) {
-    if (!newByName.has(name)) {
-      changes.push(classifyFieldChange("field-removed", name));
-    }
-  }
-  for (const [name, newField] of newByName) {
-    const oldField = oldByName.get(name);
-    if (!oldField) continue;
-    if (!typeRefsEqual(oldField.type, newField.type)) {
-      changes.push({
-        kind: "field-type-changed",
-        fieldName: name,
-        classification: "breaking",
-        details: `type changed`
-      });
-    }
-    if (oldField.required !== newField.required) {
-      changes.push(classifyFieldChange("field-required-changed", name, newField.required));
-    }
-    if (!!oldField.readOnly !== !!newField.readOnly || !!oldField.writeOnly !== !!newField.writeOnly) {
-      changes.push(classifyFieldChange("field-access-changed", name));
-    }
-  }
-  return changes;
-}
-function typeRefsEqual(a, b) {
-  if (a.kind !== b.kind) return false;
-  switch (a.kind) {
-    case "primitive":
-      return b.kind === "primitive" && a.type === b.type && (a.format ?? "") === (b.format ?? "");
-    case "array":
-      return b.kind === "array" && typeRefsEqual(a.items, b.items);
-    case "model":
-      return b.kind === "model" && a.name === b.name;
-    case "enum":
-      return b.kind === "enum" && a.name === b.name;
-    case "literal":
-      return b.kind === "literal" && a.value === b.value;
-    case "nullable":
-      return b.kind === "nullable" && typeRefsEqual(a.inner, b.inner);
-    case "union": {
-      if (b.kind !== "union") return false;
-      if (a.variants.length !== b.variants.length) return false;
-      if (!a.variants.every((v, i) => typeRefsEqual(v, b.variants[i]))) return false;
-      if (!a.discriminator && !b.discriminator) return true;
-      if (!a.discriminator || !b.discriminator) return false;
-      if (a.discriminator.property !== b.discriminator.property) return false;
-      const aKeys = Object.keys(a.discriminator.mapping).sort();
-      const bKeys = Object.keys(b.discriminator.mapping).sort();
-      if (aKeys.length !== bKeys.length) return false;
-      return aKeys.every((k, i) => k === bKeys[i] && a.discriminator.mapping[k] === b.discriminator.mapping[k]);
-    }
-    case "map":
-      return b.kind === "map" && typeRefsEqual(a.valueType, b.valueType);
-  }
-  return assertNever(a);
-}
-
-// src/differ/operations.ts
-function diffOperations(serviceName, oldOps, newOps) {
-  const changes = [];
-  const oldByName = new Map(oldOps.map((o) => [o.name, o]));
-  const newByName = new Map(newOps.map((o) => [o.name, o]));
-  for (const [name] of newByName) {
-    if (!oldByName.has(name)) {
-      changes.push({
-        kind: "operation-added",
-        serviceName,
-        operationName: name,
-        classification: "additive"
-      });
-    }
-  }
-  for (const [name] of oldByName) {
-    if (!newByName.has(name)) {
-      changes.push({
-        kind: "operation-removed",
-        serviceName,
-        operationName: name,
-        classification: "breaking"
-      });
-    }
-  }
-  for (const [name, newOp] of newByName) {
-    const oldOp = oldByName.get(name);
-    if (!oldOp) continue;
-    const paramChanges = diffParams(oldOp, newOp);
-    const responseChanged = !typeRefsEqual(oldOp.response, newOp.response);
-    const requestBodyChanged = !requestBodiesEqual(oldOp.requestBody, newOp.requestBody);
-    const httpMethodChanged = oldOp.httpMethod !== newOp.httpMethod;
-    const pathChanged = oldOp.path !== newOp.path;
-    const paginatedChanged = !!oldOp.pagination !== !!newOp.pagination;
-    const injectIdempotencyKeyChanged = oldOp.injectIdempotencyKey !== newOp.injectIdempotencyKey;
-    const errorsDiff = classifyErrorsChange(oldOp.errors, newOp.errors);
-    const errorsChanged = errorsDiff !== "none";
-    const hasChanges = paramChanges.length > 0 || responseChanged || requestBodyChanged || httpMethodChanged || pathChanged || paginatedChanged || injectIdempotencyKeyChanged || errorsChanged;
-    if (hasChanges) {
-      const paginatedBreaking = paginatedChanged && !newOp.pagination;
-      const injectIdempotencyKeyBreaking = injectIdempotencyKeyChanged && !newOp.injectIdempotencyKey;
-      const errorsBreaking = errorsDiff === "breaking";
-      const hasBreaking = responseChanged || requestBodyChanged || httpMethodChanged || pathChanged || paginatedBreaking || injectIdempotencyKeyBreaking || errorsBreaking || paramChanges.some((pc) => pc.classification === "breaking");
-      changes.push({
-        kind: "operation-modified",
-        serviceName,
-        operationName: name,
-        paramChanges,
-        responseChanged,
-        requestBodyChanged,
-        httpMethodChanged,
-        pathChanged,
-        paginatedChanged,
-        injectIdempotencyKeyChanged,
-        errorsChanged,
-        classification: hasBreaking ? "breaking" : "additive"
-      });
-    }
-  }
-  return changes;
-}
-function requestBodiesEqual(a, b) {
-  if (!a && !b) return true;
-  if (!a || !b) return false;
-  return typeRefsEqual(a, b);
-}
-function classifyErrorsChange(oldErrors, newErrors) {
-  const oldByCode = new Map(oldErrors.map((e) => [e.statusCode, e]));
-  const newByCode = new Map(newErrors.map((e) => [e.statusCode, e]));
-  let hasAdditive = false;
-  let hasBreaking = false;
-  for (const code of newByCode.keys()) {
-    if (!oldByCode.has(code)) hasAdditive = true;
-  }
-  for (const code of oldByCode.keys()) {
-    if (!newByCode.has(code)) hasBreaking = true;
-  }
-  for (const [code, newErr] of newByCode) {
-    const oldErr = oldByCode.get(code);
-    if (!oldErr) continue;
-    if (!oldErr.type && !newErr.type) continue;
-    if (!oldErr.type || !newErr.type || !typeRefsEqual(oldErr.type, newErr.type)) {
-      hasBreaking = true;
-    }
-  }
-  if (hasBreaking) return "breaking";
-  if (hasAdditive) return "additive";
-  return "none";
-}
-function diffParams(oldOp, newOp) {
-  const changes = [];
-  const allOldParams = [...oldOp.pathParams, ...oldOp.queryParams, ...oldOp.headerParams];
-  const allNewParams = [...newOp.pathParams, ...newOp.queryParams, ...newOp.headerParams];
-  const oldByName = new Map(allOldParams.map((p) => [p.name, p]));
-  const newByName = new Map(allNewParams.map((p) => [p.name, p]));
-  for (const [name, param] of newByName) {
-    if (!oldByName.has(name)) {
-      changes.push(classifyParamChange("param-added", name, param.required));
-    }
-  }
-  for (const [name] of oldByName) {
-    if (!newByName.has(name)) {
-      changes.push(classifyParamChange("param-removed", name));
-    }
-  }
-  for (const [name, newParam] of newByName) {
-    const oldParam = oldByName.get(name);
-    if (!oldParam) continue;
-    if (!typeRefsEqual(oldParam.type, newParam.type)) {
-      changes.push(classifyParamChange("param-type-changed", name));
-    }
-    if (oldParam.required !== newParam.required) {
-      changes.push(classifyParamChange("param-required-changed", name, newParam.required));
-    }
-  }
-  return changes;
-}
-
-// src/differ/services.ts
-function diffServices(oldServices, newServices) {
-  const changes = [];
-  const oldByName = new Map(oldServices.map((s) => [s.name, s]));
-  const newByName = new Map(newServices.map((s) => [s.name, s]));
-  for (const [name] of newByName) {
-    if (!oldByName.has(name)) {
-      changes.push({ kind: "service-added", name, classification: "additive" });
-    }
-  }
-  for (const [name] of oldByName) {
-    if (!newByName.has(name)) {
-      changes.push({ kind: "service-removed", name, classification: "breaking" });
-    }
-  }
-  for (const [name, newService] of newByName) {
-    const oldService = oldByName.get(name);
-    if (!oldService) continue;
-    changes.push(...diffOperations(name, oldService.operations, newService.operations));
-  }
-  return changes;
-}
-
-// src/differ/diff.ts
-function diffSpecs(oldSpec, newSpec) {
-  const changes = [
-    ...diffModels(oldSpec.models, newSpec.models),
-    ...diffEnums(oldSpec.enums, newSpec.enums),
-    ...diffServices(oldSpec.services, newSpec.services)
-  ];
-  return {
-    oldVersion: oldSpec.version,
-    newVersion: newSpec.version,
-    changes,
-    summary: summarize(changes)
-  };
-}
-function diffEnums(oldEnums, newEnums) {
-  const changes = [];
-  const oldByName = new Map(oldEnums.map((e) => [e.name, e]));
-  const newByName = new Map(newEnums.map((e) => [e.name, e]));
-  for (const [name] of newByName) {
-    if (!oldByName.has(name)) {
-      changes.push({ kind: "enum-added", name, classification: "additive" });
-    }
-  }
-  for (const [name] of oldByName) {
-    if (!newByName.has(name)) {
-      changes.push({ kind: "enum-removed", name, classification: "breaking" });
-    }
-  }
-  for (const [name, newEnum] of newByName) {
-    const oldEnum = oldByName.get(name);
-    if (!oldEnum) continue;
-    const valueChanges = diffEnumValues(oldEnum, newEnum);
-    if (valueChanges.length > 0) {
-      const hasBreaking = valueChanges.some((vc) => vc.classification === "breaking");
-      changes.push({
-        kind: "enum-modified",
-        name,
-        valueChanges,
-        classification: hasBreaking ? "breaking" : "additive"
-      });
-    }
-  }
-  return changes;
-}
-function diffEnumValues(oldEnum, newEnum) {
-  const changes = [];
-  const oldByName = new Map(oldEnum.values.map((v) => [v.name, v]));
-  const newByName = new Map(newEnum.values.map((v) => [v.name, v]));
-  for (const [name] of newByName) {
-    if (!oldByName.has(name)) {
-      changes.push({ kind: "value-added", valueName: name, classification: "additive" });
-    }
-  }
-  for (const [name] of oldByName) {
-    if (!newByName.has(name)) {
-      changes.push({ kind: "value-removed", valueName: name, classification: "breaking" });
-    }
-  }
-  for (const [name, newVal] of newByName) {
-    const oldVal = oldByName.get(name);
-    if (!oldVal) continue;
-    if (oldVal.value !== newVal.value) {
-      changes.push({
-        kind: "value-changed",
-        valueName: name,
-        classification: "breaking",
-        details: `value changed from '${oldVal.value}' to '${newVal.value}'`
-      });
-    }
-  }
-  return changes;
-}
-function summarize(changes) {
-  let added = 0;
-  let removed = 0;
-  let modified = 0;
-  let breaking = 0;
-  let additive = 0;
-  for (const c of changes) {
-    if (c.kind.endsWith("-added")) added++;
-    else if (c.kind.endsWith("-removed")) removed++;
-    else if (c.kind.endsWith("-modified")) modified++;
-    if (c.classification === "breaking") breaking++;
-    else additive++;
-  }
-  return { added, removed, modified, breaking, additive };
-}
-
-export {
-  buildEmitterContext,
-  generateAllFiles,
-  applyFileHeaders,
-  generateFiles,
-  mapFilesForTargetIntegration,
-  integrateGeneratedFiles,
-  generate,
-  registerEmitter,
-  getEmitter,
-  diffSpecs
-};