@onrails/codemod 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onrails/codemod",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Codemods for migrating onto @onrails/result (neverthrow → compat shim, and beyond)",
   "license": "MIT",
   "author": "Alan R. Soares",
@@ -43,6 +43,7 @@
   },
   "dependencies": {
     "@onrails/maybe": "0.1.0",
+    "@onrails/pattern": "0.1.0",
     "@onrails/result": "0.1.0",
     "typescript": "^6.0.3"
   },

package/src/ast.ts

@@ -0,0 +1,58 @@
+import { fromNullable, type Maybe, match, none, some } from "@onrails/maybe";
+import ts from "typescript";
+import { TYPE_ONLY_NATIVE } from "./constants.js";
+import type { Edit } from "./types.js";
+
+export const edit = (text: string, imports: readonly string[] = []): Edit => ({
+  start: 0,
+  end: 0,
+  text,
+  imports,
+});
+
+export const lookupMap = <K, V, R>(m: Map<K, V>, k: K, f: (v: V) => R): Maybe<R> =>
+  match(fromNullable(m.get(k)), (v) => some(f(v)), none);
+
+export const concatCollectors =
+  <T, R>(...fns: Array<(t: T) => readonly R[]>) =>
+  (t: T): readonly R[] =>
+    fns.flatMap((f) => f(t));
+
+export const walkSource = (
+  src: string,
+  visit: (node: ts.Node, sf: ts.SourceFile) => unknown,
+): void => {
+  const sf = ts.createSourceFile("codemod.ts", src, ts.ScriptTarget.Latest, true);
+  const go = (n: ts.Node) => {
+    if (visit(n, sf)) return;
+    ts.forEachChild(n, go);
+  };
+  go(sf);
+};
+
+export const spanEdit = (node: ts.Node, sf: ts.SourceFile, partial: Edit): Edit => ({
+  ...partial,
+  start: node.getStart(sf),
+  end: node.getEnd(),
+});
+
+export const argsToText = (args: ts.NodeArray<ts.Expression>): string =>
+  args.map((a) => a.getText()).join(", ");
+
+export const countOccurrences = (s: string, sub: string): number => s.split(sub).length - 1;
+
+export const splitImportNames = (specifiers: string): readonly string[] =>
+  specifiers
+    .split(",")
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0);
+
+export const stripInlineType = (specifier: string): string => specifier.replace(/^type\s+/, "");
+
+export const importedName = (specifier: string): string =>
+  stripInlineType(specifier).split(/\s+as\s+/i)[0] ?? specifier;
+
+export const isTypeOnlyNative = (specifier: string): boolean =>
+  specifier.startsWith("type ") || TYPE_ONLY_NATIVE.has(importedName(specifier));
+
+export const isValueImport = (specifier: string): boolean => !isTypeOnlyNative(specifier);

package/src/chains.ts

@@ -0,0 +1,228 @@
+import { compactMap, isSome, type Maybe, map, none, some } from "@onrails/maybe";
+import ts from "typescript";
+import { argsToText, edit, lookupMap, spanEdit, walkSource } from "./ast.js";
+import {
+  ASYNC_ROOT_HINTS,
+  CHAIN_METHODS,
+  PREDICATE_METHODS,
+  RESULT_SPECIFIC_CHAIN_METHODS,
+  SAFE_BASE_PATTERNS,
+  TEE_METHODS,
+  TERMINAL_METHODS,
+  UNSAFE_UNWRAP_METHODS,
+  ZERO_ARG_HELPERS,
+} from "./constants.js";
+import { addNativeValueImports } from "./imports.js";
+import type { ChainStep, Edit, EditAcc, PipelinePart } from "./types.js";
+
+export function isSupportedChainCall(node: ts.Node): node is ts.CallExpression {
+  if (!ts.isCallExpression(node)) return false;
+  if (!ts.isPropertyAccessExpression(node.expression)) return false;
+  const method = node.expression.name.text;
+  return CHAIN_METHODS.has(method) || TERMINAL_METHODS.has(method);
+}
+
+function identifierCallToNative(node: ts.CallExpression): Maybe<Edit> {
+  if (!ts.isIdentifier(node.expression)) return none();
+  const name = node.expression.text;
+  if (node.arguments.length === 0) {
+    const zero = lookupMap(ZERO_ARG_HELPERS, name, (text) => edit(text));
+    if (isSome(zero)) return zero;
+  }
+
+  if (name === "sequenceTupleAsync") {
+    return some(edit(`ResultAsync.combineTuple(${argsToText(node.arguments)})`, ["ResultAsync"]));
+  }
+  if (name === "getOrElse") {
+    return some(edit(`unwrapOr(${argsToText(node.arguments)})`, ["unwrapOr"]));
+  }
+  if (name === "collect") {
+    return some(edit(`combine(${argsToText(node.arguments)})`, ["combine"]));
+  }
+  if (name === "matchResult" || name === "matchMaybe") {
+    return some(edit(`match(${argsToText(node.arguments)})`, ["match"]));
+  }
+  if (name === "fold") {
+    return map(foldHandlerTexts(node.arguments[0]), ({ okText, errText }) =>
+      edit(`match(${okText}, ${errText})`, ["match"]),
+    );
+  }
+  return none();
+}
+
+type FoldHandlerTexts = { okText: string; errText: string };
+
+// Bails (none) unless both `ok` and `err` handlers are plain or shorthand
+// properties — spread/computed handlers can't be rewritten textually.
+function foldHandlerTexts(objArg: ts.Expression | undefined): Maybe<FoldHandlerTexts> {
+  if (!objArg || !ts.isObjectLiteralExpression(objArg)) return none();
+  let okText: string | undefined;
+  let errText: string | undefined;
+  for (const prop of objArg.properties) {
+    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+      if (prop.name.text === "ok") {
+        okText = prop.initializer.getText();
+      } else if (prop.name.text === "err") {
+        errText = prop.initializer.getText();
+      }
+    } else if (ts.isShorthandPropertyAssignment(prop)) {
+      if (prop.name.text === "ok") {
+        okText = "ok";
+      } else if (prop.name.text === "err") {
+        errText = "err";
+      }
+    }
+  }
+  return okText !== undefined && errText !== undefined ? some({ okText, errText }) : none();
+}
+
+function curriedFoldToNative(node: ts.CallExpression): Maybe<Edit> {
+  if (
+    !ts.isCallExpression(node.expression) ||
+    !ts.isIdentifier(node.expression.expression) ||
+    node.expression.expression.text !== "fold"
+  ) {
+    return none();
+  }
+  const receiver = node.arguments[0];
+  if (!receiver) return none();
+  return map(foldHandlerTexts(node.expression.arguments[0]), ({ okText, errText }) =>
+    edit(`match(${okText}, ${errText})(${receiver.getText()})`, ["match"]),
+  );
+}
+
+export function helperCallToNative(node: ts.CallExpression): Maybe<Edit> {
+  const ident = identifierCallToNative(node);
+  if (isSome(ident)) return ident;
+
+  const curried = curriedFoldToNative(node);
+  if (isSome(curried)) return curried;
+
+  if (!ts.isPropertyAccessExpression(node.expression)) return none();
+  const method = node.expression.name.text;
+  const base = node.expression.expression
+    .getText()
+    .replaceAll(".andTee(", ".tap(")
+    .replaceAll(".orTee(", ".tapErr(");
+  const argsText = argsToText(node.arguments);
+
+  const tee = lookupMap(TEE_METHODS, method, (t) => edit(`${base}.${t}(${argsText})`));
+  if (isSome(tee)) return tee;
+
+  if (PREDICATE_METHODS.has(method)) {
+    return some(edit(`${method}(${base})`, [method]));
+  }
+
+  return lookupMap(UNSAFE_UNWRAP_METHODS, method, (u) => edit(`${u}(${base})`, [u]));
+}
+
+export function isNestedInSupportedChain(node: ts.Node): boolean {
+  const parent = node.parent;
+  if (!parent) return false;
+  if (!ts.isPropertyAccessExpression(parent)) return false;
+  return isSupportedChainCall(parent.parent);
+}
+
+export function collectChain(node: ts.CallExpression): { base: string; steps: ChainStep[] } {
+  const steps: ChainStep[] = [];
+  let current: ts.Expression = node;
+
+  while (ts.isCallExpression(current) && ts.isPropertyAccessExpression(current.expression)) {
+    const method = current.expression.name.text;
+    if (!CHAIN_METHODS.has(method) && !TERMINAL_METHODS.has(method)) break;
+    steps.push({
+      method,
+      argsText: argsToText(current.arguments),
+      argCount: current.arguments.length,
+    });
+    current = current.expression.expression;
+  }
+
+  return {
+    base: current.getText(),
+    steps: steps.reverse(),
+  };
+}
+
+export const hasAsyncRootHint = (base: string): boolean =>
+  ASYNC_ROOT_HINTS.some((hint) => base.includes(hint));
+
+export const isSafeSyncChainBase = (base: string): boolean =>
+  SAFE_BASE_PATTERNS.some((re) => re.test(base));
+
+const isTerminalStep = (s: ChainStep): boolean => TERMINAL_METHODS.has(s.method);
+const isResultSpecificStep = (s: ChainStep): boolean => RESULT_SPECIFIC_CHAIN_METHODS.has(s.method);
+const isChainStep = (s: ChainStep): boolean => CHAIN_METHODS.has(s.method);
+
+export function chainToNative(base: string, steps: readonly ChainStep[]): Maybe<Edit> {
+  if (steps.length === 0 || hasAsyncRootHint(base)) return none();
+  const terminalStep = steps.find(isTerminalStep);
+  if (!isSafeSyncChainBase(base)) return none();
+  if (!terminalStep && !steps.some(isResultSpecificStep)) return none();
+  if (terminalStep?.method === "match" && terminalStep.argCount !== 2) return none();
+  const pipelineSteps = steps.filter(isChainStep);
+  const pipelineParts = compactMap(pipelineSteps, (step) =>
+    lookupMap(
+      CHAIN_METHODS,
+      step.method,
+      (nativeName): PipelinePart => ({
+        importName: nativeName,
+        text: `${nativeName}(${step.argsText})`,
+      }),
+    ),
+  );
+
+  if (pipelineParts.length !== pipelineSteps.length) return none();
+
+  const parts = pipelineParts.map((part) => part.text);
+  const imports = new Set(pipelineParts.map((part) => part.importName));
+  const pipeline = parts.length > 0 ? `pipe(${[base, ...parts].join(", ")})` : base;
+
+  if (parts.length > 0) imports.add("pipe");
+
+  if (!terminalStep) {
+    return some(edit(pipeline, [...imports]));
+  }
+
+  imports.add(terminalStep.method);
+  return some(edit(`${terminalStep.method}(${pipeline}, ${terminalStep.argsText})`, [...imports]));
+}
+
+export const byStartDesc = (a: Edit, b: Edit): number => b.start - a.start;
+
+export const applyEditStep = (acc: EditAcc, e: Edit): EditAcc => ({
+  src: `${acc.src.slice(0, e.start)}${e.text}${acc.src.slice(e.end)}`,
+  imports: new Set([...acc.imports, ...e.imports]),
+});
+
+export function rewriteCompatMethodChainsToNative(src: string): string {
+  const edits: Edit[] = [];
+
+  walkSource(src, (node, sf) => {
+    if (ts.isCallExpression(node)) {
+      const helper = helperCallToNative(node);
+      if (isSome(helper)) {
+        edits.push(spanEdit(node, sf, helper.value));
+        return true;
+      }
+    }
+
+    if (
+      isSupportedChainCall(node) &&
+      !isNestedInSupportedChain(node) &&
+      !ts.isPropertyAccessExpression(node.parent)
+    ) {
+      const chain = collectChain(node);
+      const chained = chainToNative(chain.base, chain.steps);
+      if (isSome(chained)) edits.push(spanEdit(node, sf, chained.value));
+    }
+  });
+
+  if (edits.length === 0) return src;
+
+  const { src: next, imports } = edits
+    .sort(byStartDesc)
+    .reduce(applyEditStep, { src, imports: new Set<string>() });
+
+  return addNativeValueImports(next, [...imports]);
+}

package/src/cli.ts

@@ -0,0 +1,132 @@
+import { relative, resolve } from "node:path";
+import * as Maybe from "@onrails/maybe";
+import { match } from "@onrails/pattern";
+import { err, isErr, ok, type Result, ResultAsync } from "@onrails/result";
+import { Glob } from "bun";
+import { CODE_EXT, SKIP } from "./constants.js";
+import { computeFileChange, toFileChange } from "./file-change.js";
+import { readFileText, writeFileText } from "./io.js";
+import { rewritePkg } from "./pkg.js";
+import type { ArgState, Args, FileChange, Mode, PkgChange } from "./types.js";
+
+const ONRAILS_FLAG = "--onrails=";
+
+const applyArg = (s: ArgState, a: string): ArgState =>
+  match(a)
+    .returnType<ArgState>()
+    .withEither("--dry", "-n", () => ({ ...s, dry: true }))
+    .with("--to-native", () => ({ ...s, mode: "native" }))
+    .with(
+      (x) => x.startsWith(ONRAILS_FLAG),
+      (x) => ({ ...s, onrails: resolve(x.slice(ONRAILS_FLAG.length)) }),
+    )
+    .with(
+      (x) => !x.startsWith("--"),
+      (x) => ({ ...s, positional: [...s.positional, x] }),
+    )
+    .otherwise(() => s);
+
+const USAGE =
+  "usage: onrails-codemod-neverthrow <target-dir> [--dry] [--to-native] [--onrails=<abs-path>]";
+
+export function parseArgs(argv: string[]): Result<Args, string> {
+  const initial: ArgState = {
+    positional: [],
+    dry: false,
+    mode: "compat",
+    onrails: resolve(import.meta.dir, "../../..", "packages/result"),
+  };
+  const { positional, dry, mode, onrails } = argv.reduce(applyArg, initial);
+  if (positional.length !== 1) {
+    return err(USAGE);
+  }
+  return ok({
+    target: resolve(positional[0] ?? "."),
+    dry,
+    onrails,
+    mode,
+  });
+}
+
+const shouldSkip = (path: string) => path.split("/").some((seg) => SKIP.has(seg));
+
+async function* walk(root: string): AsyncGenerator<string> {
+  const glob = new Glob("**/*");
+  for await (const rel of glob.scan({ cwd: root, dot: false, onlyFiles: true })) {
+    if (!shouldSkip(rel)) yield `${root}/${rel}`;
+  }
+}
+
+const rewriteCode = (
+  path: string,
+  dry: boolean,
+  mode: Mode,
+): ResultAsync<Maybe.Maybe<FileChange>, Error> =>
+  readFileText(path).flatMap((src) =>
+    Maybe.match(
+      computeFileChange(src, mode),
+      (c) => {
+        const change = toFileChange(path, c);
+        return c.changed && !dry
+          ? writeFileText(path, c.next).map(() => Maybe.some(change))
+          : ResultAsync.ok<Maybe.Maybe<FileChange>, Error>(Maybe.some(change));
+      },
+      () => ResultAsync.ok<Maybe.Maybe<FileChange>, Error>(Maybe.none()),
+    ),
+  );
+
+const collectInto =
+  <T>(into: T[], file: string) =>
+  (r: ResultAsync<Maybe.Maybe<T>, Error>): Promise<void> =>
+    r.match(
+      (m) => void Maybe.tap(m, (c) => into.push(c)),
+      (e) => console.error(`error processing ${file}:`, e.message),
+    );
+
+const printReport = (
+  { target, dry, onrails, mode }: Args,
+  codeChanges: readonly FileChange[],
+  pkgChanges: readonly PkgChange[],
+): void => {
+  const label = dry ? "DRY" : "APPLY";
+  console.log(`[${label}] target=${target}`);
+  console.log(`[${label}] mode=${mode}`);
+  if (mode === "compat") console.log(`[${label}] onrails=${onrails}`);
+  const changedCodeCount = codeChanges.filter((c) => c.changed).length;
+  console.log(`[${label}] code files changed: ${changedCodeCount}`);
+  if (mode === "native") {
+    console.log(`[${label}] code files reported only: ${codeChanges.length - changedCodeCount}`);
+  }
+  for (const c of codeChanges) {
+    console.log(`  ${relative(target, c.path)}  (${c.before} import${c.before === 1 ? "" : "s"})`);
+    for (const warning of c.warnings) {
+      console.log(`    TODO line ${warning.line}: ${warning.label}: ${warning.text}`);
+    }
+  }
+  if (mode === "compat") {
+    console.log(`[${label}] package.json updated: ${pkgChanges.length}`);
+    for (const c of pkgChanges) {
+      console.log(`  ${relative(target, c.path)}  [${c.removed.join(", ")}] -> ${c.addedAs}`);
+    }
+  }
+  if (dry) console.log(`[${label}] no files written. re-run without --dry to apply.`);
+};
+
+export async function main() {
+  const parsed = parseArgs(Bun.argv.slice(2));
+  if (isErr(parsed)) {
+    console.error(parsed.error);
+    process.exit(2);
+  }
+  const args = parsed.value;
+  const { target, dry, onrails, mode } = args;
+  const codeChanges: FileChange[] = [];
+  const pkgChanges: PkgChange[] = [];
+  for await (const file of walk(target)) {
+    if (mode === "compat" && file.endsWith("/package.json"))
+      await collectInto(pkgChanges, file)(rewritePkg(file, onrails, dry));
+    else if (CODE_EXT.test(file))
+      await collectInto(codeChanges, file)(rewriteCode(file, dry, mode));
+  }
+  printReport(args, codeChanges, pkgChanges);
+}

package/src/constants.ts

@@ -0,0 +1,63 @@
+export const SKIP = new Set([
+  "node_modules",
+  "dist",
+  ".git",
+  ".next",
+  ".turbo",
+  "coverage",
+  "build",
+]);
+export const CODE_EXT = /\.(ts|tsx|mts|cts)$/;
+export const IMPORT_RE = /(from\s+|import\s*\(\s*)(['"])neverthrow\2/g;
+export const COMPAT_SPEC = "@onrails/result/compat/neverthrow";
+export const NATIVE_SPEC = "@onrails/result";
+export const DEP_KEYS = ["dependencies", "devDependencies", "peerDependencies"] as const;
+export const TYPE_ONLY_NATIVE = new Set(["Result", "Ok", "Err", "UnexpectedError"]);
+export const COMPAT_ONLY_PATTERNS = [
+  { pattern: /\bResult\.(combine|fromThrowable)\b/, label: "Result static helper" },
+  { pattern: /\._unsafeUnwrap(Err)?\s*\(/, label: "unsafe compat unwrap" },
+] as const;
+export const RESULT_SPECIFIC_CHAIN_METHODS = new Set([
+  "andThen",
+  "chain",
+  "flatMap",
+  "mapErr",
+  "orElse",
+  "recover",
+  "tapErr",
+  "match",
+  "unwrapOr",
+]);
+export const CHAIN_METHODS = new Map([
+  ["map", "map"],
+  ["mapErr", "mapErr"],
+  ["andThen", "flatMap"],
+  ["chain", "flatMap"],
+  ["flatMap", "flatMap"],
+  ["orElse", "recover"],
+  ["recover", "recover"],
+  ["tap", "tap"],
+  ["tapErr", "tapErr"],
+]);
+export const TERMINAL_METHODS = new Set(["match", "unwrapOr"]);
+export const ASYNC_ROOT_HINTS = [
+  "ResultAsync",
+  "okAsync",
+  "errAsync",
+  "fromPromise",
+  "fromSafePromise",
+];
+export const ZERO_ARG_HELPERS = new Map([
+  ["ok", "ok(undefined)"],
+  ["okAsync", "okAsync(undefined)"],
+]);
+export const TEE_METHODS = new Map([
+  ["andTee", "tap"],
+  ["orTee", "tapErr"],
+]);
+export const PREDICATE_METHODS = new Set(["isOk", "isErr"]);
+export const UNSAFE_UNWRAP_METHODS = new Map([
+  ["_unsafeUnwrap", "unwrapOk"],
+  ["_unsafeUnwrapErr", "unwrapErr"],
+]);
+export const SAFE_BASE_PATTERNS = [/^(ok|err)\s*\(/, /^Result\./, /^[a-zA-Z_$][\w$]*$/] as const;

package/src/file-change.ts

@@ -0,0 +1,57 @@
+import { type Maybe, none, some } from "@onrails/maybe";
+import { flow } from "@onrails/result";
+import { concatCollectors, countOccurrences } from "./ast.js";
+import { rewriteCompatMethodChainsToNative } from "./chains.js";
+import { COMPAT_SPEC, IMPORT_RE, NATIVE_SPEC } from "./constants.js";
+import { rewriteCompatImportsToNative } from "./imports.js";
+import type { ComputedChange, FileChange, Mode, ModeStrategy } from "./types.js";
+import {
+  collectNativeMigrationWarnings,
+  collectUnsupportedCompatImportWarnings,
+} from "./warnings.js";
+
+const rewriteCompatToNative = flow(rewriteCompatImportsToNative, rewriteCompatMethodChainsToNative);
+
+const rewriteNeverthrowToCompat = (src: string): string =>
+  src.replace(IMPORT_RE, (_, lead, quote) => `${lead}${quote}${COMPAT_SPEC}${quote}`);
+
+const collectAllNativeWarnings = concatCollectors(
+  collectUnsupportedCompatImportWarnings,
+  collectNativeMigrationWarnings,
+);
+
+const MODES: Record<Mode, ModeStrategy> = {
+  compat: {
+    countBefore: (src) => (src.match(IMPORT_RE) ?? []).length,
+    earlyExit: (_src, before) => before === 0,
+    transform: rewriteNeverthrowToCompat,
+    warnings: () => [],
+    countAfter: () => 0,
+  },
+  native: {
+    countBefore: (src) => countOccurrences(src, COMPAT_SPEC),
+    earlyExit: () => false,
+    transform: rewriteCompatToNative,
+    warnings: collectAllNativeWarnings,
+    countAfter: (next) => countOccurrences(next, NATIVE_SPEC),
+  },
+};
+
+export const computeFileChange = (src: string, mode: Mode): Maybe<ComputedChange> => {
+  const strat = MODES[mode];
+  const before = strat.countBefore(src);
+  if (strat.earlyExit(src, before)) return none();
+  const next = strat.transform(src);
+  const changed = next !== src;
+  const warnings = strat.warnings(next);
+  if (!changed && warnings.length === 0) return none();
+  return some({ next, before, after: strat.countAfter(next), changed, warnings });
+};
+
+export const toFileChange = (path: string, c: ComputedChange): FileChange => ({
+  path,
+  before: c.before,
+  after: c.after,
+  changed: c.changed,
+  warnings: c.warnings,
+});

package/src/imports.ts

@@ -0,0 +1,77 @@
+import { isTypeOnlyNative, isValueImport, splitImportNames, stripInlineType } from "./ast.js";
+import { COMPAT_SPEC, NATIVE_SPEC } from "./constants.js";
+
+// Every entry must have a matching call-site rewrite in chains.ts, or the
+// renamed import strands the old name at call sites. `of` is intentionally
+// absent: bare `of(...)` calls collide with other libraries (e.g. RxJS) and
+// the canonical target differs per carrier (result `ok` vs maybe `some`) —
+// the native package still exports the deprecated alias, so imports of `of`
+// pass through unchanged and the lint rules flag them for manual migration.
+const IMPORT_RENAMES = new Map([
+  ["sequenceTupleAsync", "ResultAsync"],
+  ["getOrElse", "unwrapOr"],
+  ["collect", "combine"],
+  ["matchResult", "match"],
+  ["matchMaybe", "match"],
+  ["fold", "match"],
+]);
+
+export function toNativeImport(full: string, specifiers: string, quote: string): string {
+  const imports = splitImportNames(specifiers);
+  const typeNames = imports.filter(isTypeOnlyNative).map(stripInlineType);
+  const rawValueNames = imports.filter(isValueImport);
+  const valueNames = rawValueNames.map((name) => IMPORT_RENAMES.get(name) ?? name);
+
+  const uniqueValueNames = [...new Set(valueNames)];
+  const uniqueTypeNames = [...new Set(typeNames)];
+  const chunks: string[] = [];
+
+  if (uniqueValueNames.length > 0) {
+    chunks.push(`import { ${uniqueValueNames.join(", ")} } from ${quote}${NATIVE_SPEC}${quote};`);
+  }
+
+  if (uniqueTypeNames.length > 0) {
+    chunks.push(
+      `import type { ${uniqueTypeNames.join(", ")} } from ${quote}${NATIVE_SPEC}${quote};`,
+    );
+  }
+
+  return chunks.length > 0 ? chunks.join("\n") : full;
+}
+
+export function rewriteCompatImportsToNative(src: string): string {
+  const namedImportRe = new RegExp(
+    String.raw`import\s+\{\s*([^}]+?)\s*\}\s+from\s+(['"])${COMPAT_SPEC.replaceAll("/", String.raw`\/`)}\2\s*;?`,
+    "g",
+  );
+  const typeNamedImportRe = new RegExp(
+    String.raw`import\s+type\s+\{\s*([^}]+?)\s*\}\s+from\s+(['"])${COMPAT_SPEC.replaceAll("/", String.raw`\/`)}\2\s*;?`,
+    "g",
+  );
+
+  return src
+    .replace(typeNamedImportRe, (_full, specifiers: string, quote: string) => {
+      const imports = splitImportNames(specifiers);
+      return `import type { ${imports.join(", ")} } from ${quote}${NATIVE_SPEC}${quote};`;
+    })
+    .replace(namedImportRe, (full: string, specifiers: string, quote: string) =>
+      toNativeImport(full, specifiers, quote),
+    );
+}
+
+export function addNativeValueImports(src: string, imports: readonly string[]): string {
+  const names = [...new Set(imports)].sort();
+  if (names.length === 0) return src;
+  const importRe = new RegExp(
+    String.raw`import\s+\{\s*([^}]*?)\s*\}\s+from\s+(['"])${NATIVE_SPEC.replaceAll("/", String.raw`\/`)}\2\s*;?`,
+  );
+  const match = importRe.exec(src);
+
+  if (!match?.[1]) {
+    return `import { ${names.join(", ")} } from "${NATIVE_SPEC}";\n${src}`;
+  }
+
+  const existing = splitImportNames(match[1]).map(stripInlineType);
+  const next = [...new Set([...existing, ...names])].sort();
+  return `${src.slice(0, match.index)}import { ${next.join(", ")} } from ${match[2]}${NATIVE_SPEC}${match[2]};${src.slice(match.index + match[0].length)}`;
+}