@workos/oagen 0.13.0 → 0.14.1

package/dist/compat/index.mjs

@@ -1,5 +1,5 @@
 import { t as safeParse$1, v as ExtractorError } from "../tree-sitter-DcUvm0KA.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-xp7F8_dW.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-Dlk7bV5R.mjs";
 import path, { basename, dirname, join, relative, resolve } from "node:path";
 import Parser from "tree-sitter";
 import ts from "typescript";

package/dist/differ-fdF9qogA.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"differ-fdF9qogA.d.mts","names":[],"sources":["../src/compat/classify.ts","../src/compat/spec-filter.ts","../src/compat/differ.ts"],"mappings":";;;;UAaiB,gBAAA;EAcJ;EAZX,QAAA,EAAU,oBAAA;EAAV;EAEA,QAAA,EAAU,oBAAA;EAAV;EAEA,MAAA;EAAA;EAEA,kBAAA;EAEA;EAAA,UAAA,EAAY,gBAAA;EAEZ;EAAA,GAAA,EAAK,MAAA;EAEL;EAAA,GAAA,EAAK,MAAA;EAEL;EAAA,OAAA;EAOW;;AAIb;;;;EAJE,WAAA;AAAA;;UAIe,oBAAA;EACf,OAAA,EAAS,gBAAA;EACT,OAAA;IACE,QAAA;IACA,QAAA;IACA,QAAA;EAAA;AAAA;;;;;iBAYY,qBAAA,CACd,QAAA,EAAU,YAAA,EACV,SAAA,EAAW,YAAA,cACX,MAAA,EAAQ,iBAAA,GACP,gBAAA;;;;iBAkUa,mBAAA,CAAoB,MAAA,EAAQ,YAAA,GAAe,gBAAA;;iBAc3C,gBAAA,CAAiB,OAAA,EAAS,gBAAA,KAAqB,oBAAA;;;;AAhY/D;;;;iBCJgB,gBAAA,CAAiB,IAAA,EAAM,OAAA,EAAS,KAAA,EAAO,aAAA,GAAgB,GAAA;;;;;iBA0CvD,qBAAA,CAAsB,IAAA,EAAM,OAAA,GAAU,GAAA,SAAY,GAAA;;;;;;iBAalD,qBAAA,CAAsB,IAAA,EAAM,OAAA,EAAS,KAAA,EAAO,aAAA,GAAgB,GAAA;;;;;;iBAqB5D,sBAAA,CAAuB,IAAA,EAAM,OAAA,GAAU,GAAA;;;;;iBAcvC,mBAAA,CAAoB,IAAA,EAAM,OAAA,GAAU,GAAA;;;;;;;;;;;;AD1CpD;;;;iBC8FgB,aAAA,CACd,OAAA,EAAS,UAAA,EACT,YAAA,EAAc,GAAA,UACd,IAAA;EACE,UAAA,GAAa,GAAA;EACb,WAAA,GAAc,GAAA;EACd,UAAA,GAAa,GAAA,SAAY,GAAA;AAAA,IAE1B,UAAA;;;;UChIc,gBAAA;EACf,OAAA,EAAS,gBAAA;EACT,OAAA,EAAS,oBAAA;AAAA;;;;;iBAOK,aAAA,CACd,QAAA,EAAU,cAAA,EACV,SAAA,EAAW,cAAA,EACX,MAAA,GAAS,iBAAA,GACR,gBAAA;;;;;;AFJH;;;iBEsMgB,YAAA,CAAa,QAAA,EAAU,UAAA,EAAY,SAAA,EAAW,UAAA,EAAY,KAAA,EAAO,aAAA,GAAgB,UAAA"}
+{"version":3,"file":"differ-fdF9qogA.d.mts","names":[],"sources":["../src/compat/classify.ts","../src/compat/spec-filter.ts","../src/compat/differ.ts"],"mappings":";;;;UAaiB,gBAAA;EAcJ;EAZX,QAAA,EAAU,oBAAA;EAAV;EAEA,QAAA,EAAU,oBAAA;EAAV;EAEA,MAAA;EAAA;EAEA,kBAAA;EAEA;EAAA,UAAA,EAAY,gBAAA;EAEZ;EAAA,GAAA,EAAK,MAAA;EAEL;EAAA,GAAA,EAAK,MAAA;EAEL;EAAA,OAAA;EAOW;;AAIb;;;;EAJE,WAAA;AAAA;;UAIe,oBAAA;EACf,OAAA,EAAS,gBAAA;EACT,OAAA;IACE,QAAA;IACA,QAAA;IACA,QAAA;EAAA;AAAA;;;;;iBAYY,qBAAA,CACd,QAAA,EAAU,YAAA,EACV,SAAA,EAAW,YAAA,cACX,MAAA,EAAQ,iBAAA,GACP,gBAAA;;;;iBAkUa,mBAAA,CAAoB,MAAA,EAAQ,YAAA,GAAe,gBAAA;;iBAc3C,gBAAA,CAAiB,OAAA,EAAS,gBAAA,KAAqB,oBAAA;;;;AAhY/D;;;;iBCJgB,gBAAA,CAAiB,IAAA,EAAM,OAAA,EAAS,KAAA,EAAO,aAAA,GAAgB,GAAA;;;;;iBA0CvD,qBAAA,CAAsB,IAAA,EAAM,OAAA,GAAU,GAAA,SAAY,GAAA;;;;;;iBAalD,qBAAA,CAAsB,IAAA,EAAM,OAAA,EAAS,KAAA,EAAO,aAAA,GAAgB,GAAA;;;;;;iBAqB5D,sBAAA,CAAuB,IAAA,EAAM,OAAA,GAAU,GAAA;;;;;iBAcvC,mBAAA,CAAoB,IAAA,EAAM,OAAA,GAAU,GAAA;;;;;;;;;;;;AD1CpD;;;;iBC8FgB,aAAA,CACd,OAAA,EAAS,UAAA,EACT,YAAA,EAAc,GAAA,UACd,IAAA;EACE,UAAA,GAAa,GAAA;EACb,WAAA,GAAc,GAAA;EACd,UAAA,GAAa,GAAA,SAAY,GAAA;AAAA,IAE1B,UAAA;;;;UChIc,gBAAA;EACf,OAAA,EAAS,gBAAA;EACT,OAAA,EAAS,oBAAA;AAAA;;;;;iBAOK,aAAA,CACd,QAAA,EAAU,cAAA,EACV,SAAA,EAAW,cAAA,EACX,MAAA,GAAS,iBAAA,GACR,gBAAA;;;;;;AFJH;;;iBEopBgB,YAAA,CAAa,QAAA,EAAU,UAAA,EAAY,SAAA,EAAW,UAAA,EAAY,KAAA,EAAO,aAAA,GAAgB,UAAA"}

package/dist/{overlay-xp7F8_dW.mjs → overlay-Dlk7bV5R.mjs}

@@ -913,6 +913,10 @@ function diffSnapshots(baseline, candidate, policy) {
 		changes.push(classifyAddedSymbol(candSym));
 	}
 	detectForkedSchemas(changes, baseline, candidate);
+	const typeRenames = detectTypeRenames(changes, baseline, candidate);
+	const enumRenames = detectEnumRenames(changes, baseline, candidate);
+	inferTransitiveTypeRenames(typeRenames, baseline, candidate, changes);
+	cascadeRenameDowngrades(changes, typeRenames, enumRenames, baseline, candidate);
 	return {
 		changes,
 		summary: summarizeChanges(changes)
@@ -987,6 +991,279 @@ function collectTypeFieldSets(snapshot) {
 	return result;
 }
 /**
+* Detect type renames: a baseline type symbol disappears and a candidate
+* type symbol with the same (or superset) field set takes its place.
+*
+* Common when an upstream spec promotes a single schema into multiple
+* (e.g. `ApiKey` → `OrganizationApiKey` + `UserApiKey`). The wire shape
+* returned by individual endpoints is unchanged — `OrganizationApiKey`
+* has the same fields `ApiKey` had — so consumer code accessing those
+* fields keeps working. The compat report flags `ApiKey` as removed
+* because its symbol is gone; this pass downgrades the removal to
+* soft-risk and records the rename so its child fields/methods cascade.
+*
+* Identity criteria (must all hold):
+*   1. The removed symbol owns ≥ 1 field/property in the baseline (i.e.
+*      it's a type-shaped symbol — model/interface/class — not a plain
+*      function or constant).
+*   2. Some candidate type that did *not* exist in the baseline has a
+*      field set that is a non-strict superset of the removed type's
+*      fields. (Strict-subset would mean fields were lost — a real break.)
+*   3. The candidate type is the alphabetically-first such match, so
+*      pairing is deterministic when multiple candidates fit (e.g. both
+*      `OrganizationApiKey` and `UserApiKey` share the original fields).
+*
+* Returns a `removedName -> newName` map so a downstream cascade pass
+* can downgrade owned-field removals and `*_type_changed` pointing at
+* the same pair.
+*
+* Mutates matching `symbol_removed` entries in `changes`: severity →
+* `soft-risk`, attaches a `remediation` describing the rename.
+*/
+function detectTypeRenames(changes, baseline, candidate) {
+	const renameMap = /* @__PURE__ */ new Map();
+	const baselineTypeFields = collectTypeFieldSets(baseline);
+	const candidateTypeFields = collectTypeFieldSets(candidate);
+	const baselineTypeNames = new Set(baselineTypeFields.keys());
+	const candidateTypesSorted = [...candidateTypeFields.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+	const parentRemovalByName = /* @__PURE__ */ new Map();
+	for (const change of changes) if (change.category === "symbol_removed" && change.severity === "breaking") parentRemovalByName.set(change.old.symbol ?? "", change);
+	for (const [baselineTypeName, baselineFields] of baselineTypeFields) {
+		if (baselineFields.size === 0) continue;
+		const sameNameFields = candidateTypeFields.get(baselineTypeName);
+		if (sameNameFields && setEquals(baselineFields, sameNameFields)) continue;
+		const match = candidateTypesSorted.find(([candName, candFields]) => {
+			if (baselineTypeNames.has(candName)) return false;
+			for (const f of baselineFields) if (!candFields.has(f)) return false;
+			return true;
+		});
+		if (!match) continue;
+		const [newName] = match;
+		renameMap.set(baselineTypeName, newName);
+		const parentRemoval = parentRemovalByName.get(baselineTypeName);
+		if (parentRemoval) {
+			parentRemoval.severity = "soft-risk";
+			parentRemoval.remediation = `Type "${baselineTypeName}" appears to have been renamed to "${newName}" — the new type has every field of the old (a non-strict superset). Field accesses and method calls on values of type "${newName}" continue to work; only explicit "${baselineTypeName}" type annotations need to migrate. Consider emitting a deprecated alias \`type ${baselineTypeName} = ${newName}\` in languages that support it.`;
+		}
+	}
+	return renameMap;
+}
+/**
+* Transitive rename inference. After `detectTypeRenames` records direct
+* structural matches (e.g. `ApiKeyWithValue → OrganizationApiKeyWithValue`),
+* walk the parent's fields and follow the `typeRef.name` of each: if the
+* baseline parent's field references an alias-type `OldOwner` and the new
+* parent's same-named field references a different alias `NewOwner`, the
+* pair is the same type-concept under a renamed name. Record the
+* secondary rename so the cascade can downgrade `OldOwner`'s
+* `symbol_removed` and any `field_type_changed` pointing at the pair.
+*
+* Why this is necessary: discriminated-union owner types (Go's
+* `APIKeyWithValueOwner`, PHP/Python's nested constructor params) are
+* frequently emitted as `kind: 'alias'` symbols with no extractable
+* field children — so `collectTypeFieldSets` returns empty for them and
+* the structural matcher can't pair them directly. The transitive
+* lookup gives us a deterministic, conservative way to propagate the
+* rename: it only fires when the parent rename has already been
+* positively identified, and only follows fields that share the same
+* wire name across baseline and candidate.
+*/
+function inferTransitiveTypeRenames(typeRenames, baseline, candidate, changes) {
+	if (typeRenames.size === 0) return;
+	const baselineFieldType = /* @__PURE__ */ new Map();
+	for (const sym of baseline.symbols) {
+		if (sym.kind !== "field" && sym.kind !== "property") continue;
+		if (!sym.ownerFqName || !sym.typeRef) continue;
+		const localName = sym.fqName.includes(".") ? sym.fqName.slice(sym.fqName.lastIndexOf(".") + 1) : sym.fqName;
+		baselineFieldType.set(`${sym.ownerFqName}.${localName.toLowerCase()}`, sym.typeRef.name);
+	}
+	const candidateFieldType = /* @__PURE__ */ new Map();
+	for (const sym of candidate.symbols) {
+		if (sym.kind !== "field" && sym.kind !== "property") continue;
+		if (!sym.ownerFqName || !sym.typeRef) continue;
+		const localName = sym.fqName.includes(".") ? sym.fqName.slice(sym.fqName.lastIndexOf(".") + 1) : sym.fqName;
+		candidateFieldType.set(`${sym.ownerFqName}.${localName.toLowerCase()}`, sym.typeRef.name);
+	}
+	const parentRemovalByName = /* @__PURE__ */ new Map();
+	for (const change of changes) if (change.category === "symbol_removed" && change.severity === "breaking") parentRemovalByName.set(change.old.symbol ?? "", change);
+	const initialEntries = [...typeRenames.entries()];
+	for (const [oldOwner, newOwner] of initialEntries) for (const [baselineKey, baselineFieldTypeRef] of baselineFieldType) {
+		if (!baselineKey.startsWith(`${oldOwner}.`)) continue;
+		const localName = baselineKey.slice(oldOwner.length + 1);
+		const candidateKey = `${newOwner}.${localName}`;
+		const candidateFieldTypeRef = candidateFieldType.get(candidateKey);
+		if (!candidateFieldTypeRef) continue;
+		const oldT = bareTypeName(baselineFieldTypeRef);
+		const newT = bareTypeName(candidateFieldTypeRef);
+		if (!oldT || !newT || oldT === newT) continue;
+		if (typeRenames.has(oldT)) continue;
+		typeRenames.set(oldT, newT);
+		const removal = parentRemovalByName.get(oldT);
+		if (removal) {
+			removal.severity = "soft-risk";
+			removal.remediation = `Type "${oldT}" appears to have been renamed to "${newT}" — inferred transitively because the renamed parent "${oldOwner}" → "${newOwner}" has a "${localName}" field whose type swapped from "${oldT}" to "${newT}". Consider emitting a deprecated alias \`type ${oldT} = ${newT}\` in languages that support it.`;
+		}
+	}
+}
+/**
+* Detect enum canonical-flips: a baseline enum disappears and a candidate
+* enum with the **same wire-value set** takes its place.
+*
+* Caused by the emitter's enum-dedup heuristic picking a different
+* canonical name when a new same-shape enum joins the spec. Languages
+* that emit type aliases (Go, Ruby, Python, PHP, Kotlin) handle this
+* transparently via `type Old = New`; languages without first-class
+* aliases (dotnet) report the old enum as removed. The wire values are
+* unchanged — every legal value still serializes to the same JSON — so
+* consumer code constructing or matching on these enum values keeps
+* working. Only references to the typed enum class need migration.
+*
+* Identity criterion: a removed enum's value set is *exactly* equal to
+* a newly-added enum's value set (not superset — narrowing the value
+* set would be a real break for consumers expecting the dropped values).
+*/
+function detectEnumRenames(changes, baseline, candidate) {
+	const renameMap = /* @__PURE__ */ new Map();
+	const baselineEnumValues = collectEnumValueSets(baseline);
+	const candidateEnumValues = collectEnumValueSets(candidate);
+	const baselineEnumNames = new Set(baselineEnumValues.keys());
+	const candidateEnumsSorted = [...candidateEnumValues.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+	const parentRemovalByName = /* @__PURE__ */ new Map();
+	for (const change of changes) if (change.category === "symbol_removed" && change.severity === "breaking") parentRemovalByName.set(change.old.symbol ?? "", change);
+	for (const [baselineEnumName, baselineValues] of baselineEnumValues) {
+		if (baselineValues.size === 0) continue;
+		const sameNameValues = candidateEnumValues.get(baselineEnumName);
+		if (sameNameValues && setEquals(baselineValues, sameNameValues)) continue;
+		const match = candidateEnumsSorted.find(([candName, candValues]) => !baselineEnumNames.has(candName) && setEquals(baselineValues, candValues));
+		if (!match) continue;
+		const [newName] = match;
+		renameMap.set(baselineEnumName, newName);
+		const parentRemoval = parentRemovalByName.get(baselineEnumName);
+		if (parentRemoval) {
+			parentRemoval.severity = "soft-risk";
+			parentRemoval.remediation = `Enum "${baselineEnumName}" appears to have been renamed to "${newName}" — both enums have identical wire values, so on-the-wire serialization is unchanged. This is typically the emitter's dedup canonical-flip after a new same-shape enum joined the spec. Consider emitting a deprecated alias in languages that support it, or pinning the canonical via emitter config.`;
+		}
+	}
+	return renameMap;
+}
+/**
+* Cascade rename downgrades to changes whose meaning depends on a renamed
+* symbol. Walks every change and:
+*
+*   - Downgrades child removals (`Owner.field` removed where `Owner` was
+*     renamed) — the field still exists, just under a new owner fqName.
+*     Same logic for enum members under a renamed enum.
+*   - Downgrades `return_type_changed` / `field_type_changed` whose
+*     old → new pair matches a recorded rename — the type swap is the
+*     rename itself, not a meaningful signature break.
+*
+* Each cascaded change gets a remediation pointing at the parent rename
+* so the reviewer can find the explanation in the report.
+*/
+function cascadeRenameDowngrades(changes, typeRenames, enumRenames, baseline, candidate) {
+	let baselineTypeFields;
+	let candidateTypeFields;
+	const getBaselineFields = () => {
+		if (!baselineTypeFields) baselineTypeFields = collectTypeFieldSets(baseline);
+		return baselineTypeFields;
+	};
+	const getCandidateFields = () => {
+		if (!candidateTypeFields) candidateTypeFields = collectTypeFieldSets(candidate);
+		return candidateTypeFields;
+	};
+	/**
+	* Structural equivalence: candidate type's field set is a non-strict
+	* superset of baseline type's field set, AND the candidate type was
+	* newly added in this diff (not a swap to a pre-existing type, which
+	* is a real signature break the consumer chose). When `New ⊇ Old` and
+	* `New` is new, every field the consumer accessed on the old type
+	* still exists on the value they receive — so the swap is non-breaking
+	* at the value level even though the declared type changed. This is
+	* the fork-detector's positive signal, applied as a severity
+	* downgrade in addition to the existing remediation hint.
+	*/
+	const isStructurallyEquivalent = (oldT, newT) => {
+		if (!oldT || !newT || oldT === newT) return false;
+		const baselineFields = getBaselineFields();
+		const candidateFields = getCandidateFields();
+		if (baselineFields.has(newT)) return false;
+		const oldFields = baselineFields.get(oldT);
+		const newFields = candidateFields.get(newT);
+		if (!oldFields || !newFields) return false;
+		if (oldFields.size === 0) return false;
+		for (const f of oldFields) if (!newFields.has(f)) return false;
+		return true;
+	};
+	for (const change of changes) {
+		if (change.severity !== "breaking") continue;
+		if (change.category === "symbol_removed") {
+			const removed = change.old.symbol ?? "";
+			const dotIdx = removed.indexOf(".");
+			if (dotIdx <= 0) continue;
+			const ownerName = removed.slice(0, dotIdx);
+			const renamedTo = typeRenames.get(ownerName) ?? enumRenames.get(ownerName);
+			if (!renamedTo) continue;
+			change.severity = "soft-risk";
+			change.remediation = `Owned by renamed symbol "${ownerName}" (now "${renamedTo}"). The same member exists on the new symbol under "${renamedTo}.${removed.slice(dotIdx + 1)}".`;
+			continue;
+		}
+		if (change.category === "return_type_changed") {
+			const oldT = bareTypeName(change.old.returnType ?? "");
+			const newT = bareTypeName(change.new.returnType ?? "");
+			if (typeRenames.get(oldT) === newT) {
+				change.severity = "soft-risk";
+				change.remediation = `Return type swap matches recorded rename "${oldT}" → "${newT}". The underlying field set is preserved (see the rename advisory on "${oldT}").`;
+			} else if (isStructurallyEquivalent(oldT, newT)) {
+				change.severity = "soft-risk";
+				if (!change.remediation) change.remediation = `Return type swap from "${oldT}" to "${newT}" is structurally equivalent — every field on "${oldT}" still exists on "${newT}". Consumer code accessing fields on the returned value continues to work; only explicit "${oldT}" type annotations need to migrate.`;
+			}
+			continue;
+		}
+		if (change.category === "field_type_changed") {
+			const oldT = bareTypeName(change.old.type ?? "");
+			const newT = bareTypeName(change.new.type ?? "");
+			if ((typeRenames.get(oldT) ?? enumRenames.get(oldT)) === newT) {
+				change.severity = "soft-risk";
+				change.remediation = `Field type swap matches recorded rename "${oldT}" → "${newT}". On-the-wire shape is unchanged (see the rename advisory on "${oldT}").`;
+			} else if (isStructurallyEquivalent(oldT, newT)) {
+				change.severity = "soft-risk";
+				if (!change.remediation) change.remediation = `Field type swap from "${oldT}" to "${newT}" is structurally equivalent — every field on "${oldT}" still exists on "${newT}".`;
+			}
+		}
+	}
+}
+/**
+* Build a map from enum fqName → set of wire values. Used by
+* `detectEnumRenames` to find structurally-identical enums across
+* baseline and candidate. Wire values come from `enum_member.value`
+* (the JSON-level value) — not the member names, which are
+* language-specific PascalCase forms.
+*
+* Members whose `value` is undefined are skipped — they contribute no
+* identity information.
+*/
+function collectEnumValueSets(snapshot) {
+	const result = /* @__PURE__ */ new Map();
+	for (const sym of snapshot.symbols) {
+		if (sym.kind !== "enum_member") continue;
+		if (!sym.ownerFqName) continue;
+		if (sym.value === void 0) continue;
+		let set = result.get(sym.ownerFqName);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			result.set(sym.ownerFqName, set);
+		}
+		set.add(String(sym.value));
+	}
+	return result;
+}
+/** Set equality for the small string sets used by rename detection. */
+function setEquals(a, b) {
+	if (a.size !== b.size) return false;
+	for (const v of a) if (!b.has(v)) return false;
+	return true;
+}
+/**
 * Strip array/nullable suffixes so we compare bare type names. Languages
 * encode these differently (`Foo[]`, `Foo | null`, `Foo?`, `List<Foo>`,
 * `Optional[Foo]`); this is a best-effort common-case stripper, not an
@@ -994,10 +1271,13 @@ function collectTypeFieldSets(snapshot) {
 */
 function bareTypeName(t) {
 	let s = t.trim();
+	s = s.replace(/^\*/, "");
 	s = s.replace(/\s*\|\s*null$/, "").replace(/\?$/, "");
 	s = s.replace(/\[\]$/, "");
-	const generic = s.match(/^[A-Za-z_][A-Za-z0-9_.]*<\s*([A-Za-z_][A-Za-z0-9_.]*)\s*>$/);
-	if (generic) s = generic[1];
+	const angleGeneric = s.match(/^[A-Za-z_][A-Za-z0-9_.]*<\s*([A-Za-z_*][A-Za-z0-9_.*]*)\s*>$/);
+	if (angleGeneric) return bareTypeName(angleGeneric[1]);
+	const bracketGeneric = s.match(/^[A-Za-z_][A-Za-z0-9_.]*\[\s*([A-Za-z_*][A-Za-z0-9_.*]*)\s*\]$/);
+	if (bracketGeneric) return bareTypeName(bracketGeneric[1]);
 	return s;
 }
 /**
@@ -1794,4 +2074,4 @@ function patchOverlay(overlay, changes, baseline) {
 //#endregion
 export { getDefaultPolicy as A, defaultSeverityForCategory as C, isCompatibleSchemaVersion as D, COMPAT_SCHEMA_VERSION as E, validateSnapshot as O, summarizeChanges as S, apiSurfaceToSnapshot as T, nodeHints as _, registerExtractor as a, classifyAddedSymbol as b, filterSurface as c, specDerivedHttpKeys as d, specDerivedMethodPaths as f, namedTypeWordsOverlap as g, defaultIsNullableOnlyDifference as h, getExtractor as i, mergePolicy as j, ALL_LANGUAGE_IDS as k, specDerivedEnumValues as l, NAMED_TYPE_RE as m, isPatchableChange as n, diffSnapshots as o, specDerivedNames as p, patchOverlay as r, diffSurfaces as s, buildOverlayLookup as t, specDerivedFieldPaths as u, resolveHints as v, severityMeetsThreshold as w, classifySymbolChanges as x, typeExistsInSurface as y };
 
-//# sourceMappingURL=overlay-xp7F8_dW.mjs.map
+//# sourceMappingURL=overlay-Dlk7bV5R.mjs.map