@tailor-platform/sdk-codemod 0.3.0-next.2 → 0.3.0-next.4

package/dist/codemods/v2/runtime-subpath-namespace/scripts/transform.js

@@ -0,0 +1,792 @@
+import { a as importSource, c as localDeclarationNames, i as importBindings, n as collectBindingNames, o as importSpecNames, r as findImportStatements, s as isTypeOnlyImport } from "../../../ast-grep-helpers-D3FXAKNz.js";
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/runtime-subpath-namespace/scripts/transform.ts
+const MODULES_BY_SOURCE = new Map([
+	{
+		namespace: "iconv",
+		source: "@tailor-platform/sdk/runtime/iconv",
+		members: {
+			convert: "convert",
+			convertBuffer: "convertBuffer",
+			decode: "decode",
+			encode: "encode",
+			encodings: "encodings",
+			Iconv: "Iconv"
+		}
+	},
+	{
+		namespace: "secretmanager",
+		source: "@tailor-platform/sdk/runtime/secretmanager",
+		members: {
+			getSecrets: "getSecrets",
+			getSecret: "getSecret"
+		}
+	},
+	{
+		namespace: "authconnection",
+		source: "@tailor-platform/sdk/runtime/authconnection",
+		members: { getConnectionToken: "getConnectionToken" }
+	},
+	{
+		namespace: "idp",
+		source: "@tailor-platform/sdk/runtime/idp",
+		members: { Client: "Client" }
+	},
+	{
+		namespace: "workflow",
+		source: "@tailor-platform/sdk/runtime/workflow",
+		members: {
+			triggerWorkflow: "triggerWorkflow",
+			resumeWorkflow: "resumeWorkflow",
+			triggerJobFunction: "triggerJobFunction",
+			wait: "wait",
+			resolve: "resolve"
+		}
+	},
+	{
+		namespace: "context",
+		source: "@tailor-platform/sdk/runtime/context",
+		members: { getInvoker: "getInvoker" }
+	},
+	{
+		namespace: "file",
+		source: "@tailor-platform/sdk/runtime/file",
+		members: {
+			upload: "upload",
+			download: "download",
+			downloadAsBase64: "downloadAsBase64",
+			delete: "delete",
+			deleteFile: "delete",
+			getMetadata: "getMetadata",
+			downloadStream: "downloadStream",
+			uploadStream: "uploadStream"
+		}
+	},
+	{
+		namespace: "aigateway",
+		source: "@tailor-platform/sdk/runtime/aigateway",
+		members: { get: "get" }
+	}
+].map((mod) => [mod.source, mod]));
+const AGGREGATE_RUNTIME_SOURCE = "@tailor-platform/sdk/runtime";
+const JSX_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".jsx"]);
+const JS_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".js",
+	".mjs",
+	".cjs"
+]);
+function quickFilter(source) {
+	return source.includes(AGGREGATE_RUNTIME_SOURCE);
+}
+function sourceLang(filePath, source) {
+	const lower = filePath.toLowerCase();
+	const extension = lower.slice(lower.lastIndexOf("."));
+	if (JSX_FILE_EXTENSIONS.has(extension)) return Lang.Tsx;
+	if (JS_FILE_EXTENSIONS.has(extension) && /<>|<\/>|<[A-Za-z][\w.$:-]/.test(source)) return Lang.Tsx;
+	return Lang.TypeScript;
+}
+function importClause(importStmt) {
+	return importStmt.children().find((child) => child.kind() === "import_clause") ?? null;
+}
+function hasDefaultImport(importStmt) {
+	return importClause(importStmt)?.children().some((child) => child.kind() === "identifier") ?? false;
+}
+function namespaceImportName(importStmt) {
+	return importClause(importStmt)?.children().find((child) => child.kind() === "namespace_import")?.children().find((child) => child.kind() === "identifier")?.text() ?? null;
+}
+function formatImport(source, namedSpecs, typeOnly = false, attributeText = "") {
+	const importKeyword = typeOnly ? "import type" : "import";
+	const named = namedSpecs.length > 0 ? `{ ${namedSpecs.join(", ")} }` : null;
+	const attributes = attributeText === "" ? "" : ` ${attributeText}`;
+	if (named) return `${importKeyword} ${named} from "${source}"${attributes};`;
+	return "";
+}
+function importAttributeText(importStmt) {
+	return importStmt.children().find((child) => child.kind() === "import_attribute")?.text() ?? "";
+}
+function replaceImportStatement(importStmt, nextText, sourceText) {
+	if (nextText !== "") return importStmt.replace(nextText);
+	const range = importStmt.range();
+	let endPos = range.end.index;
+	if (sourceText[endPos] === "\r" && sourceText[endPos + 1] === "\n") endPos += 2;
+	else if (sourceText[endPos] === "\n") endPos += 1;
+	return {
+		startPos: range.start.index,
+		endPos,
+		insertedText: ""
+	};
+}
+function isInsideImportStatement(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "import_statement") return true;
+		current = current.parent();
+	}
+	return false;
+}
+function isInsideExportSpecifier(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "export_specifier") return true;
+		if (current.kind() === "export_statement") return false;
+		current = current.parent();
+	}
+	return false;
+}
+function isInsideTypeQuery(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "type_query") return true;
+		if (current.kind() === "statement_block" || current.kind() === "program") return false;
+		current = current.parent();
+	}
+	return false;
+}
+function isJsxTagName(node) {
+	const parentKind = node.parent()?.kind();
+	return parentKind === "jsx_opening_element" || parentKind === "jsx_self_closing_element" || parentKind === "jsx_closing_element";
+}
+function sameNode(left, right) {
+	if (!left) return false;
+	const leftRange = left.range();
+	const rightRange = right.range();
+	return leftRange.start.index === rightRange.start.index && leftRange.end.index === rightRange.end.index;
+}
+function typeParameterName(typeParameter) {
+	return typeParameter.children().find((child) => child.kind() === "type_identifier") ?? null;
+}
+function typeParametersDeclare(typeParameters, name) {
+	return typeParameters.children().some((child) => child.kind() === "type_parameter" && typeParameterName(child)?.text() === name);
+}
+function isTypeParameterScoped(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "type_parameter" && sameNode(typeParameterName(current), node)) return true;
+		const typeParameters = current.children().find((child) => child.kind() === "type_parameters");
+		if (typeParameters && typeParametersDeclare(typeParameters, node.text())) return true;
+		current = current.parent();
+	}
+	return false;
+}
+function isNestedTypeMember(node) {
+	const parent = node.parent();
+	if (parent?.kind() !== "nested_type_identifier") return false;
+	return !sameNode(parent.children().find((child) => child.kind() === "identifier" || child.kind() === "type_identifier"), node);
+}
+function localTypeScopeDeclarationNames(root) {
+	const names = /* @__PURE__ */ new Set();
+	for (const node of root.findAll({ rule: { any: [
+		{ kind: "type_parameter" },
+		{ kind: "infer_type" },
+		{ kind: "mapped_type_clause" }
+	] } })) {
+		const name = node.children().find((child) => child.kind() === "type_identifier");
+		if (name) names.add(name.text());
+	}
+	return names;
+}
+function hasExportSpecifierReference(root, names) {
+	return root.findAll({ rule: { kind: "export_specifier" } }).some((specifier) => specifier.children().some((child) => child.kind() === "identifier" && names.has(child.text())));
+}
+function hasNonTypeQueryTypeReference(root, names) {
+	return root.findAll({ rule: { kind: "type_identifier" } }).some((node) => {
+		if (!names.has(node.text())) return false;
+		if (isInsideImportStatement(node)) return false;
+		if (isInsideExportSpecifier(node)) return false;
+		if (isTypeParameterScoped(node)) return false;
+		if (isNestedTypeMember(node)) return false;
+		return !isInsideTypeQuery(node);
+	});
+}
+function hasNamespaceTypeMemberReference(root, namespaceLocal) {
+	return root.findAll({ rule: { kind: "nested_type_identifier" } }).some((node) => {
+		return node.children().find((child) => child.kind() === "identifier" || child.kind() === "type_identifier")?.text() === namespaceLocal;
+	});
+}
+function findExportStatements(root) {
+	return root.findAll({ rule: { kind: "export_statement" } }).filter((stmt) => stmt.parent()?.kind() === "program").toSorted((a, b) => a.range().start.index - b.range().start.index);
+}
+function aggregateFileImportLocals(imports) {
+	const locals = /* @__PURE__ */ new Set();
+	for (const importStmt of imports) {
+		if (importSource(importStmt) !== AGGREGATE_RUNTIME_SOURCE) continue;
+		for (const binding of importBindings(importStmt)) if (!binding.typeOnly && binding.importedName === "file") locals.add(binding.localName);
+	}
+	return locals;
+}
+function isValueBindingLeafKind(kind) {
+	return kind === "identifier" || kind === "shorthand_property_identifier_pattern";
+}
+function isValueBindingPatternKind(kind) {
+	return isValueBindingLeafKind(kind) || kind === "object_pattern" || kind === "array_pattern" || kind === "rest_pattern";
+}
+function collectValueBindingNames(node, names, result) {
+	if (isValueBindingLeafKind(node.kind())) {
+		if (names.has(node.text())) result.add(node.text());
+		return;
+	}
+	for (const child of node.children()) {
+		if (child.kind() === "property_identifier") continue;
+		if (child.kind() === "=") break;
+		collectValueBindingNames(child, names, result);
+	}
+}
+function valueBindingNames(node, names) {
+	const result = /* @__PURE__ */ new Set();
+	collectValueBindingNames(node, names, result);
+	return result;
+}
+function directValueBindingNames(node, names) {
+	const result = /* @__PURE__ */ new Set();
+	for (const child of node.children()) {
+		if (child.kind() === "=") break;
+		if (isValueBindingPatternKind(child.kind())) collectValueBindingNames(child, names, result);
+	}
+	return result;
+}
+function firstDeclaratorChild(node) {
+	return node.children().find((child) => child.kind() !== "=") ?? null;
+}
+function addShadowedRange(ranges, name, scope) {
+	const range = scope.range();
+	const existing = ranges.get(name) ?? [];
+	existing.push({
+		start: range.start.index,
+		end: range.end.index
+	});
+	ranges.set(name, existing);
+}
+function nearestValueScope(node) {
+	let current = node.parent();
+	while (current) {
+		const kind = current.kind();
+		if (kind === "statement_block" || kind === "program" || kind === "switch_body" || kind === "for_statement" || kind === "for_in_statement") return current;
+		current = current.parent();
+	}
+	return node;
+}
+function functionValueScope(node) {
+	let current = node.parent();
+	while (current) {
+		const kind = current.kind();
+		if (kind === "function_declaration" || kind === "function_expression" || kind === "arrow_function" || kind === "method_definition" || kind === "program") return current;
+		current = current.parent();
+	}
+	return node;
+}
+function variableValueScope(node) {
+	const declaration = node.parent();
+	return /^var\b/.test(declaration?.text().trimStart() ?? "") ? functionValueScope(node) : nearestValueScope(node);
+}
+function parameterValueScope(node) {
+	let current = node.parent();
+	while (current) {
+		const kind = current.kind();
+		if (kind === "formal_parameters") {
+			current = current.parent();
+			continue;
+		}
+		if (kind === "function_declaration" || kind === "function_expression" || kind === "arrow_function" || kind === "method_definition") return current;
+		break;
+	}
+	return nearestValueScope(node);
+}
+function buildShadowedRanges(root, names) {
+	const ranges = /* @__PURE__ */ new Map();
+	for (const decl of root.findAll({ rule: { kind: "variable_declarator" } })) {
+		if (isInsideImportStatement(decl)) continue;
+		const binding = firstDeclaratorChild(decl);
+		if (!binding) continue;
+		for (const name of valueBindingNames(binding, names)) addShadowedRange(ranges, name, variableValueScope(decl));
+	}
+	for (const decl of root.findAll({ rule: { any: [
+		{ kind: "function_declaration" },
+		{ kind: "class_declaration" },
+		{ kind: "enum_declaration" }
+	] } })) {
+		const name = decl.children().find((child) => child.kind() === "identifier" && names.has(child.text()));
+		if (name) addShadowedRange(ranges, name.text(), nearestValueScope(decl));
+	}
+	for (const expression of root.findAll({ rule: { any: [{ kind: "function_expression" }, { kind: "class" }] } })) {
+		const name = expression.children().find((child) => (child.kind() === "identifier" || child.kind() === "type_identifier") && names.has(child.text()));
+		if (name) addShadowedRange(ranges, name.text(), expression);
+	}
+	for (const param of root.findAll({ rule: { any: [{ kind: "required_parameter" }, { kind: "optional_parameter" }] } })) for (const name of directValueBindingNames(param, names)) addShadowedRange(ranges, name, parameterValueScope(param));
+	for (const arrow of root.findAll({ rule: { kind: "arrow_function" } })) {
+		const children = arrow.children();
+		const arrowIndex = children.findIndex((child) => child.kind() === "=>");
+		if (arrowIndex === -1) continue;
+		for (const child of children.slice(0, arrowIndex)) {
+			if (child.kind() === "=") break;
+			if (!isValueBindingPatternKind(child.kind())) continue;
+			for (const name of valueBindingNames(child, names)) addShadowedRange(ranges, name, arrow);
+		}
+	}
+	for (const catchClause of root.findAll({ rule: { kind: "catch_clause" } })) for (const name of directValueBindingNames(catchClause, names)) addShadowedRange(ranges, name, catchClause);
+	for (const loop of root.findAll({ rule: { kind: "for_in_statement" } })) {
+		const children = loop.children();
+		const keywordIndex = children.findIndex((child) => child.kind() === "in" || child.kind() === "of");
+		if (keywordIndex === -1) continue;
+		for (const child of children.slice(0, keywordIndex)) for (const name of valueBindingNames(child, names)) addShadowedRange(ranges, name, loop);
+	}
+	return ranges;
+}
+function isShadowed(node, ranges) {
+	const candidates = ranges.get(node.text());
+	if (!candidates) return false;
+	const position = node.range().start.index;
+	return candidates.some((range) => position >= range.start && position < range.end);
+}
+function isAggregateFileReceiver(node, fileLocals, shadowedRanges) {
+	return node?.kind() === "identifier" && fileLocals.has(node.text()) && !isShadowed(node, shadowedRanges);
+}
+function aggregateFileDeleteAccesses(root, imports) {
+	const fileLocals = aggregateFileImportLocals(imports);
+	if (fileLocals.size === 0) return [];
+	const shadowedRanges = buildShadowedRanges(root, fileLocals);
+	const accesses = [];
+	for (const member of root.findAll({ rule: { kind: "member_expression" } })) {
+		const receiver = member.field("object");
+		const property = member.children().find((child) => child.kind() === "property_identifier");
+		if (isAggregateFileReceiver(receiver, fileLocals, shadowedRanges) && property?.text() === "deleteFile") accesses.push({
+			node: member,
+			property,
+			computed: false
+		});
+	}
+	for (const subscript of root.findAll({ rule: { kind: "subscript_expression" } })) {
+		const receiver = subscript.field("object");
+		const property = subscript.field("index");
+		if (isAggregateFileReceiver(receiver, fileLocals, shadowedRanges) && property?.kind() === "string" && property.text().slice(1, -1) === "deleteFile") accesses.push({
+			node: subscript,
+			property,
+			computed: true
+		});
+	}
+	return accesses;
+}
+function aggregateFileDeleteEdits(root, imports) {
+	return aggregateFileDeleteAccesses(root, imports).map(({ property, computed }) => {
+		if (!computed) return property.replace("delete");
+		const quote = property.text()[0] ?? "\"";
+		return property.replace(`${quote}delete${quote}`);
+	});
+}
+function declaratorSides(node) {
+	const children = node.children();
+	const equalsIndex = children.findIndex((child) => child.kind() === "=");
+	if (equalsIndex === -1) return null;
+	const binding = children.slice(0, equalsIndex).find((child) => child.kind() !== "comment");
+	const value = children.slice(equalsIndex + 1).find((child) => child.kind() !== "comment");
+	return binding && value ? {
+		binding,
+		value
+	} : null;
+}
+function aggregateFileDeleteDestructures(root, imports) {
+	const fileLocals = aggregateFileImportLocals(imports);
+	if (fileLocals.size === 0) return [];
+	const shadowedRanges = buildShadowedRanges(root, fileLocals);
+	return root.findAll({ rule: { kind: "variable_declarator" } }).filter((declarator) => {
+		const sides = declaratorSides(declarator);
+		if (!sides || sides.binding.kind() !== "object_pattern" || !isAggregateFileReceiver(sides.value, fileLocals, shadowedRanges)) return false;
+		return sides.binding.findAll({ rule: { any: [{ kind: "property_identifier" }, { kind: "shorthand_property_identifier_pattern" }] } }).some((property) => property.text() === "deleteFile");
+	});
+}
+function aggregateFileDeleteFindingNodes(root, imports) {
+	return [...aggregateFileDeleteAccesses(root, imports).map((access) => access.node), ...aggregateFileDeleteDestructures(root, imports)];
+}
+function usedNames(root, imports, removedNames) {
+	const names = localDeclarationNames(root);
+	for (const importStmt of imports) for (const binding of importBindings(importStmt)) if (!removedNames.has(binding.localName)) names.add(binding.localName);
+	return names;
+}
+function uniqueNamespaceLocal(mod, root, imports, removedNames) {
+	const names = usedNames(root, imports, removedNames);
+	if (!names.has(mod.namespace)) return mod.namespace;
+	const base = `${mod.namespace}Runtime`;
+	if (!names.has(base)) return base;
+	for (let i = 2;; i++) {
+		const candidate = `${base}${i}`;
+		if (!names.has(candidate)) return candidate;
+	}
+}
+function selfNamespaceSpec(mod, localName) {
+	return localName === mod.namespace ? mod.namespace : `${mod.namespace} as ${localName}`;
+}
+function typeOnlySelfNamespaceSpec(mod, localName) {
+	return `type ${selfNamespaceSpec(mod, localName)}`;
+}
+function existingSelfNamespaceImport(importStmt, mod, statementTypeOnly) {
+	for (const spec of importStmt.findAll({ rule: { kind: "import_specifier" } })) {
+		const names = importSpecNames(spec);
+		if (!names || names.importedName !== mod.namespace) continue;
+		return {
+			localName: names.localName,
+			typeOnly: statementTypeOnly || names.typeOnly
+		};
+	}
+	return null;
+}
+function flatImportsFor(importStmt, mod) {
+	const statementTypeOnly = isTypeOnlyImport(importStmt);
+	const flatImports = [];
+	for (const spec of importStmt.findAll({ rule: { kind: "import_specifier" } })) {
+		const names = importSpecNames(spec);
+		if (!names) continue;
+		const memberName = mod.members[names.importedName];
+		if (!memberName) continue;
+		flatImports.push({
+			localName: names.localName,
+			memberName,
+			typeOnly: statementTypeOnly || names.typeOnly
+		});
+	}
+	return flatImports;
+}
+function plannedValueNamespaceLocal(importStmt, mod, root, imports) {
+	const source = importSource(importStmt);
+	if (!source) return null;
+	for (const candidate of imports) {
+		if (sameNode(candidate, importStmt)) continue;
+		if (importSource(candidate) !== source || isTypeOnlyImport(candidate)) continue;
+		const namespaceName = namespaceImportName(candidate);
+		if (namespaceName) return namespaceName;
+		const existingSelf = existingSelfNamespaceImport(candidate, mod, false);
+		if (existingSelf && !existingSelf.typeOnly) return existingSelf.localName;
+		const valueFlatImports = flatImportsFor(candidate, mod).filter((binding) => !binding.typeOnly);
+		if (valueFlatImports.length === 0) continue;
+		const removedNames = new Set(valueFlatImports.map((binding) => binding.localName));
+		const declaredNames = /* @__PURE__ */ new Set([...localDeclarationNames(root), ...localTypeScopeDeclarationNames(root)]);
+		if (valueFlatImports.some((binding) => declaredNames.has(binding.localName))) continue;
+		if (hasExportSpecifierReference(root, removedNames)) continue;
+		return uniqueNamespaceLocal(mod, root, imports, removedNames);
+	}
+	return null;
+}
+function buildImportReplacement(importStmt, mod, root, imports, sourceText, emittedNamespaceSpecifiers) {
+	const source = importSource(importStmt);
+	if (!source) return null;
+	const statementTypeOnly = isTypeOnlyImport(importStmt);
+	const attributes = importAttributeText(importStmt);
+	const namespaceName = namespaceImportName(importStmt);
+	if (namespaceName) {
+		if (hasNamespaceTypeMemberReference(root, namespaceName)) return null;
+		return {
+			edit: importStmt.replace(formatImport(source, [selfNamespaceSpec(mod, namespaceName)], statementTypeOnly, attributes)),
+			flatImports: [],
+			namespaceLocal: namespaceName
+		};
+	}
+	if (hasDefaultImport(importStmt)) return null;
+	const existingSelf = existingSelfNamespaceImport(importStmt, mod, statementTypeOnly);
+	const flatImports = [];
+	const keptSpecs = [];
+	for (const spec of importStmt.findAll({ rule: { kind: "import_specifier" } })) {
+		const names = importSpecNames(spec);
+		if (!names) continue;
+		const memberName = mod.members[names.importedName];
+		if (memberName) {
+			flatImports.push({
+				localName: names.localName,
+				memberName,
+				typeOnly: statementTypeOnly || names.typeOnly
+			});
+			continue;
+		}
+		keptSpecs.push(spec.text());
+	}
+	if (flatImports.length === 0) return null;
+	const removedNames = new Set(flatImports.map((binding) => binding.localName));
+	const declaredNames = /* @__PURE__ */ new Set([...localDeclarationNames(root), ...localTypeScopeDeclarationNames(root)]);
+	if (flatImports.some((binding) => declaredNames.has(binding.localName))) return null;
+	if (hasExportSpecifierReference(root, removedNames)) return null;
+	if (hasNonTypeQueryTypeReference(root, removedNames)) return null;
+	const flatImportsAreTypeOnly = flatImports.every((binding) => binding.typeOnly);
+	const canUseExistingSelf = existingSelf != null && (!existingSelf.typeOnly || flatImportsAreTypeOnly);
+	const plannedValueLocal = flatImportsAreTypeOnly ? plannedValueNamespaceLocal(importStmt, mod, root, imports) : null;
+	const namespaceLocal = plannedValueLocal ?? (canUseExistingSelf ? existingSelf.localName : uniqueNamespaceLocal(mod, root, imports, removedNames));
+	const namespaceSpecifierKey = [
+		source,
+		namespaceLocal,
+		flatImportsAreTypeOnly ? "type" : "value"
+	].join("\0");
+	const namespaceAlreadyEmitted = emittedNamespaceSpecifiers.has(namespaceSpecifierKey);
+	const needsNamespaceSpecifier = plannedValueLocal == null && !canUseExistingSelf && !namespaceAlreadyEmitted;
+	if (needsNamespaceSpecifier) emittedNamespaceSpecifiers.add(namespaceSpecifierKey);
+	const namespaceSpecifier = flatImportsAreTypeOnly && !statementTypeOnly ? typeOnlySelfNamespaceSpec(mod, namespaceLocal) : selfNamespaceSpec(mod, namespaceLocal);
+	return {
+		edit: replaceImportStatement(importStmt, formatImport(source, needsNamespaceSpecifier ? [namespaceSpecifier, ...keptSpecs] : keptSpecs, statementTypeOnly, attributes), sourceText),
+		flatImports,
+		namespaceLocal
+	};
+}
+function referenceEdits(root, replacements) {
+	const byLocalName = /* @__PURE__ */ new Map();
+	for (const replacement of replacements) for (const binding of replacement.flatImports) byLocalName.set(binding.localName, {
+		namespaceLocal: replacement.namespaceLocal,
+		memberName: binding.memberName,
+		typeOnly: binding.typeOnly
+	});
+	const edits = [];
+	const replacementFor = (name) => {
+		const binding = byLocalName.get(name);
+		return binding ? `${binding.namespaceLocal}.${binding.memberName}` : null;
+	};
+	for (const node of root.findAll({ rule: { kind: "identifier" } })) {
+		if (isInsideImportStatement(node)) continue;
+		if (isInsideExportSpecifier(node)) continue;
+		if (isJsxTagName(node)) continue;
+		if (byLocalName.get(node.text())?.typeOnly && !isInsideTypeQuery(node)) continue;
+		const replacement = replacementFor(node.text());
+		if (!replacement) continue;
+		edits.push(node.replace(replacement));
+	}
+	for (const node of root.findAll({ rule: { kind: "type_identifier" } })) {
+		if (isInsideImportStatement(node)) continue;
+		if (isInsideExportSpecifier(node)) continue;
+		if (!isInsideTypeQuery(node)) continue;
+		if (isTypeParameterScoped(node)) continue;
+		if (isNestedTypeMember(node)) continue;
+		const replacement = replacementFor(node.text());
+		if (!replacement) continue;
+		edits.push(node.replace(replacement));
+	}
+	for (const node of root.findAll({ rule: { kind: "shorthand_property_identifier" } })) {
+		if (byLocalName.get(node.text())?.typeOnly) continue;
+		const replacement = replacementFor(node.text());
+		if (!replacement) continue;
+		edits.push(node.replace(`${node.text()}: ${replacement}`));
+	}
+	return edits;
+}
+/**
+* Rewrite v1 runtime subpath imports to the v2 namespace object exports.
+* @param source - File contents
+* @param filePath - Absolute path to the file
+* @returns Transformed source or null when nothing matched.
+*/
+function transform(source, filePath) {
+	if (!quickFilter(source)) return null;
+	const root = parse(sourceLang(filePath, source), source).root();
+	const imports = findImportStatements(root);
+	const replacements = [];
+	const emittedNamespaceSpecifiers = /* @__PURE__ */ new Set();
+	for (const importStmt of imports) {
+		const sourceName = importSource(importStmt);
+		if (!sourceName) continue;
+		const mod = MODULES_BY_SOURCE.get(sourceName);
+		if (!mod) continue;
+		const replacement = buildImportReplacement(importStmt, mod, root, imports, source, emittedNamespaceSpecifiers);
+		if (replacement) replacements.push(replacement);
+	}
+	const aggregateEdits = aggregateFileDeleteEdits(root, imports);
+	if (replacements.length === 0 && aggregateEdits.length === 0) return null;
+	const edits = [
+		...replacements.map((replacement) => replacement.edit),
+		...referenceEdits(root, replacements),
+		...aggregateEdits
+	];
+	const result = root.commitEdits(edits);
+	return result === source ? null : result;
+}
+function hasRemovedFlatSpecifier(node, mod) {
+	return node.findAll({ rule: { any: [{ kind: "import_specifier" }, { kind: "export_specifier" }] } }).some((spec) => {
+		const names = importSpecNames(spec);
+		return names != null && mod.members[names.importedName] != null;
+	});
+}
+function isExportStar(node) {
+	if (node.children().some((child) => child.kind() === "*")) return true;
+	return node.children().find((child) => child.kind() === "namespace_export")?.children().some((child) => child.kind() === "*") ?? false;
+}
+function literalModuleSource(node) {
+	if (node.kind() === "string") return importSource(node);
+	if (node.kind() !== "template_string") return null;
+	if (node.children().some((child) => child.kind() === "template_substitution")) return null;
+	const text = node.text();
+	return text.startsWith("`") && text.endsWith("`") ? text.slice(1, -1) : null;
+}
+function isSourceScopeNode(node) {
+	const kind = node.kind();
+	return kind === "program" || kind === "statement_block" || kind === "function_declaration" || kind === "arrow_function" || kind === "method_definition";
+}
+function nearestSourceScope(node) {
+	let current = node.parent();
+	while (current) {
+		if (isSourceScopeNode(current)) return current;
+		current = current.parent();
+	}
+	return null;
+}
+function sameRange(left, right) {
+	if (!left) return false;
+	const leftRange = left.range();
+	const rightRange = right.range();
+	return leftRange.start.index === rightRange.start.index && leftRange.end.index === rightRange.end.index;
+}
+function isConstVariableDeclarator(node) {
+	return node.parent()?.children().some((child) => child.kind() === "const") ?? false;
+}
+function sourceConstInitializerContent(node) {
+	const directValue = literalModuleSource(node);
+	if (directValue != null) return directValue;
+	if (node.kind() !== "as_expression" && node.kind() !== "satisfies_expression" && node.kind() !== "parenthesized_expression") return null;
+	for (const child of node.children()) {
+		const childValue = sourceConstInitializerContent(child);
+		if (childValue != null) return childValue;
+	}
+	return null;
+}
+function sourceConstVariableDeclaratorContent(node, name) {
+	if (!isConstVariableDeclarator(node)) return null;
+	const names = /* @__PURE__ */ new Set();
+	collectBindingNames(node, names);
+	if (!names.has(name)) return null;
+	const initializer = node.children().findLast((child) => sourceConstInitializerContent(child) != null);
+	return initializer == null ? null : sourceConstInitializerContent(initializer);
+}
+function bindingNames(node) {
+	const names = /* @__PURE__ */ new Set();
+	collectBindingNames(node, names);
+	return names;
+}
+function sourceStringVariableInScope(scope, name, before) {
+	const bindings = scope.findAll({ rule: { any: [
+		{ kind: "variable_declarator" },
+		{ kind: "required_parameter" },
+		{ kind: "optional_parameter" },
+		{ kind: "catch_clause" }
+	] } }).filter((node) => node.range().start.index < before && sameRange(nearestSourceScope(node), scope)).toSorted((a, b) => b.range().start.index - a.range().start.index);
+	for (const binding of bindings) {
+		if (!bindingNames(binding).has(name)) continue;
+		return binding.kind() === "variable_declarator" ? sourceConstVariableDeclaratorContent(binding, name) : null;
+	}
+}
+function sourceScopedStringVariableContent(identifier) {
+	const name = identifier.text();
+	const before = identifier.range().start.index;
+	let current = identifier.parent();
+	while (current) {
+		if (isSourceScopeNode(current)) {
+			const value = sourceStringVariableInScope(current, name, before);
+			if (value !== void 0) return value;
+		}
+		current = current.parent();
+	}
+	return null;
+}
+function isDynamicImportCall(node) {
+	return node.kind() === "call_expression" && node.children().some((child) => child.kind() === "import");
+}
+function isRequireCall(node) {
+	return node.kind() === "call_expression" && node.children().some((child) => child.kind() === "identifier" && child.text() === "require");
+}
+function isArgumentSyntaxNode(node) {
+	const kind = node.kind();
+	return kind === "(" || kind === ")" || kind === "," || kind === "comment";
+}
+function firstCallArgument(callExpression) {
+	return callExpression.children().find((child) => child.kind() === "arguments")?.children().find((child) => !isArgumentSyntaxNode(child)) ?? null;
+}
+function moduleCallSourceName(callExpression) {
+	const sourceArg = firstCallArgument(callExpression);
+	if (!sourceArg) return null;
+	const sourceName = literalModuleSource(sourceArg);
+	if (sourceName != null) return sourceName;
+	return sourceArg.kind() === "identifier" ? sourceScopedStringVariableContent(sourceArg) : null;
+}
+function dynamicImportSourceName(callExpression) {
+	return moduleCallSourceName(callExpression);
+}
+function dynamicImportExcerptNode(callExpression) {
+	let current = callExpression;
+	while (current.parent()) {
+		const parent = current.parent();
+		if (!parent) break;
+		if (parent.kind() !== "await_expression" && parent.kind() !== "parenthesized_expression" && parent.kind() !== "member_expression") break;
+		current = parent;
+	}
+	return current;
+}
+function dynamicRuntimeImportFindings(root, relativePath) {
+	const findings = [];
+	for (const callExpression of root.findAll({ rule: { kind: "call_expression" } })) {
+		if (!isDynamicImportCall(callExpression)) continue;
+		const sourceName = dynamicImportSourceName(callExpression);
+		if (!sourceName || !MODULES_BY_SOURCE.has(sourceName)) continue;
+		const excerptNode = dynamicImportExcerptNode(callExpression);
+		findings.push({
+			file: relativePath,
+			line: excerptNode.range().start.line + 1,
+			message: "Dynamic runtime subpath import may still access a removed flat value export.",
+			excerpt: excerptNode.text().trim()
+		});
+	}
+	return findings;
+}
+function runtimeRequireFindings(root, relativePath) {
+	const findings = [];
+	for (const callExpression of root.findAll({ rule: { kind: "call_expression" } })) {
+		if (isInsideImportStatement(callExpression)) continue;
+		if (!isRequireCall(callExpression)) continue;
+		const sourceName = moduleCallSourceName(callExpression);
+		if (!sourceName || !MODULES_BY_SOURCE.has(sourceName)) continue;
+		findings.push({
+			file: relativePath,
+			line: callExpression.range().start.line + 1,
+			message: "CommonJS runtime subpath require may still access a removed flat value export.",
+			excerpt: callExpression.text().trim()
+		});
+	}
+	return findings;
+}
+function isImportRequireStatement(importStmt) {
+	return importStmt.children().some((child) => child.kind() === "import_require_clause");
+}
+function reviewFindings(source, filePath, relativePath) {
+	if (!quickFilter(source)) return [];
+	const root = parse(sourceLang(filePath, source), source).root();
+	const imports = findImportStatements(root);
+	const findings = [];
+	findings.push(...dynamicRuntimeImportFindings(root, relativePath));
+	findings.push(...runtimeRequireFindings(root, relativePath));
+	for (const access of aggregateFileDeleteFindingNodes(root, imports)) findings.push({
+		file: relativePath,
+		line: access.range().start.line + 1,
+		message: "Aggregate runtime file namespace still uses the removed deleteFile alias.",
+		excerpt: access.text().trim()
+	});
+	for (const importStmt of imports) {
+		const sourceName = importSource(importStmt);
+		if (!sourceName) continue;
+		const mod = MODULES_BY_SOURCE.get(sourceName);
+		if (!mod) continue;
+		const hasImportRequire = isImportRequireStatement(importStmt);
+		const hasRemovedDefaultImport = hasDefaultImport(importStmt);
+		const hasNamespaceImport = namespaceImportName(importStmt) != null;
+		const hasRemovedFlatImport = hasRemovedFlatSpecifier(importStmt, mod);
+		if (!hasImportRequire && !hasRemovedDefaultImport && !hasNamespaceImport && !hasRemovedFlatImport) continue;
+		findings.push({
+			file: relativePath,
+			line: importStmt.range().start.line + 1,
+			message: hasImportRequire ? "TypeScript runtime subpath import-equals may still access a removed flat value export." : "Runtime subpath import still uses a removed default, namespace-star, or flat value import.",
+			excerpt: importStmt.text().trim()
+		});
+	}
+	for (const exportStmt of findExportStatements(root)) {
+		const sourceName = importSource(exportStmt);
+		if (!sourceName) continue;
+		const mod = MODULES_BY_SOURCE.get(sourceName);
+		if (!mod || !hasRemovedFlatSpecifier(exportStmt, mod) && !isExportStar(exportStmt)) continue;
+		findings.push({
+			file: relativePath,
+			line: exportStmt.range().start.line + 1,
+			message: "Runtime subpath re-export still uses a removed flat value export.",
+			excerpt: exportStmt.text().trim()
+		});
+	}
+	return findings;
+}
+//#endregion
+export { transform as default, reviewFindings };