@workos/oagen 0.26.1 → 0.28.0

package/dist/compat/index.mjs

@@ -1,5 +1,5 @@
 import { t as safeParse$1, v as ExtractorError } from "../tree-sitter-C6HB4OrC.mjs";
-import { A as getDefaultPolicy, C as defaultSeverityForCategory, D as isCompatibleSchemaVersion, E as COMPAT_SCHEMA_VERSION, O as validateSnapshot, S as summarizeChanges, T as apiSurfaceToSnapshot, _ as nodeHints, a as registerExtractor, b as classifyAddedSymbol, c as filterSurface, d as specDerivedHttpKeys, f as specDerivedMethodPaths, g as namedTypeWordsOverlap, h as defaultIsNullableOnlyDifference, i as getExtractor, j as mergePolicy, k as ALL_LANGUAGE_IDS, l as specDerivedEnumValues, m as NAMED_TYPE_RE, n as isPatchableChange, o as diffSnapshots, p as specDerivedNames, r as patchOverlay, s as diffSurfaces, t as buildOverlayLookup, u as specDerivedFieldPaths, v as resolveHints, w as severityMeetsThreshold, x as classifySymbolChanges, y as typeExistsInSurface } from "../overlay-DcvsIx5P.mjs";
+import { A as getDefaultPolicy, C as defaultSeverityForCategory, D as isCompatibleSchemaVersion, E as COMPAT_SCHEMA_VERSION, O as validateSnapshot, S as summarizeChanges, T as apiSurfaceToSnapshot, _ as nodeHints, a as registerExtractor, b as classifyAddedSymbol, c as filterSurface, d as specDerivedHttpKeys, f as specDerivedMethodPaths, g as namedTypeWordsOverlap, h as defaultIsNullableOnlyDifference, i as getExtractor, j as mergePolicy, k as ALL_LANGUAGE_IDS, l as specDerivedEnumValues, m as NAMED_TYPE_RE, n as isPatchableChange, o as diffSnapshots, p as specDerivedNames, r as patchOverlay, s as diffSurfaces, t as buildOverlayLookup, u as specDerivedFieldPaths, v as resolveHints, w as severityMeetsThreshold, x as classifySymbolChanges, y as typeExistsInSurface } from "../overlay-jsSkFJ2g.mjs";
 import path, { basename, dirname, join, relative, resolve } from "node:path";
 import Parser from "tree-sitter";
 import ts from "typescript";
@@ -700,7 +700,7 @@ function parseConstElement(constElement) {
 		value: valueNode.text
 	};
 }
-function parseMethods$2(classBody) {
+function parseMethods$3(classBody) {
 	const methods = [];
 	const allPromotedProperties = [];
 	for (const child of classBody.namedChildren) {
@@ -759,7 +759,7 @@ function parseMethods$2(classBody) {
 		promotedProperties: allPromotedProperties
 	};
 }
-function parseProperties$1(classBody) {
+function parseProperties$2(classBody) {
 	const properties = [];
 	for (const child of classBody.namedChildren) {
 		if (child.type !== "property_declaration") continue;
@@ -830,8 +830,8 @@ function parseClassDeclarations(tree, sourceFile, namespace) {
 		}
 		const bodyNode = node.childForFieldName("body");
 		if (!bodyNode) continue;
-		const { methods, promotedProperties } = parseMethods$2(bodyNode);
-		const properties = parseProperties$1(bodyNode);
+		const { methods, promotedProperties } = parseMethods$3(bodyNode);
+		const properties = parseProperties$2(bodyNode);
 		const constants = parseConstants(bodyNode);
 		const resourceAttributes = parseResourceAttributes(bodyNode);
 		const hasCustomConstructor = methods.some((m) => m.name === "constructFromResponse" && m.isStatic);
@@ -858,7 +858,7 @@ function parseInterfaceDeclarations(tree, sourceFile, namespace) {
 		if (!nameNode) continue;
 		const bodyNode = node.childForFieldName("body");
 		if (!bodyNode) continue;
-		const { methods } = parseMethods$2(bodyNode);
+		const { methods } = parseMethods$3(bodyNode);
 		interfaces.push({
 			name: nameNode.text,
 			namespace,
@@ -897,7 +897,7 @@ function parseEnumDeclarations(tree, sourceFile, namespace) {
 				value
 			});
 		}
-		const { methods } = parseMethods$2(bodyNode);
+		const { methods } = parseMethods$3(bodyNode);
 		enums.push({
 			name: nameNode.text,
 			namespace,
@@ -970,7 +970,7 @@ function isExceptionClass$1(cls, exceptionBases) {
 	if (!cls.extends) return false;
 	return exceptionBases.has(cls.extends);
 }
-function buildSurface$6(allClasses, hints) {
+function buildSurface$7(allClasses, hints) {
 	const resourceBases = new Set(hints?.modelBaseClasses ?? DEFAULT_RESOURCE_BASES);
 	const exceptionBases = new Set(hints?.exceptionBaseClasses ?? DEFAULT_EXCEPTION_BASES$1);
 	const classes = {};
@@ -1211,7 +1211,7 @@ function createPhpExtractor(hintOverrides) {
 				const parsed = parsePhpFile(filePath, sdkPath);
 				allClasses.push(...parsed.classes);
 			}
-			const { classes, interfaces, enums, exports } = buildSurface$6(allClasses, mergedHints);
+			const { classes, interfaces, enums, exports } = buildSurface$7(allClasses, mergedHints);
 			return {
 				language: "php",
 				extractedFrom: sdkPath,
@@ -1641,7 +1641,7 @@ function unwrapReturnType(returnType) {
 	if (awaitableMatch) return awaitableMatch[1];
 	return returnType;
 }
-function buildSurface$5(parsedFiles, hints) {
+function buildSurface$6(parsedFiles, hints) {
 	const MODEL_BASES = new Set(hints?.modelBaseClasses ?? DEFAULT_MODEL_BASES);
 	const EXCEPTION_BASES = new Set(hints?.exceptionBaseClasses ?? DEFAULT_EXCEPTION_BASES);
 	const classes = {};
@@ -2092,7 +2092,7 @@ function createPythonExtractor(hintOverrides) {
 				const parsed = parsePythonFile(filePath, sdkPath);
 				parsedFiles.push(parsed);
 			}
-			const { classes, interfaces, typeAliases, enums, exports } = buildSurface$5(parsedFiles, mergedHints);
+			const { classes, interfaces, typeAliases, enums, exports } = buildSurface$6(parsedFiles, mergedHints);
 			return {
 				language: "python",
 				extractedFrom: sdkPath,
@@ -2865,7 +2865,7 @@ function buildQualifiedNames(items) {
 	}
 	return result;
 }
-function buildSurface$4(allStructs, allTypes, allFuncs, allConsts) {
+function buildSurface$5(allStructs, allTypes, allFuncs, allConsts) {
 	const classes = {};
 	const interfaces = {};
 	const typeAliases = {};
@@ -3110,7 +3110,7 @@ const goExtractor = {
 			allFuncs.push(...parsed.funcs);
 			allConsts.push(...parsed.consts);
 		}
-		const { classes, interfaces, typeAliases, enums, exports } = buildSurface$4(allStructs, allTypes, allFuncs, allConsts);
+		const { classes, interfaces, typeAliases, enums, exports } = buildSurface$5(allStructs, allTypes, allFuncs, allConsts);
 		return {
 			language: "go",
 			extractedFrom: sdkPath,
@@ -3281,7 +3281,7 @@ function parseEnums$1(tree, sourceFile) {
 	}
 	return enums;
 }
-function parseParams(paramsNode) {
+function parseParams$1(paramsNode) {
 	const params = [];
 	for (const child of paramsNode.namedChildren) {
 		if (child.type === "self_parameter") continue;
@@ -3321,7 +3321,7 @@ function parseImplBlocks(tree, sourceFile) {
 			funcs.push({
 				receiverType,
 				name: nameNode.text,
-				params: paramsNode ? parseParams(paramsNode) : [],
+				params: paramsNode ? parseParams$1(paramsNode) : [],
 				returnType: extractReturnType(child),
 				isAsync: isAsyncFunc(child),
 				sourceFile
@@ -3347,7 +3347,7 @@ function parseTraits(tree, sourceFile) {
 			methods.push({
 				receiverType: null,
 				name: methodName.text,
-				params: paramsNode ? parseParams(paramsNode) : [],
+				params: paramsNode ? parseParams$1(paramsNode) : [],
 				returnType: extractReturnType(child),
 				isAsync: isAsyncFunc(child),
 				sourceFile
@@ -3399,7 +3399,7 @@ function unwrapResultType(returnType) {
 	if (match) return match[1].trim();
 	return returnType;
 }
-function buildSurface$3(allStructs, allEnums, allFuncs, allTraits, allTypeAliases) {
+function buildSurface$4(allStructs, allEnums, allFuncs, allTraits, allTypeAliases) {
 	const classes = {};
 	const interfaces = {};
 	const typeAliases = {};
@@ -3604,7 +3604,7 @@ const rustExtractor = {
 			allTraits.push(...parsed.traits);
 			allTypeAliases.push(...parsed.typeAliases);
 		}
-		const { classes, interfaces, typeAliases, enums, exports } = buildSurface$3(allStructs, allEnums, allFuncs, allTraits, allTypeAliases);
+		const { classes, interfaces, typeAliases, enums, exports } = buildSurface$4(allStructs, allEnums, allFuncs, allTraits, allTypeAliases);
 		return {
 			language: "rust",
 			extractedFrom: sdkPath,
@@ -3652,7 +3652,7 @@ function extractPackageName(source) {
 	return match ? match[1] : "unknown";
 }
 /** Strip single-line and block comments from source to avoid false matches. */
-function stripComments$1(source) {
+function stripComments$2(source) {
 	let result = source.replace(/\/\*[\s\S]*?\*\//g, "");
 	result = result.replace(/\/\/[^\n]*/g, "");
 	return result;
@@ -3671,7 +3671,7 @@ function extractJsonPropertyName$1(text) {
 */
 function parseConstructorParams(paramsBlock) {
 	const fields = [];
-	const params = splitTopLevelCommas(paramsBlock);
+	const params = splitTopLevelCommas$1(paramsBlock);
 	for (const param of params) {
 		const trimmed = param.trim();
 		if (!trimmed) continue;
@@ -3693,7 +3693,7 @@ function parseConstructorParams(paramsBlock) {
 	return fields;
 }
 /** Split a string by top-level commas, ignoring commas inside angle brackets, parens, or strings. */
-function splitTopLevelCommas(text) {
+function splitTopLevelCommas$1(text) {
 	const result = [];
 	let depth = 0;
 	let current = "";
@@ -3799,7 +3799,7 @@ function parseClasses$1(source, sourceFile, packageName) {
 		const classBody = source.slice(braceStart + 1, idx - 1);
 		const constructorParams = [];
 		if (constructorBlock.trim()) {
-			const params = splitTopLevelCommas(constructorBlock);
+			const params = splitTopLevelCommas$1(constructorBlock);
 			for (const param of params) {
 				const paramMatch = param.trim().match(/(?:(?:private|protected)\s+)?(?:val|var)\s+(\w+)\s*:\s*(.+)/);
 				if (paramMatch) constructorParams.push({
@@ -3808,7 +3808,7 @@ function parseClasses$1(source, sourceFile, packageName) {
 				});
 			}
 		}
-		const methods = parseMethods$1(classBody);
+		const methods = parseMethods$2(classBody);
 		if (methods.length > 0) classes.push({
 			name,
 			constructorParams,
@@ -3820,7 +3820,7 @@ function parseClasses$1(source, sourceFile, packageName) {
 	return classes;
 }
 /** Parse method declarations from a class body. */
-function parseMethods$1(classBody) {
+function parseMethods$2(classBody) {
 	const methods = [];
 	const methodRegex = /(private|protected|internal|public)?\s*(?:suspend\s+)?fun\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*([^\s{]+))?/g;
 	let match;
@@ -3832,7 +3832,7 @@ function parseMethods$1(classBody) {
 		if (visibility === "private" || visibility === "protected") continue;
 		const params = [];
 		if (paramsStr.trim()) {
-			const paramParts = splitTopLevelCommas(paramsStr);
+			const paramParts = splitTopLevelCommas$1(paramsStr);
 			for (const part of paramParts) {
 				const paramMatch = part.trim().match(/(\w+)\s*:\s*([^=]+?)(?:\s*=\s*(.+))?$/);
 				if (paramMatch) {
@@ -3871,7 +3871,7 @@ function parseTypeAliases(source, sourceFile, packageName) {
 function parseKotlinFile(filePath, sdkPath) {
 	const source = readFileSync(filePath, "utf-8");
 	const relPath = relative(sdkPath, filePath);
-	const cleaned = stripComments$1(source);
+	const cleaned = stripComments$2(source);
 	const packageName = extractPackageName(cleaned);
 	return {
 		dataClasses: parseDataClasses(cleaned, relPath, packageName),
@@ -3882,7 +3882,7 @@ function parseKotlinFile(filePath, sdkPath) {
 }
 //#endregion
 //#region src/compat/extractors/kotlin-surface.ts
-function buildSurface$2(allDataClasses, allClasses, allEnums, allTypeAliases) {
+function buildSurface$3(allDataClasses, allClasses, allEnums, allTypeAliases) {
 	const classes = {};
 	const interfaces = {};
 	const typeAliases = {};
@@ -4040,7 +4040,7 @@ const kotlinExtractor = {
 			allEnums.push(...parsed.enums);
 			allTypeAliases.push(...parsed.typeAliases);
 		}
-		const { classes, interfaces, typeAliases, enums, exports } = buildSurface$2(allDataClasses, allClasses, allEnums, allTypeAliases);
+		const { classes, interfaces, typeAliases, enums, exports } = buildSurface$3(allDataClasses, allClasses, allEnums, allTypeAliases);
 		return {
 			language: "kotlin",
 			extractedFrom: sdkPath,
@@ -4091,7 +4091,7 @@ function extractNamespace(source) {
 	return "unknown";
 }
 /** Strip single-line and block comments from source. */
-function stripComments(source) {
+function stripComments$1(source) {
 	let result = source.replace(/\/\*[\s\S]*?\*\//g, "");
 	result = result.replace(/\/\/[^\n]*/g, "");
 	return result;
@@ -4151,8 +4151,8 @@ function parseClasses(source, sourceFile) {
 			idx++;
 		}
 		const classBody = source.slice(braceStart + 1, idx - 1);
-		const properties = parseProperties(classBody);
-		const methods = parseMethods(classBody);
+		const properties = parseProperties$1(classBody);
+		const methods = parseMethods$1(classBody);
 		const constructorParams = parseConstructor(classBody, name);
 		const isService = methods.length > 0;
 		classes.push({
@@ -4168,7 +4168,7 @@ function parseClasses(source, sourceFile) {
 	return classes;
 }
 /** Parse properties from a class body. */
-function parseProperties(classBody) {
+function parseProperties$1(classBody) {
 	const properties = [];
 	const lines = classBody.split("\n");
 	let pendingJsonName = null;
@@ -4198,7 +4198,7 @@ function parseProperties(classBody) {
 	return properties;
 }
 /** Parse methods from a class body. */
-function parseMethods(classBody) {
+function parseMethods$1(classBody) {
 	const methods = [];
 	const methodRegex = /(private|protected|internal|public)\s+(?:(static)\s+)?(?:(async)\s+)?(\S+(?:<[^>]+>)?)\s+(\w+)\s*\(([^)]*)\)/g;
 	let match;
@@ -4260,7 +4260,7 @@ function parseConstructor(classBody, className) {
 function parseCSharpFile(filePath, sdkPath) {
 	const source = readFileSync(filePath, "utf-8");
 	const relPath = relative(sdkPath, filePath);
-	const cleaned = stripComments(source);
+	const cleaned = stripComments$1(source);
 	return {
 		classes: parseClasses(cleaned, relPath),
 		enums: parseEnums(cleaned, relPath)
@@ -4268,7 +4268,7 @@ function parseCSharpFile(filePath, sdkPath) {
 }
 //#endregion
 //#region src/compat/extractors/dotnet-surface.ts
-function buildSurface$1(allClasses, allEnums, _hints) {
+function buildSurface$2(allClasses, allEnums, _hints) {
 	const classes = {};
 	const interfaces = {};
 	const enums = {};
@@ -4540,7 +4540,7 @@ function createDotnetExtractor(hintOverrides) {
 				allClasses.push(...parsed.classes);
 				allEnums.push(...parsed.enums);
 			}
-			const { classes, interfaces, enums, exports } = buildSurface$1(allClasses, allEnums, mergedHints);
+			const { classes, interfaces, enums, exports } = buildSurface$2(allClasses, allEnums, mergedHints);
 			return {
 				language: "dotnet",
 				extractedFrom: sdkPath,
@@ -4592,7 +4592,7 @@ function walkElixirFiles(dir) {
 */
 function stripCommentsAndHeredocs(source) {
 	let result = source.replace(/"""[\s\S]*?"""/g, "\"\"\"\"\"\"");
-	result = result.replace(/#[^\n]*/g, "");
+	result = result.replace(/#(?!\{)[^\n]*/g, "");
 	return result;
 }
 /**
@@ -4772,6 +4772,24 @@ function extractTypeSpecs(modules, sourceFile) {
 	}
 	return specs;
 }
+/** Named escapes Elixir recognizes inside double-quoted strings/atoms. */
+const ELIXIR_STRING_ESCAPES = {
+	"0": "\0",
+	a: "\x07",
+	b: "\b",
+	d: "",
+	e: "\x1B",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	s: " ",
+	t: "	",
+	v: "\v"
+};
+/** Undo backslash escapes inside a double-quoted Elixir string/atom. */
+function unescapeElixirString(s) {
+	return s.replace(/\\(.)/g, (_, ch) => ELIXIR_STRING_ESCAPES[ch] ?? ch);
+}
 function extractEnumModules(modules, sourceFile) {
 	const enumModules = [];
 	for (const { name: moduleName, body: moduleBody } of modules) {
@@ -4786,6 +4804,24 @@ function extractEnumModules(modules, sourceFile) {
 			if (funcName === "values") continue;
 			members[funcName] = funcValue;
 		}
+		const hadNamedMembers = Object.keys(members).length > 0;
+		const valuesList = moduleBody.match(/def\s+values,\s*do:\s*\[((?:"(?:[^"\\]|\\.)*"|[^\]"])*)\]/);
+		if (valuesList) {
+			const tokenRegex = /:"((?:[^"\\]|\\.)*)"|:([a-zA-Z_][a-zA-Z0-9_@]*[?!]?)|"((?:[^"\\]|\\.)*)"|(-?\d+(?:\.\d+)?)/g;
+			let token;
+			while ((token = tokenRegex.exec(valuesList[1])) !== null) {
+				if (!(token[1] != null || token[2] != null) && hadNamedMembers) continue;
+				const text = token[1] ?? token[2] ?? token[3] ?? token[4];
+				const name = token[2] ?? unescapeElixirString(text);
+				if (!(name in members)) members[name] = unescapeElixirString(text);
+			}
+		}
+		const dumpRegex = /def\s+dump\(:(?:"((?:[^"\\]|\\.)*)"|([a-zA-Z_][a-zA-Z0-9_@]*[?!]?))\),\s*do:\s*"((?:[^"\\]|\\.)*)"/g;
+		let dumpMatch;
+		while ((dumpMatch = dumpRegex.exec(moduleBody)) !== null) {
+			const atomName = dumpMatch[1] != null ? unescapeElixirString(dumpMatch[1]) : dumpMatch[2];
+			if (atomName in members) members[atomName] = unescapeElixirString(dumpMatch[3]);
+		}
 		if (Object.keys(members).length > 0) enumModules.push({
 			moduleName,
 			members,
@@ -4814,7 +4850,7 @@ function shortName(moduleName) {
 	const parts = moduleName.split(".");
 	return parts[parts.length - 1];
 }
-function buildSurface(allStructs, allFunctions, allEnumModules, allTypeSpecs) {
+function buildSurface$1(allStructs, allFunctions, allEnumModules, allTypeSpecs) {
 	const classes = {};
 	const interfaces = {};
 	const enums = {};
@@ -5004,7 +5040,7 @@ const elixirExtractor = {
 			allEnumModules.push(...parsed.enumModules);
 			allTypeSpecs.push(...parsed.typeSpecs);
 		}
-		const { classes, interfaces, enums, exports } = buildSurface(allStructs, allFunctions, allEnumModules, allTypeSpecs);
+		const { classes, interfaces, enums, exports } = buildSurface$1(allStructs, allFunctions, allEnumModules, allTypeSpecs);
 		return {
 			language: "elixir",
 			extractedFrom: sdkPath,
@@ -5018,6 +5054,623 @@ const elixirExtractor = {
 	}
 };
 //#endregion
-export { ALL_LANGUAGE_IDS, COMPAT_SCHEMA_VERSION, apiSurfaceToSnapshot, applyApprovals, buildConceptualRollup, buildOverlayLookup, classifyAddedSymbol, classifySymbolChanges, defaultSeverityForCategory, diffSnapshots, diffSurfaces, dotnetExtractor, elixirExtractor, filterSurface, formatConceptualSummary, formatHumanSummary, generateConceptualReport, generateReport, getDefaultPolicy, getExtractor, goExtractor, highestSeverity, isCompatibleSchemaVersion, isPatchableChange, kotlinExtractor, matchApproval, mergePolicy, nodeExtractor, nodeHints, patchOverlay, phpExtractor, pythonExtractor, registerExtractor, resolveHints, rubyExtractor, rustExtractor, severityMeetsThreshold, specDerivedEnumValues, specDerivedFieldPaths, specDerivedHttpKeys, specDerivedMethodPaths, specDerivedNames, summarizeChanges, summarizeConceptualChanges, unapprovedChanges, validateApproval, validateApprovals, validateSnapshot };
+//#region src/compat/extractors/ios-parser.ts
+/**
+* Swift source parser — regex-based extraction of structs, classes, actors,
+* extensions, enums, and type aliases from Swift source files.
+*
+* Swift-specific concerns handled here that the other parsers can ignore:
+*  - String literals may contain `//` (URLs) and braces, so comment stripping
+*    and brace matching are both string-aware.
+*  - Files marked `@oagen-ignore-file` are hand-maintained and skipped, so an
+*    `extension` of a hand-written type (e.g. `WorkOSClient+Resources.swift`)
+*    owns the surface it contributes.
+*  - Generated enums carry an `unknown(String)` escape-hatch case and encode
+*    member raw values in `init(rawValue:)` / `var rawValue` switches rather
+*    than `case name = "value"` declarations.
+*/
+const SKIP_DIRS = new Set([
+	"build",
+	"Tests",
+	"DerivedData",
+	"Pods",
+	"Carthage"
+]);
+function walkSwiftFiles(dir) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		let stat;
+		try {
+			stat = statSync(fullPath);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) {
+			if (entry.startsWith(".") || SKIP_DIRS.has(entry)) continue;
+			results.push(...walkSwiftFiles(fullPath));
+		} else if (entry.endsWith(".swift") && !entry.endsWith("Tests.swift") && !entry.endsWith("Test.swift") && entry !== "Package.swift") results.push(fullPath);
+	}
+	return results.sort();
+}
+/** Advance past a string literal starting at `idx` (which must point at `"`).
+*  Handles escapes, multi-line `"""` literals, and `\(...)` interpolations —
+*  whose expressions may contain nested string literals and braces. Returns
+*  the index just past the closing quote(s). */
+function skipString(source, idx) {
+	const n = source.length;
+	if (source.startsWith("\"\"\"", idx)) {
+		const end = source.indexOf("\"\"\"", idx + 3);
+		return end === -1 ? n : end + 3;
+	}
+	let i = idx + 1;
+	while (i < n && source[i] !== "\"") {
+		if (source[i] === "\\") {
+			if (source[i + 1] === "(") {
+				let depth = 1;
+				let j = i + 2;
+				while (j < n && depth > 0) {
+					const ch = source[j];
+					if (ch === "\"") {
+						j = skipString(source, j);
+						continue;
+					}
+					if (ch === "(") depth++;
+					else if (ch === ")") depth--;
+					j++;
+				}
+				i = j;
+				continue;
+			}
+			i++;
+		}
+		i++;
+	}
+	return Math.min(i + 1, n);
+}
+/** Strip line and (nesting) block comments. String literals are preserved
+*  verbatim, including any `//` sequences inside them (URLs). */
+function stripComments(source) {
+	let out = "";
+	let i = 0;
+	const n = source.length;
+	while (i < n) {
+		const ch = source[i];
+		if (ch === "\"") {
+			const end = skipString(source, i);
+			out += source.slice(i, end);
+			i = end;
+			continue;
+		}
+		if (ch === "/" && source[i + 1] === "/") {
+			while (i < n && source[i] !== "\n") i++;
+			continue;
+		}
+		if (ch === "/" && source[i + 1] === "*") {
+			let depth = 1;
+			i += 2;
+			while (i < n && depth > 0) if (source[i] === "/" && source[i + 1] === "*") {
+				depth++;
+				i += 2;
+			} else if (source[i] === "*" && source[i + 1] === "/") {
+				depth--;
+				i += 2;
+			} else i++;
+			continue;
+		}
+		out += ch;
+		i++;
+	}
+	return out;
+}
+/** Given the index of an opening `{`, return the index just past its matching
+*  `}`. String-aware so braces inside literals don't skew the depth. */
+function matchBrace(source, openIdx) {
+	const n = source.length;
+	let depth = 1;
+	let i = openIdx + 1;
+	while (i < n && depth > 0) {
+		const ch = source[i];
+		if (ch === "\"") {
+			i = skipString(source, i);
+			continue;
+		}
+		if (ch === "{") depth++;
+		else if (ch === "}") depth--;
+		i++;
+	}
+	return i;
+}
+/** Reduce a type body to its top-level text: nested `{...}` blocks are
+*  replaced with a newline so declaration signatures survive while method
+*  bodies, computed-property accessors, and nested types disappear. */
+function topLevelText(body) {
+	let out = "";
+	let i = 0;
+	const n = body.length;
+	while (i < n) {
+		const ch = body[i];
+		if (ch === "\"") {
+			const end = skipString(body, i);
+			out += body.slice(i, end);
+			i = end;
+			continue;
+		}
+		if (ch === "{") {
+			out += "\n";
+			i = matchBrace(body, i);
+			continue;
+		}
+		out += ch;
+		i++;
+	}
+	return out;
+}
+/** Split by top-level commas, ignoring commas nested in brackets or strings. */
+function splitTopLevelCommas(text) {
+	const result = [];
+	let depth = 0;
+	let current = "";
+	let i = 0;
+	while (i < text.length) {
+		const ch = text[i];
+		if (ch === "\"") {
+			const end = skipString(text, i);
+			current += text.slice(i, end);
+			i = end;
+			continue;
+		}
+		if (ch === "<" || ch === "(" || ch === "[") {
+			depth++;
+			current += ch;
+		} else if (ch === ">" || ch === ")" || ch === "]") {
+			depth--;
+			current += ch;
+		} else if (ch === "," && depth === 0) {
+			result.push(current);
+			current = "";
+		} else current += ch;
+		i++;
+	}
+	if (current.trim()) result.push(current);
+	return result;
+}
+/** Given the index of an opening `(`, return the index just past its matching `)`. */
+function matchParen(source, openIdx) {
+	const n = source.length;
+	let depth = 1;
+	let i = openIdx + 1;
+	while (i < n && depth > 0) {
+		const ch = source[i];
+		if (ch === "\"") {
+			i = skipString(source, i);
+			continue;
+		}
+		if (ch === "(") depth++;
+		else if (ch === ")") depth--;
+		i++;
+	}
+	return i;
+}
+const VISIBILITY_PUBLIC = /\b(?:public|open)\b/;
+/** Parse `label name: Type = default` parameter fragments. The public name is
+*  the external argument label; `_ name:` falls back to the internal name. */
+function parseParams(paramsBlock) {
+	const params = [];
+	for (const part of splitTopLevelCommas(paramsBlock)) {
+		const trimmed = part.trim();
+		if (!trimmed) continue;
+		const paramMatch = trimmed.match(/^(?:(\w+|_)\s+)?(\w+)\s*:\s*([^=]+?)(?:\s*=\s*(.+))?$/s);
+		if (!paramMatch) continue;
+		const label = paramMatch[1];
+		const internalName = paramMatch[2];
+		const type = paramMatch[3].trim();
+		const hasDefault = paramMatch[4] !== void 0;
+		const name = !label || label === "_" ? internalName : label;
+		params.push({
+			name,
+			type,
+			optional: type.endsWith("?") || hasDefault
+		});
+	}
+	return params;
+}
+/** Parse stored and computed property declarations from top-level type text. */
+function parseProperties(surfaceText, defaultPublic) {
+	const properties = [];
+	const propRegex = /^[ \t]*((?:@\w+(?:\([^)]*\))?\s+)*(?:(?:public|open|package|internal|fileprivate|private|static|class|final|lazy|weak|nonisolated)(?:\([^)]*\))?\s+)*)(let|var)\s+(\w+)\s*:\s*([^\n={]+)/gm;
+	let match;
+	while ((match = propRegex.exec(surfaceText)) !== null) {
+		const modifiers = match[1] || "";
+		if (!VISIBILITY_PUBLIC.test(modifiers) && !(defaultPublic && !/\b(?:internal|fileprivate|private|package)\b/.test(modifiers))) continue;
+		if (/\bstatic\b/.test(modifiers)) continue;
+		const keyword = match[2];
+		const name = match[3];
+		const type = match[4].trim();
+		properties.push({
+			name,
+			type,
+			optional: type.endsWith("?"),
+			readonly: keyword === "let"
+		});
+	}
+	return properties;
+}
+/** Parse `func` declarations from top-level type text. */
+function parseMethods(surfaceText, defaultPublic) {
+	const methods = [];
+	const funcRegex = /((?:@\w+(?:\([^)]*\))?\s+)*(?:(?:public|open|package|internal|fileprivate|private|static|class|final|nonisolated|mutating)(?:\([^)]*\))?\s+)*)func\s+(\w+)(?:<[^>]*>)?\s*\(/g;
+	let match;
+	while ((match = funcRegex.exec(surfaceText)) !== null) {
+		const modifiers = match[1] || "";
+		if (!VISIBILITY_PUBLIC.test(modifiers) && !(defaultPublic && !/\b(?:internal|fileprivate|private|package)\b/.test(modifiers))) continue;
+		const name = match[2];
+		const parenOpen = match.index + match[0].length - 1;
+		const parenClose = matchParen(surfaceText, parenOpen);
+		const params = parseParams(surfaceText.slice(parenOpen + 1, parenClose - 1));
+		const tailMatch = surfaceText.slice(parenClose).match(/^\s*(async)?\s*(?:throws|rethrows)?\s*(?:->\s*([^\n]+))?/);
+		let returnType = tailMatch?.[2]?.trim() ?? "Void";
+		const whereIdx = returnType.indexOf(" where ");
+		if (whereIdx !== -1) returnType = returnType.slice(0, whereIdx).trim();
+		methods.push({
+			name,
+			params,
+			returnType,
+			async: tailMatch?.[1] === "async",
+			isStatic: /\b(?:static|class)\b/.test(modifiers)
+		});
+		funcRegex.lastIndex = parenClose;
+	}
+	return methods;
+}
+/** Parse `init` declarations from top-level type text. */
+function parseInits(surfaceText, defaultPublic) {
+	const overloads = [];
+	const initRegex = /((?:@\w+(?:\([^)]*\))?\s+)*(?:(?:public|open|package|internal|fileprivate|private|convenience|required|nonisolated)\s+)*)init\s*\??\s*\(/g;
+	let match;
+	while ((match = initRegex.exec(surfaceText)) !== null) {
+		const modifiers = match[1] || "";
+		if (!VISIBILITY_PUBLIC.test(modifiers) && !(defaultPublic && !/\b(?:internal|fileprivate|private|package)\b/.test(modifiers))) continue;
+		const parenOpen = match.index + match[0].length - 1;
+		const parenClose = matchParen(surfaceText, parenOpen);
+		overloads.push(parseParams(surfaceText.slice(parenOpen + 1, parenClose - 1)));
+		initRegex.lastIndex = parenClose;
+	}
+	return overloads;
+}
+function parseEnumBody(name, body, sourceFile) {
+	const surface = topLevelText(body);
+	const declared = [];
+	const caseLineRegex = /^\s*(?:indirect\s+)?case\s+(.+)$/gm;
+	let match;
+	while ((match = caseLineRegex.exec(surface)) !== null) for (const entry of splitTopLevelCommas(match[1])) {
+		const trimmed = entry.trim();
+		if (!trimmed) continue;
+		const caseMatch = trimmed.match(/^`?(\w+)`?(\([^)]*\))?(?:\s*=\s*"([^"]*)")?/);
+		if (!caseMatch) continue;
+		if (caseMatch[2] !== void 0) continue;
+		declared.push({
+			name: caseMatch[1],
+			rawValue: caseMatch[3]
+		});
+	}
+	if (declared.length === 0) return null;
+	const valueByMember = /* @__PURE__ */ new Map();
+	const getterRegex = /case\s+\.(\w+)\s*:\s*return\s+"((?:[^"\\]|\\.)*)"/g;
+	while ((match = getterRegex.exec(body)) !== null) valueByMember.set(match[1], match[2]);
+	const initRegex = /case\s+"((?:[^"\\]|\\.)*)"\s*:\s*self\s*=\s*\.(\w+)/g;
+	while ((match = initRegex.exec(body)) !== null) if (!valueByMember.has(match[2])) valueByMember.set(match[2], match[1]);
+	const members = {};
+	for (const { name: memberName, rawValue } of declared) members[memberName] = rawValue ?? valueByMember.get(memberName) ?? memberName;
+	return {
+		name,
+		members,
+		sourceFile
+	};
+}
+/** Parse a single Swift source file and return all extracted symbols.
+*  Files marked `@oagen-ignore-file` are hand-maintained and yield nothing. */
+function parseSwiftFile(filePath, sdkPath) {
+	const source = readFileSync(filePath, "utf-8");
+	const relPath = relative(sdkPath, filePath);
+	const empty = {
+		types: [],
+		enums: [],
+		typeAliases: []
+	};
+	if (source.includes("@oagen-ignore-file")) return empty;
+	const cleaned = stripComments(source);
+	const typeDeclRegex = /((?:@\w+(?:\([^)]*\))?\s+)*(?:(?:public|open|package|internal|fileprivate|private|final|indirect)\s+)*)(struct|class|actor|enum)\s+(\w+)(?:<[^>]*>)?(?:\s*:\s*[^{]+?)?\s*\{/g;
+	const extensionRegex = /(^|\n)\s*((?:public|package|internal|fileprivate|private)\s+)?extension\s+(\w+)(?:\s*:\s*[^{]+?)?\s*\{/g;
+	const types = [];
+	const enums = [];
+	const typeAliases = [];
+	let match;
+	while ((match = typeDeclRegex.exec(cleaned)) !== null) {
+		const modifiers = match[1] || "";
+		const kind = match[2];
+		const name = match[3];
+		const braceIdx = match.index + match[0].length - 1;
+		const bodyEnd = matchBrace(cleaned, braceIdx);
+		const body = cleaned.slice(braceIdx + 1, bodyEnd - 1);
+		if (!VISIBILITY_PUBLIC.test(modifiers)) continue;
+		if (kind === "enum") {
+			const parsed = parseEnumBody(name, body, relPath);
+			if (parsed) enums.push(parsed);
+			continue;
+		}
+		const surface = topLevelText(body);
+		types.push({
+			kind,
+			name,
+			properties: parseProperties(surface, false),
+			methods: parseMethods(surface, false),
+			initOverloads: parseInits(surface, false),
+			sourceFile: relPath
+		});
+	}
+	while ((match = extensionRegex.exec(cleaned)) !== null) {
+		const isPublicExtension = (match[2] || "").trim() === "public";
+		const name = match[3];
+		const braceIdx = match.index + match[0].length - 1;
+		const bodyEnd = matchBrace(cleaned, braceIdx);
+		const surface = topLevelText(cleaned.slice(braceIdx + 1, bodyEnd - 1));
+		const decl = {
+			kind: "extension",
+			name,
+			properties: parseProperties(surface, isPublicExtension),
+			methods: parseMethods(surface, isPublicExtension),
+			initOverloads: parseInits(surface, isPublicExtension),
+			sourceFile: relPath
+		};
+		if (decl.properties.length > 0 || decl.methods.length > 0 || decl.initOverloads.length > 0) types.push(decl);
+	}
+	const aliasRegex = /(?:public|open)\s+typealias\s+(\w+)(?:<[^>]*>)?\s*=\s*([^\n]+)/g;
+	while ((match = aliasRegex.exec(cleaned)) !== null) typeAliases.push({
+		name: match[1],
+		value: match[2].trim(),
+		sourceFile: relPath
+	});
+	return {
+		types,
+		enums,
+		typeAliases
+	};
+}
+//#endregion
+//#region src/compat/extractors/ios-surface.ts
+function mergeTypes(allTypes) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const decl of allTypes) {
+		let entry = byName.get(decl.name);
+		if (!entry) {
+			entry = {
+				name: decl.name,
+				declKind: null,
+				properties: [],
+				methods: [],
+				initOverloads: [],
+				sourceFile: decl.sourceFile
+			};
+			byName.set(decl.name, entry);
+		}
+		if (decl.kind !== "extension" && entry.declKind === null) {
+			entry.declKind = decl.kind;
+			entry.sourceFile = decl.sourceFile;
+		}
+		entry.properties.push(...decl.properties);
+		entry.methods.push(...decl.methods);
+		entry.initOverloads.push(...decl.initOverloads);
+	}
+	return [...byName.values()];
+}
+function buildSurface(allTypes, allEnums, allTypeAliases) {
+	const classes = {};
+	const interfaces = {};
+	const typeAliases = {};
+	const enums = {};
+	const collector = new ExportCollector();
+	for (const type of mergeTypes(allTypes)) {
+		if (type.declKind === "struct" && type.methods.length === 0) {
+			if (type.properties.length === 0) continue;
+			const fields = {};
+			for (const prop of type.properties) fields[prop.name] = {
+				name: prop.name,
+				type: prop.type,
+				optional: prop.optional
+			};
+			interfaces[type.name] = {
+				name: type.name,
+				sourceFile: type.sourceFile,
+				fields: sortRecord(fields),
+				extends: []
+			};
+			collector.add(type.sourceFile, type.name);
+			continue;
+		}
+		if (type.methods.length === 0 && type.properties.length === 0) continue;
+		const methods = {};
+		for (const method of type.methods) {
+			const params = method.params.map((p) => ({
+				name: p.name,
+				type: p.type,
+				optional: p.optional,
+				passingStyle: "positional"
+			}));
+			if (!methods[method.name]) methods[method.name] = [];
+			methods[method.name].push({
+				name: method.name,
+				params,
+				returnType: method.returnType,
+				async: method.async,
+				isStatic: method.isStatic
+			});
+		}
+		const properties = {};
+		for (const prop of type.properties) properties[prop.name] = {
+			name: prop.name,
+			type: prop.type,
+			readonly: prop.readonly
+		};
+		const constructorParams = (type.initOverloads[0] ?? []).map((p) => ({
+			name: p.name,
+			type: p.type,
+			optional: p.optional,
+			passingStyle: "positional"
+		}));
+		classes[type.name] = {
+			name: type.name,
+			sourceFile: type.sourceFile,
+			methods: sortRecord(methods),
+			properties: sortRecord(properties),
+			constructorParams
+		};
+		collector.add(type.sourceFile, type.name);
+	}
+	for (const en of allEnums) {
+		enums[en.name] = {
+			name: en.name,
+			sourceFile: en.sourceFile,
+			members: sortRecord(en.members)
+		};
+		collector.add(en.sourceFile, en.name);
+	}
+	for (const ta of allTypeAliases) {
+		typeAliases[ta.name] = {
+			name: ta.name,
+			sourceFile: ta.sourceFile,
+			value: ta.value
+		};
+		collector.add(ta.sourceFile, ta.name);
+	}
+	return {
+		classes: sortRecord(classes),
+		interfaces: sortRecord(interfaces),
+		typeAliases: sortRecord(typeAliases),
+		enums: sortRecord(enums),
+		exports: sortRecord(collector.toRecord())
+	};
+}
+//#endregion
+//#region src/compat/extractors/ios.ts
+/**
+* Swift (iOS) API surface extractor.
+*
+* Walks `.swift` files (excluding tests, Package.swift, and build
+* directories), parses public structs, classes, actors, extensions, enums,
+* and type aliases, then builds an `ApiSurface`.
+*
+* Parser:  `ios-parser.ts`  — string-aware regex Swift source analysis
+* Surface: `ios-surface.ts` — ApiSurface construction
+*/
+const PRIMITIVES = [
+	"String",
+	"Int",
+	"Int32",
+	"Int64",
+	"Double",
+	"Float",
+	"Bool",
+	"Void",
+	"Data",
+	"Date",
+	"URL",
+	"UUID"
+];
+/** Unwrap `[Element]` and `[Key: Value]` sugar; returns the element/value type. */
+function unwrapBrackets(type) {
+	const bracketMatch = type.match(/^\[(.+)\]$/);
+	if (!bracketMatch) return type;
+	const inner = bracketMatch[1].trim();
+	const colonIdx = inner.indexOf(":");
+	return colonIdx === -1 ? inner : inner.slice(colonIdx + 1).trim();
+}
+const iosExtractor = {
+	language: "ios",
+	hints: {
+		stripNullable(type) {
+			if (type.endsWith("?")) return type.slice(0, -1);
+			return null;
+		},
+		isNullableOnlyDifference(a, b) {
+			return defaultIsNullableOnlyDifference(this, a, b);
+		},
+		isUnionReorder(_a, _b) {
+			return false;
+		},
+		isGenericTypeParam(type) {
+			return /^[A-Z]$/.test(type) || /^T[A-Z][a-zA-Z]*$/.test(type);
+		},
+		isExtractionArtifact(type) {
+			return [
+				"Any",
+				"Any?",
+				"AnyObject",
+				"AnyCodable",
+				"AnyCodable?"
+			].includes(type);
+		},
+		tolerateCategoryMismatch: true,
+		extractReturnTypeName(returnType) {
+			let inner = returnType.trim();
+			if (inner.endsWith("?")) inner = inner.slice(0, -1);
+			inner = unwrapBrackets(inner);
+			if (inner.endsWith("?")) inner = inner.slice(0, -1);
+			const pageMatch = inner.match(/^Page<(.+)>$/);
+			if (pageMatch) inner = pageMatch[1];
+			if (PRIMITIVES.includes(inner)) return null;
+			return inner;
+		},
+		extractParamTypeName(paramType) {
+			let inner = paramType.trim();
+			if (inner.endsWith("?")) inner = inner.slice(0, -1);
+			inner = unwrapBrackets(inner);
+			if (inner.endsWith("?")) inner = inner.slice(0, -1);
+			if (PRIMITIVES.includes(inner)) return null;
+			return inner;
+		},
+		propertyMatchesClass(propertyName, className) {
+			return propertyName.toLowerCase() === className.toLowerCase();
+		},
+		derivedModelNames(modelName) {
+			return [`${modelName}Response`];
+		}
+	},
+	async extractSnapshot(sdkPath) {
+		return apiSurfaceToSnapshot(await this.extract(sdkPath));
+	},
+	async extract(sdkPath) {
+		const swiftFiles = walkSwiftFiles(sdkPath);
+		if (swiftFiles.length === 0) throw new ExtractorError(`No .swift files found in ${sdkPath}`, `Ensure the --sdk-path argument points to a Swift package root containing .swift source files.`);
+		const allTypes = [];
+		const allEnums = [];
+		const allTypeAliases = [];
+		for (const filePath of swiftFiles) {
+			const parsed = parseSwiftFile(filePath, sdkPath);
+			allTypes.push(...parsed.types);
+			allEnums.push(...parsed.enums);
+			allTypeAliases.push(...parsed.typeAliases);
+		}
+		const { classes, interfaces, typeAliases, enums, exports } = buildSurface(allTypes, allEnums, allTypeAliases);
+		return {
+			language: "ios",
+			extractedFrom: sdkPath,
+			extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			classes,
+			interfaces,
+			typeAliases,
+			enums,
+			exports
+		};
+	}
+};
+//#endregion
+export { ALL_LANGUAGE_IDS, COMPAT_SCHEMA_VERSION, apiSurfaceToSnapshot, applyApprovals, buildConceptualRollup, buildOverlayLookup, classifyAddedSymbol, classifySymbolChanges, defaultSeverityForCategory, diffSnapshots, diffSurfaces, dotnetExtractor, elixirExtractor, filterSurface, formatConceptualSummary, formatHumanSummary, generateConceptualReport, generateReport, getDefaultPolicy, getExtractor, goExtractor, highestSeverity, iosExtractor, isCompatibleSchemaVersion, isPatchableChange, kotlinExtractor, matchApproval, mergePolicy, nodeExtractor, nodeHints, patchOverlay, phpExtractor, pythonExtractor, registerExtractor, resolveHints, rubyExtractor, rustExtractor, severityMeetsThreshold, specDerivedEnumValues, specDerivedFieldPaths, specDerivedHttpKeys, specDerivedMethodPaths, specDerivedNames, summarizeChanges, summarizeConceptualChanges, unapprovedChanges, validateApproval, validateApprovals, validateSnapshot };
 
 //# sourceMappingURL=index.mjs.map