@workos/oagen 0.14.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-DGcHh1KN.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;;;iBE4bgB,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-DGcHh1KN.mjs → overlay-Dlk7bV5R.mjs}

@@ -913,7 +913,10 @@ function diffSnapshots(baseline, candidate, policy) {
 		changes.push(classifyAddedSymbol(candSym));
 	}
 	detectForkedSchemas(changes, baseline, candidate);
-	cascadeRenameDowngrades(changes, detectTypeRenames(changes, baseline, candidate), detectEnumRenames(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)
@@ -1023,27 +1026,86 @@ function detectTypeRenames(changes, baseline, candidate) {
 	const candidateTypeFields = collectTypeFieldSets(candidate);
 	const baselineTypeNames = new Set(baselineTypeFields.keys());
 	const candidateTypesSorted = [...candidateTypeFields.entries()].sort((a, b) => a[0].localeCompare(b[0]));
-	for (const change of changes) {
-		if (change.category !== "symbol_removed") continue;
-		if (change.severity !== "breaking") continue;
-		const removedName = bareTypeName(change.old.symbol ?? "");
-		if (!removedName) continue;
-		const removedFields = baselineTypeFields.get(removedName);
-		if (!removedFields || removedFields.size === 0) continue;
+	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 removedFields) if (!candFields.has(f)) return false;
+			for (const f of baselineFields) if (!candFields.has(f)) return false;
 			return true;
 		});
 		if (!match) continue;
 		const [newName] = match;
-		renameMap.set(removedName, newName);
-		change.severity = "soft-risk";
-		change.remediation = `Type "${removedName}" 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 "${removedName}" type annotations need to migrate. Consider emitting a deprecated alias \`type ${removedName} = ${newName}\` in languages that support it.`;
+		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.
 *
@@ -1066,24 +1128,21 @@ function detectEnumRenames(changes, baseline, candidate) {
 	const candidateEnumValues = collectEnumValueSets(candidate);
 	const baselineEnumNames = new Set(baselineEnumValues.keys());
 	const candidateEnumsSorted = [...candidateEnumValues.entries()].sort((a, b) => a[0].localeCompare(b[0]));
-	for (const change of changes) {
-		if (change.category !== "symbol_removed") continue;
-		if (change.severity !== "breaking") continue;
-		const removedName = bareTypeName(change.old.symbol ?? "");
-		if (!removedName) continue;
-		const removedValues = baselineEnumValues.get(removedName);
-		if (!removedValues || removedValues.size === 0) continue;
-		const match = candidateEnumsSorted.find(([candName, candValues]) => {
-			if (baselineEnumNames.has(candName)) return false;
-			if (candValues.size !== removedValues.size) return false;
-			for (const v of removedValues) if (!candValues.has(v)) return false;
-			return true;
-		});
+	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(removedName, newName);
-		change.severity = "soft-risk";
-		change.remediation = `Enum "${removedName}" 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.`;
+		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;
 }
@@ -1101,8 +1160,40 @@ function detectEnumRenames(changes, baseline, candidate) {
 * 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) {
-	if (typeRenames.size === 0 && enumRenames.size === 0) return;
+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") {
@@ -1122,6 +1213,9 @@ function cascadeRenameDowngrades(changes, typeRenames, enumRenames) {
 			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;
 		}
@@ -1131,6 +1225,9 @@ function cascadeRenameDowngrades(changes, typeRenames, enumRenames) {
 			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}".`;
 			}
 		}
 	}
@@ -1160,6 +1257,12 @@ function collectEnumValueSets(snapshot) {
 	}
 	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>`,
@@ -1168,10 +1271,13 @@ function collectEnumValueSets(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;
 }
 /**
@@ -1968,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-DGcHh1KN.mjs.map
+//# sourceMappingURL=overlay-Dlk7bV5R.mjs.map