@tailor-platform/sdk-codemod 0.3.0-next.1 → 0.3.0-next.3

package/dist/codemods/v2/auth-connection-token-helper/scripts/transform.js

@@ -0,0 +1,243 @@
+import { a as importSpecNames, i as importSource, n as findImportStatements, o as isTypeOnlyImport, r as importBindings, s as localDeclarationNames, t as buildAddNamedImportEdit } from "../../../ast-grep-helpers-Bfn39biW.js";
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/auth-connection-token-helper/scripts/transform.ts
+const RUNTIME_MODULE = "@tailor-platform/sdk/runtime";
+const AUTHCONNECTION = "authconnection";
+const GET_CONNECTION_TOKEN = "getConnectionToken";
+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(GET_CONNECTION_TOKEN);
+}
+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 parseRoot(source, filePath) {
+	if (!quickFilter(source)) return null;
+	try {
+		return parse(sourceLang(filePath, source), source).root();
+	} catch {
+		return null;
+	}
+}
+function isTailorConfigSource(source) {
+	return /(^|\/)tailor\.config(?:\.(?:ts|tsx|js|jsx|mts|cts|mjs|cjs))?$/.test(source);
+}
+function findAuthImports(imports) {
+	const authImports = [];
+	for (const importStmt of imports) {
+		const source = importSource(importStmt);
+		if (!source || !isTailorConfigSource(source) || isTypeOnlyImport(importStmt)) continue;
+		for (const spec of importStmt.findAll({ rule: { kind: "import_specifier" } })) {
+			const names = importSpecNames(spec);
+			if (names?.importedName !== "auth" || names.typeOnly) continue;
+			authImports.push({
+				importStmt,
+				localName: names.localName,
+				spec
+			});
+		}
+	}
+	return authImports;
+}
+function runtimeAuthconnectionReference(imports) {
+	for (const importStmt of imports) {
+		if (importSource(importStmt) !== RUNTIME_MODULE || isTypeOnlyImport(importStmt)) continue;
+		for (const binding of importBindings(importStmt)) if (binding.importedName === AUTHCONNECTION && !binding.typeOnly) return binding.localName;
+		const local = (importStmt.children().find((child) => child.kind() === "import_clause")?.children().find((child) => child.kind() === "namespace_import"))?.children().find((child) => child.kind() === "identifier");
+		if (local) return `${local.text()}.${AUTHCONNECTION}`;
+	}
+	return null;
+}
+function hasRuntimeImportCollision(root, imports) {
+	if (localDeclarationNames(root).has(AUTHCONNECTION)) return true;
+	return imports.some((importStmt) => importSource(importStmt) !== RUNTIME_MODULE && importBindings(importStmt).some((binding) => binding.localName === AUTHCONNECTION && !binding.typeOnly));
+}
+function hasAuthLocalCollision(root, authLocalNames) {
+	const localNames = localDeclarationNames(root);
+	return Array.from(authLocalNames).some((name) => localNames.has(name));
+}
+function findDirectAuthCalls(root, authLocalNames) {
+	const calls = [];
+	for (const call of root.findAll({ rule: { kind: "call_expression" } })) {
+		const callee = call.field("function");
+		if (callee?.kind() !== "member_expression") continue;
+		const object = callee.field("object");
+		const property = callee.field("property");
+		if (object?.kind() !== "identifier" || property?.text() !== GET_CONNECTION_TOKEN || !authLocalNames.has(object.text())) continue;
+		const range = object.range();
+		calls.push({
+			objectNode: object,
+			localName: object.text(),
+			range: [range.start.index, range.end.index]
+		});
+	}
+	return calls;
+}
+function isInsideImportStatement(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "import_statement") return true;
+		current = current.parent();
+	}
+	return false;
+}
+function isInsideScheduledRange(node, ranges) {
+	const start = node.range().start.index;
+	return ranges.some(([rangeStart, rangeEnd]) => start >= rangeStart && start < rangeEnd);
+}
+function countRemainingRefs(root, localName, scheduledRanges) {
+	return root.findAll({ rule: { any: [{ kind: "identifier" }, { kind: "shorthand_property_identifier" }] } }).filter((node) => node.text() === localName).filter((node) => !isInsideImportStatement(node) && !isInsideScheduledRange(node, scheduledRanges)).length;
+}
+function importInsertionIndex(root, imports, source) {
+	const lastImport = imports.at(-1);
+	if (lastImport) return lastImport.range().end.index;
+	if (source.startsWith("#!")) {
+		const newlineIndex = source.indexOf("\n");
+		return newlineIndex === -1 ? source.length : newlineIndex + 1;
+	}
+	return root.children().find((child) => child.kind() !== "comment")?.range().start.index ?? 0;
+}
+function buildAddRuntimeImportEdit(root, source, imports) {
+	return buildAddNamedImportEdit({
+		importName: AUTHCONNECTION,
+		imports,
+		insertionIndex: importInsertionIndex,
+		moduleName: RUNTIME_MODULE,
+		root,
+		source
+	});
+}
+function lineStartIndex(source, index) {
+	let pos = index;
+	while (pos > 0 && source[pos - 1] !== "\n" && source[pos - 1] !== "\r") pos--;
+	return pos;
+}
+function consumeLineBreak(source, index) {
+	if (source[index] === "\r") return source[index + 1] === "\n" ? index + 2 : index + 1;
+	if (source[index] === "\n") return index + 1;
+	return index;
+}
+function isHorizontalWhitespace(source, start, end) {
+	for (let index = start; index < end; index++) if (source[index] !== " " && source[index] !== "	") return false;
+	return true;
+}
+function buildImportRemovalEdit(source, binding) {
+	if (binding.importStmt.findAll({ rule: { kind: "import_specifier" } }).length === 1) {
+		const range = binding.importStmt.range();
+		let end = range.end.index;
+		if (source[end] === "\n") end++;
+		return {
+			startPos: range.start.index,
+			endPos: end,
+			insertedText: ""
+		};
+	}
+	const range = binding.spec.range();
+	let start = range.start.index;
+	let end = range.end.index;
+	const specEnd = end;
+	while (end < source.length && /[ \t]/.test(source[end])) end++;
+	if (source[end] === ",") {
+		end++;
+		while (end < source.length && /[ \t]/.test(source[end])) end++;
+		const nextLine = consumeLineBreak(source, end);
+		const lineStart = lineStartIndex(source, start);
+		if (nextLine !== end && isHorizontalWhitespace(source, lineStart, start)) return {
+			startPos: lineStart,
+			endPos: nextLine,
+			insertedText: ""
+		};
+		return {
+			startPos: start,
+			endPos: end,
+			insertedText: ""
+		};
+	}
+	const nextLine = consumeLineBreak(source, end);
+	const lineStart = lineStartIndex(source, start);
+	if (nextLine !== end && isHorizontalWhitespace(source, lineStart, start)) return {
+		startPos: lineStart,
+		endPos: nextLine,
+		insertedText: ""
+	};
+	while (start > 0 && /[ \t]/.test(source[start - 1])) start--;
+	if (source[start - 1] === ",") start--;
+	return {
+		startPos: start,
+		endPos: specEnd,
+		insertedText: ""
+	};
+}
+function applyEdits(source, edits) {
+	return edits.toSorted((a, b) => b.startPos - a.startPos || b.endPos - a.endPos).reduce((current, edit) => `${current.slice(0, edit.startPos)}${edit.insertedText}${current.slice(edit.endPos)}`, source).replace(/^\n+/, "");
+}
+function transformParsed(source, root) {
+	const imports = findImportStatements(root);
+	const authImports = findAuthImports(imports);
+	if (authImports.length === 0) return null;
+	const authLocalNames = new Set(authImports.map((binding) => binding.localName));
+	if (hasAuthLocalCollision(root, authLocalNames)) return null;
+	const calls = findDirectAuthCalls(root, authLocalNames);
+	if (calls.length === 0) return null;
+	const existingRuntimeRef = runtimeAuthconnectionReference(imports);
+	if (!existingRuntimeRef && hasRuntimeImportCollision(root, imports)) return null;
+	const runtimeRef = existingRuntimeRef ?? AUTHCONNECTION;
+	const edits = calls.map((call) => call.objectNode.replace(runtimeRef));
+	if (!existingRuntimeRef) edits.push(buildAddRuntimeImportEdit(root, source, imports));
+	const scheduledRangesByLocalName = /* @__PURE__ */ new Map();
+	for (const call of calls) {
+		const ranges = scheduledRangesByLocalName.get(call.localName) ?? [];
+		ranges.push(call.range);
+		scheduledRangesByLocalName.set(call.localName, ranges);
+	}
+	for (const binding of authImports) {
+		if (!scheduledRangesByLocalName.has(binding.localName)) continue;
+		if (countRemainingRefs(root, binding.localName, scheduledRangesByLocalName.get(binding.localName) ?? []) > 0) continue;
+		const edit = buildImportRemovalEdit(source, binding);
+		if (edit) edits.push(edit);
+	}
+	const result = applyEdits(source, edits);
+	return result === source ? null : result;
+}
+function transform(source, filePath) {
+	const root = parseRoot(source, filePath);
+	return root ? transformParsed(source, root) : null;
+}
+function lineForIndex(source, index) {
+	return source.slice(0, index).split(/\r\n|\r|\n/).length;
+}
+function excerptForLine(line) {
+	return line.trim();
+}
+function isReviewLine(excerpt) {
+	if (!excerpt.includes(GET_CONNECTION_TOKEN)) return false;
+	if (excerpt.includes(`${AUTHCONNECTION}.${GET_CONNECTION_TOKEN}`) || excerpt.includes(`tailor.${AUTHCONNECTION}.${GET_CONNECTION_TOKEN}`)) return false;
+	return excerpt.includes(`.${GET_CONNECTION_TOKEN}`) || excerpt.includes(`["${GET_CONNECTION_TOKEN}"]`) || excerpt.includes(`['${GET_CONNECTION_TOKEN}']`) || new RegExp(`[,{]\\s*${GET_CONNECTION_TOKEN}\\s*[:}=,]`).test(excerpt);
+}
+function reviewFindings(source, _filePath, relativePath) {
+	if (!quickFilter(source)) return [];
+	const findings = [];
+	let offset = 0;
+	for (const line of source.split(/\n/)) {
+		const excerpt = excerptForLine(line);
+		if (isReviewLine(excerpt)) findings.push({
+			file: relativePath,
+			line: lineForIndex(source, offset),
+			message: "Replace defineAuth auth.getConnectionToken() with runtime authconnection.",
+			excerpt
+		});
+		offset += line.length + 1;
+	}
+	return findings;
+}
+//#endregion
+export { transform as default, reviewFindings };

package/dist/codemods/v2/auth-invoker-call-unwrap/scripts/transform.js

@@ -0,0 +1,7 @@
+import { transformAuthInvoker } from "../../auth-invoker-unwrap/scripts/transform.js";
+//#region codemods/v2/auth-invoker-call-unwrap/scripts/transform.ts
+function transform(source, filePath) {
+	return transformAuthInvoker(source, filePath, { renameOptionKeys: false });
+}
+//#endregion
+export { transform as default };

package/dist/codemods/v2/auth-invoker-unwrap/scripts/transform.js

@@ -1,8 +1,8 @@
 import { Lang, parse } from "@ast-grep/napi";
 //#region codemods/v2/auth-invoker-unwrap/scripts/transform.ts
-const QUICK_FILTER_NEEDLE = "auth.invoker";
+const QUICK_FILTER_NEEDLES = ["auth.invoker", "authInvoker"];
 function quickFilter(source) {
-	return source.includes(QUICK_FILTER_NEEDLE);
+	return QUICK_FILTER_NEEDLES.some((needle) => source.includes(needle));
 }
 function isInsideImportStatement(node) {
 	let current = node.parent();
@@ -121,32 +121,127 @@ function findAuthImports(root) {
 		return false;
 	});
 }
+function sameRange(a, b) {
+	const ar = a.range();
+	const br = b.range();
+	return ar.start.index === br.start.index && ar.end.index === br.end.index;
+}
+function keyText(node) {
+	if (!node) return null;
+	return node.text().replace(/^['"]|['"]$/g, "");
+}
+function expressionArguments(args) {
+	return args.children().filter((child) => ![
+		"(",
+		")",
+		","
+	].includes(child.kind()));
+}
+function argumentCallForObject(objectNode) {
+	const args = objectNode.parent();
+	const call = args?.parent();
+	if (args?.kind() !== "arguments" || call?.kind() !== "call_expression") return null;
+	const index = expressionArguments(args).findIndex((arg) => sameRange(arg, objectNode));
+	return index === -1 ? null : {
+		call,
+		index
+	};
+}
+function calleeText(call) {
+	return call.field("function")?.text() ?? "";
+}
+function isCreateCallOptionObject(objectNode, functionName) {
+	const callInfo = argumentCallForObject(objectNode);
+	return callInfo?.index === 0 && callInfo.call.field("function")?.kind() === "identifier" && calleeText(callInfo.call) === functionName;
+}
+function isExecutorOperationObject(objectNode) {
+	const operationPair = objectNode.parent();
+	if (operationPair?.kind() !== "pair" || keyText(operationPair.field("key")) !== "operation") return false;
+	const configObject = operationPair.parent();
+	return configObject?.kind() === "object" && isCreateCallOptionObject(configObject, "createExecutor");
+}
+function isSupportedInvokerOptionObject(objectNode) {
+	return isCreateCallOptionObject(objectNode, "createResolver") || isCreateCallOptionObject(objectNode, "startWorkflow") || isExecutorOperationObject(objectNode);
+}
+function optionObjectForPairKey(node) {
+	const parent = node.parent();
+	if (!parent || parent.kind() !== "pair") return null;
+	const key = parent.field("key");
+	if (!key || !sameRange(key, node)) return null;
+	const objectNode = parent.parent();
+	return objectNode?.kind() === "object" ? objectNode : null;
+}
+function isSupportedInvokerOptionKey(node) {
+	const objectNode = optionObjectForPairKey(node) ?? node.parent();
+	return objectNode?.kind() === "object" && isSupportedInvokerOptionObject(objectNode);
+}
+function isSupportedInvokerValueCall(node) {
+	const pair = node.parent();
+	if (pair?.kind() !== "pair") return false;
+	const value = pair.field("value");
+	if (!value || !sameRange(value, node)) return false;
+	const key = keyText(pair.field("key"));
+	if (key !== "authInvoker" && key !== "invoker") return false;
+	const objectNode = pair.parent();
+	return objectNode?.kind() === "object" && isSupportedInvokerOptionObject(objectNode);
+}
+function findAuthInvokerShorthands(root) {
+	return root.findAll({ rule: {
+		kind: "shorthand_property_identifier",
+		regex: "^authInvoker$"
+	} }).filter(isSupportedInvokerOptionKey);
+}
+function findAuthInvokerPropertyKeys(root) {
+	return root.findAll({ rule: {
+		kind: "property_identifier",
+		regex: "^authInvoker$"
+	} }).filter(isSupportedInvokerOptionKey);
+}
+function findQuotedAuthInvokerPropertyKeys(root) {
+	return root.findAll({ rule: {
+		kind: "string",
+		regex: "^['\"]authInvoker['\"]$"
+	} }).filter(isSupportedInvokerOptionKey);
+}
+function renameQuotedKey(node) {
+	const quote = node.text().startsWith("'") ? "'" : "\"";
+	return `${quote}invoker${quote}`;
+}
 /**
-* Replace `auth.invoker("name")` calls with the bare `"name"` string literal.
+* Replace `auth.invoker("name")` calls with the bare `"name"` string literal
+* and optionally rename `authInvoker:` option keys to `invoker:`.
 * If no other `auth` references remain after the rewrite, drop the `auth`
 * specifier (or the entire import line when `auth` was its sole specifier).
 *
-* `auth.invoker()` was deprecated in favor of passing the machine user name
-* directly; carrying the `auth` import only for `.invoker()` would otherwise
-* pull config-layer (Node-only) modules into runtime bundles.
+* `auth.invoker()` was removed in favor of passing the machine user name
+* directly to `invoker`; carrying the `auth` import only for `.invoker()`
+* would otherwise pull config-layer modules into runtime bundles.
 * @param source - File contents
 * @param filePath - Absolute path to the file (kept for the runner signature)
+* @param options - Transform behavior flags
 * @returns Transformed source or null when nothing matched.
 */
-function transform(source, _filePath) {
+function transformAuthInvoker(source, _filePath, options = {}) {
 	if (!quickFilter(source)) return null;
+	const renameOptionKeys = options.renameOptionKeys ?? true;
 	const root = parse(source.includes("</") || source.includes("/>") ? Lang.Tsx : Lang.TypeScript, source).root();
-	const calls = findInvokerCalls(root);
-	if (calls.length === 0) return null;
+	const calls = findInvokerCalls(root).filter((c) => isSupportedInvokerValueCall(c.callNode));
 	const edits = calls.map((c) => c.callNode.replace(c.argText));
-	if (countRemainingAuthRefs(root, calls.map((c) => c.range)) === 0) for (const importStmt of findAuthImports(root)) {
+	if (renameOptionKeys) {
+		edits.push(...findAuthInvokerPropertyKeys(root).map((node) => node.replace("invoker")));
+		edits.push(...findQuotedAuthInvokerPropertyKeys(root).map((node) => node.replace(renameQuotedKey(node))));
+		edits.push(...findAuthInvokerShorthands(root).map((node) => node.replace("invoker: authInvoker")));
+	}
+	if (calls.length > 0 && countRemainingAuthRefs(root, calls.map((c) => c.range)) === 0) for (const importStmt of findAuthImports(root)) {
 		const edit = buildAuthImportRemovalEdit(source, importStmt);
 		if (edit) edits.push(edit);
 	}
-	if (edits.length === 0) return null;
-	let result = root.commitEdits(edits);
+	let result = edits.length === 0 ? source : root.commitEdits(edits);
 	result = result.replace(/^[\t ]*\n+/, "").replace(/\n{3,}/g, "\n\n");
 	return result === source ? null : result;
 }
+function transform(source, filePath) {
+	return transformAuthInvoker(source, filePath);
+}
 //#endregion
-export { transform as default };
+export { transform as default, transformAuthInvoker };

package/dist/codemods/v2/define-generators-to-plugins/scripts/transform.js

@@ -47,7 +47,8 @@ function transform(source) {
 			if (arg.kind() === "array") {
 				const children = arg.children().filter((c) => c.isNamed() && c.kind() !== "comment");
 				if (children.length >= 1) {
-					const mapping = PLUGIN_MAP[children[0].text().replace(/^["']|["']$/g, "")];
+					const packageName = children[0].text().replace(/^["']|["']$/g, "");
+					const mapping = PLUGIN_MAP[packageName];
 					if (mapping) {
 						migratedArgs++;
 						importsToAdd.set(mapping.importPath, mapping.functionName);

package/dist/codemods/v2/env-var-rename/scripts/transform.js

@@ -0,0 +1,88 @@
+import { Lang, parse } from "@ast-grep/napi";
+import * as path from "pathe";
+//#region codemods/v2/env-var-rename/scripts/transform.ts
+const ENV_RENAMES = [
+	["TAILOR_PLATFORM_SDK_CONFIG_PATH", "TAILOR_CONFIG_PATH"],
+	["TAILOR_PLATFORM_SDK_DTS_PATH", "TAILOR_DTS_PATH"],
+	["TAILOR_PLATFORM_SDK_ALLOW_CI_ID_INJECTION", "TAILOR_CI_ALLOW_ID_INJECTION"],
+	["TAILOR_PLATFORM_SDK_BUILD_ONLY", "TAILOR_DEPLOY_BUILD_ONLY"],
+	["TAILOR_SDK_OUTPUT_DIR", "TAILOR_BUILD_OUTPUT_DIR"],
+	["TAILOR_SDK_SKILLS_SOURCE", "TAILOR_SKILLS_SOURCE"],
+	["TAILOR_SDK_VERSION", "TAILOR_TEMPLATE_SDK_VERSION"],
+	["TAILOR_ENABLE_INLINE_SOURCEMAP", "TAILOR_INLINE_SOURCEMAP"],
+	["TAILOR_PLATFORM_QUERY_NEWLINE_ON_ENTER", "TAILOR_QUERY_NEWLINE_ON_ENTER"],
+	["TAILOR_TOKEN", "TAILOR_PLATFORM_TOKEN"]
+];
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const ENV_BOUNDARY = "[A-Za-z0-9_]";
+const RENAME_PATTERNS = ENV_RENAMES.map(([from, to]) => ({
+	pattern: new RegExp(`(?<!${ENV_BOUNDARY})${from}(?!${ENV_BOUNDARY})`, "g"),
+	to
+}));
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function replaceTextTokens(source) {
+	let updated = source;
+	for (const { pattern, to } of RENAME_PATTERNS) updated = updated.replace(pattern, to);
+	return updated;
+}
+function sourceLang(filePath) {
+	const ext = path.extname(filePath).toLowerCase();
+	return ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : Lang.TypeScript;
+}
+function collectStringFragmentEdits(root, source) {
+	const edits = [];
+	const visit = (node) => {
+		if (node.kind() === "string_fragment") {
+			const range = node.range();
+			const text = source.slice(range.start.index, range.end.index);
+			const replacement = replaceTextTokens(text);
+			if (replacement !== text) edits.push([
+				range.start.index,
+				range.end.index,
+				replacement
+			]);
+			return;
+		}
+		for (const child of node.children()) visit(child);
+	};
+	visit(root);
+	return edits;
+}
+function replaceSourceStringFragments(source, filePath) {
+	let root;
+	try {
+		root = parse(sourceLang(filePath), source).root();
+	} catch {
+		return source;
+	}
+	let updated = source;
+	const edits = collectStringFragmentEdits(root, source).toSorted(([a], [b]) => b - a);
+	for (const [start, end, replacement] of edits) updated = `${updated.slice(0, start)}${replacement}${updated.slice(end)}`;
+	return updated;
+}
+function replaceSourceTokens(source, filePath) {
+	let updated = source;
+	for (const [from, to] of ENV_RENAMES) {
+		const escaped = escapeRegExp(from);
+		updated = updated.replace(new RegExp(`\\bprocess\\.env\\.${escaped}(?![A-Za-z0-9_$])`, "g"), `process.env.${to}`).replace(new RegExp(`\\bprocess\\.env\\[(["'\`])${escaped}\\1\\]`, "g"), `process.env[$1${to}$1]`).replace(new RegExp(`([,{]\\s*)${escaped}(?=\\s*:)`, "g"), `$1${to}`);
+	}
+	return replaceSourceStringFragments(updated, filePath);
+}
+function transform(source, filePath) {
+	const ext = path.extname(filePath).toLowerCase();
+	const updated = SOURCE_EXTENSIONS.has(ext) ? replaceSourceTokens(source, filePath) : replaceTextTokens(source);
+	return updated === source ? null : updated;
+}
+//#endregion
+export { transform as default };

package/dist/codemods/v2/execute-script-arg/scripts/transform.js

@@ -0,0 +1,60 @@
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/execute-script-arg/scripts/transform.ts
+const NEEDLE = "executeScript";
+function quickFilter(source) {
+	return source.includes(NEEDLE) && source.includes("JSON.stringify");
+}
+function pairKeyText(pair) {
+	const key = pair.children()[0];
+	if (!key) return null;
+	return key.text().replace(/^['"]|['"]$/g, "");
+}
+/**
+* True when `stringifyCall` is the value of a top-level `arg:` property in the
+* object literal passed directly to `executeScript(...)`. The chain checked is
+* `JSON.stringify(...)` → pair (`arg:`) → object → arguments → `executeScript`
+* call, so a nested `arg:` (e.g. `executeScript({ opts: { arg: ... } })`) or an
+* unrelated `JSON.stringify` is left untouched.
+*/
+function isExecuteScriptArg(stringifyCall) {
+	const pair = stringifyCall.parent();
+	if (!pair || pair.kind() !== "pair") return false;
+	if (pairKeyText(pair) !== "arg") return false;
+	const obj = pair.parent();
+	if (!obj || obj.kind() !== "object") return false;
+	const args = obj.parent();
+	if (!args || args.kind() !== "arguments") return false;
+	const call = args.parent();
+	if (!call || call.kind() !== "call_expression") return false;
+	const callee = call.children()[0];
+	return !!callee && callee.text() === NEEDLE;
+}
+/**
+* Rewrite `executeScript({ ..., arg: JSON.stringify(X), ... })` to
+* `executeScript({ ..., arg: X, ... })`.
+*
+* In v2 the `executeScript` `arg` option takes a JSON-serializable value and
+* serializes it internally, so a pre-stringified argument double-encodes. Only
+* the literal `arg: JSON.stringify(<single expr>)` form is rewritten; indirect
+* forms (a stringified value held in a variable, `JSON.stringify(x, null, 2)`,
+* etc.) are left for manual migration.
+* @param source - File contents
+* @param _filePath - Absolute path to the file (kept for the runner signature)
+* @returns Transformed source or null when nothing matched.
+*/
+function transform(source, _filePath) {
+	if (!quickFilter(source)) return null;
+	const root = parse(source.includes("</") || source.includes("/>") ? Lang.Tsx : Lang.TypeScript, source).root();
+	const edits = [];
+	for (const match of root.findAll({ rule: { pattern: "JSON.stringify($X)" } })) {
+		if (!isExecuteScriptArg(match)) continue;
+		const inner = match.getMatch("X");
+		if (!inner) continue;
+		edits.push(match.replace(inner.text()));
+	}
+	if (edits.length === 0) return null;
+	const result = root.commitEdits(edits);
+	return result === source ? null : result;
+}
+//#endregion
+export { transform as default };