@cosmicdrift/kumiko-framework 0.386.0 → 0.388.0

package/src/scripts/codemod/pii-personal-migration.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env bun
 // Migrates create*Field(...) calls from the old flag-based PII API (pii,
 // userOwned, tenantOwned, subjectRef, allowPlaintext, lookupable,
-// searchable, sensitive) to the author-facing personal/find API
-// (kumiko-framework#2250). Idempotent — re-running is a no-op on already
-// migrated fields (skipped once a `personal` property is present).
+// searchable, sensitive) to the author-facing personal/find API.
+// Idempotent — re-running is a no-op on already migrated fields (skipped once
+// a `personal` property is present).
 //
 // Mapping table (exact):
 //   pii: true                           -> personal: "self"
@@ -87,7 +87,16 @@ const OVERRIDES_ARG_INDEX_1 = new Set(["createEmbeddedField", "createEmbeddedLis
 const FIELD_FACTORY_RE = /^create\w*Field$/;
 
 type ReportEntry = { readonly file: string; readonly line: number; readonly note: string };
-type FindBucket = "exact" | "fuzzy" | "none" | "secret" | "ref" | "personal-false" | "no-find";
+const FIND_BUCKETS = [
+  "exact",
+  "fuzzy",
+  "none",
+  "secret",
+  "ref",
+  "personal-false",
+  "no-find",
+] as const;
+type FindBucket = (typeof FIND_BUCKETS)[number];
 
 const reports: ReportEntry[] = [];
 const newLookupableSites: ReportEntry[] = [];
@@ -168,50 +177,40 @@ function reportRawSubjectLiterals(
   }
 }
 
-// kumiko-lint-ignore complexity-budget migration codemod, one-time script — splitting would add risk without benefit
-function processObjectLiteral(obj: ObjectLiteralExpression, factoryName: string): void {
-  // skip: field already carries `personal` — already migrated, idempotent no-op
-  if (obj.getProperty("personal")) return;
-
-  const piiEncryptedProp = obj.getProperty("piiEncrypted");
-  if (piiEncryptedProp) {
-    report(
-      piiEncryptedProp,
-      "piiEncrypted: true on an entity field (removed from the type system) — needs a human decision, not a mechanical mapping",
-    );
-    // skip: reported above — piiEncrypted needs a human decision, not a mechanical mapping
-    return;
-  }
+type SubjectProp = { readonly name: SubjectFlagName; readonly prop: PropertyAssignment };
+type PersonalInit = { readonly personal: string; readonly reason: string | undefined };
+type FindSupport = "text" | "longText" | "none";
+type FindabilityProps = {
+  readonly lookupable: PropertyAssignment | undefined;
+  readonly searchable: PropertyAssignment | undefined;
+  readonly sensitive: PropertyAssignment | undefined;
+};
 
+function singleSubjectFlag(obj: ObjectLiteralExpression): SubjectProp | undefined {
   const subjectProps = SUBJECT_FLAG_NAMES.map((n) => ({ name: n, prop: findProp(obj, n) })).filter(
     (x): x is { name: SubjectFlagName; prop: PropertyAssignment } => !!x.prop,
   );
-  const lookupableProp = findProp(obj, "lookupable");
-  const searchableProp = findProp(obj, "searchable");
-  const sensitiveProp = findProp(obj, "sensitive");
-  const anonymizeProp = obj.getProperty("anonymize");
-
   if (subjectProps.length === 0) {
     // `searchable`/`sensitive` alone remain valid, unrelated FieldDef
     // properties — left untouched. `lookupable` alone can never compile
     // (always an excess property without a `personal` to attach `find`
     // to). `anonymize` alone has no PersonalAnnotations arm to live on.
+    const lookupableProp = findProp(obj, "lookupable");
     if (lookupableProp) {
       report(
         lookupableProp,
         "lookupable without any subject annotation — no `personal` to attach `find` to",
       );
     }
+    const anonymizeProp = obj.getProperty("anonymize");
     if (anonymizeProp) {
       report(
         anonymizeProp,
         "anonymize without any subject annotation — no PersonalAnnotations arm accepts anonymize alone",
       );
     }
-    // skip: no subject flag on this field — stray lookupable/anonymize already reported above if present
-    return;
+    return undefined;
   }
-
   if (subjectProps.length > 1) {
     const first = subjectProps[0];
     if (first) {
@@ -220,152 +219,154 @@ function processObjectLiteral(obj: ObjectLiteralExpression, factoryName: string)
         `multiple subject annotations on one field (${subjectProps.map((s) => s.name).join(", ")}) — needs a human decision on which subject is correct`,
       );
     }
-    // skip: reported above — multiple subject annotations need a human call on which one wins
-    return;
-  }
-
-  const subject = subjectProps[0];
-  if (!subject) {
-    // skip: length===0 and length>1 already returned — empty [0] is unreachable
-    return;
+    return undefined;
   }
+  return subjectProps[0];
+}
 
+function findSupportOf(factoryName: string, subject: SubjectProp): FindSupport | undefined {
   if (NO_PERSONAL_FACTORIES.has(factoryName)) {
     report(
       subject.prop,
       `${factoryName} has no personal-annotation support — subject flag "${subject.name}" cannot be expressed here`,
     );
-    // skip: reported above — this factory has no personal-annotation support to migrate into
-    return;
-  }
-  const isTextFind = TEXT_FIND_FACTORIES.has(factoryName);
-  const isLongTextFind = LONGTEXT_FIND_FACTORIES.has(factoryName);
-  const isNoFind = NO_FIND_FACTORIES.has(factoryName);
-  if (!isTextFind && !isLongTextFind && !isNoFind) {
-    report(
-      subject.prop,
-      `unrecognized field factory "${factoryName}" — cannot verify its PersonalAnnotations shape`,
-    );
-    // skip: reported above — unknown factory shape, cannot verify safely
-    return;
+    return undefined;
+  }
+  if (TEXT_FIND_FACTORIES.has(factoryName)) return "text";
+  if (LONGTEXT_FIND_FACTORIES.has(factoryName)) return "longText";
+  if (NO_FIND_FACTORIES.has(factoryName)) return "none";
+  report(
+    subject.prop,
+    `unrecognized field factory "${factoryName}" — cannot verify its PersonalAnnotations shape`,
+  );
+  return undefined;
+}
+
+function personalFromTrueFlag(
+  personal: string,
+): (subject: SubjectProp) => PersonalInit | undefined {
+  return (subject) => {
+    if (isTrueLiteral(subject.prop.getInitializer())) return { personal, reason: undefined };
+    report(subject.prop, `${subject.name} is set to a non-\`true\` value — cannot infer intent`);
+    return undefined;
+  };
+}
+
+function personalFromAllowPlaintext(subject: SubjectProp): PersonalInit | undefined {
+  const init = subject.prop.getInitializer();
+  if (!init) {
+    report(subject.prop, "allowPlaintext has no value");
+    return undefined;
   }
+  const reason = Node.isStringLiteral(init)
+    ? `"${normalizeReasonSlug(init.getLiteralText())}"`
+    : init.getText();
+  return { personal: "false", reason };
+}
 
-  let personalInit: string;
-  let reasonInit: string | undefined;
-  if (subject.name === "pii") {
-    if (!isTrueLiteral(subject.prop.getInitializer())) {
-      report(subject.prop, "pii is set to a non-`true` value — cannot infer intent");
-      // skip: reported above — non-`true` pii value, can't infer intent
-      return;
-    }
-    personalInit = `"self"`;
-  } else if (subject.name === "tenantOwned") {
-    if (!isTrueLiteral(subject.prop.getInitializer())) {
-      report(subject.prop, "tenantOwned is set to a non-`true` value — cannot infer intent");
-      // skip: reported above — non-`true` tenantOwned value, can't infer intent
-      return;
-    }
-    personalInit = `"tenant"`;
-  } else if (subject.name === "subjectRef") {
-    if (!isTrueLiteral(subject.prop.getInitializer())) {
-      report(subject.prop, "subjectRef is set to a non-`true` value — cannot infer intent");
-      // skip: reported above — non-`true` subjectRef value, can't infer intent
-      return;
-    }
-    personalInit = `"ref"`;
-  } else if (subject.name === "allowPlaintext") {
-    const init = subject.prop.getInitializer();
-    if (!init) {
-      report(subject.prop, "allowPlaintext has no value");
-      // skip: reported above — allowPlaintext has no value to migrate
-      return;
-    }
-    personalInit = "false";
-    reasonInit = Node.isStringLiteral(init)
-      ? `"${normalizeReasonSlug(init.getLiteralText())}"`
-      : init.getText();
-  } else {
-    const init = subject.prop.getInitializer();
-    if (!init || !Node.isObjectLiteralExpression(init)) {
-      report(subject.prop, "userOwned value is not an object literal — cannot extract ownerField");
-      // skip: reported above — userOwned value isn't an object literal, can't extract ownerField
-      return;
-    }
-    const ownerFieldProp = findProp(init, "ownerField");
-    const ownerFieldInit = ownerFieldProp?.getInitializer();
-    if (!ownerFieldInit) {
-      report(subject.prop, 'userOwned is missing an "ownerField" property');
-      // skip: reported above — userOwned is missing its ownerField property
-      return;
-    }
-    personalInit = `{ of: ${ownerFieldInit.getText()} }`;
+function personalFromUserOwned(subject: SubjectProp): PersonalInit | undefined {
+  const init = subject.prop.getInitializer();
+  if (!init || !Node.isObjectLiteralExpression(init)) {
+    report(subject.prop, "userOwned value is not an object literal — cannot extract ownerField");
+    return undefined;
+  }
+  const ownerFieldInit = findProp(init, "ownerField")?.getInitializer();
+  if (!ownerFieldInit) {
+    report(subject.prop, 'userOwned is missing an "ownerField" property');
+    return undefined;
   }
+  return { personal: `{ of: ${ownerFieldInit.getText()} }`, reason: undefined };
+}
 
-  const subjectIsRefOrPlaintext =
-    subject.name === "subjectRef" || subject.name === "allowPlaintext";
+// One row per subject flag of the mapping table in the file header; a row
+// reports and returns undefined when the flag value cannot be mapped.
+const PERSONAL_INIT_BY_SUBJECT: Record<
+  SubjectFlagName,
+  (subject: SubjectProp) => PersonalInit | undefined
+> = {
+  pii: personalFromTrueFlag(`"self"`),
+  userOwned: personalFromUserOwned,
+  tenantOwned: personalFromTrueFlag(`"tenant"`),
+  subjectRef: personalFromTrueFlag(`"ref"`),
+  allowPlaintext: personalFromAllowPlaintext,
+};
 
-  if (subjectIsRefOrPlaintext) {
-    // These PersonalAnnotations arms carry no `find` field at all.
-    if (lookupableProp) {
-      report(
-        lookupableProp,
-        `lookupable combined with personal:${subject.name === "subjectRef" ? '"ref"' : "false"} — findability doesn't apply to this subject, table has no mapping`,
-      );
-      // skip: reported above — lookupable doesn't apply to this subject, no mapping to migrate
-      return;
-    }
-    applyTransform(obj, [subject.prop], {
-      personal: personalInit,
-      reason: reasonInit,
-      find: undefined,
-    });
-    counts[subject.name === "subjectRef" ? "ref" : "personal-false"]++;
-    // skip: already transformed above — nothing left to check for this subject
+// These PersonalAnnotations arms carry no `find` field at all.
+function migrateFindlessSubject(
+  obj: ObjectLiteralExpression,
+  subject: SubjectProp,
+  personal: PersonalInit,
+  lookupableProp: PropertyAssignment | undefined,
+): void {
+  const isRef = subject.name === "subjectRef";
+  if (lookupableProp) {
+    report(
+      lookupableProp,
+      `lookupable combined with personal:${isRef ? '"ref"' : "false"} — findability doesn't apply to this subject, table has no mapping`,
+    );
+    // skip: reported above — lookupable doesn't apply to this subject, no mapping to migrate
     return;
   }
+  applyTransform(obj, [subject.prop], {
+    personal: personal.personal,
+    reason: personal.reason,
+    find: undefined,
+  });
+  counts[isRef ? "ref" : "personal-false"]++;
+}
 
-  if (isNoFind) {
-    const stray = lookupableProp ?? searchableProp ?? sensitiveProp;
-    if (stray) {
-      report(
-        stray,
-        `${factoryName} has no \`find\` in its PersonalAnnotations — findability flag present on a non-text field`,
-      );
-      // skip: reported above — findability flag on a non-text field, no valid find to attach
-      return;
-    }
-    applyTransform(obj, [subject.prop], {
-      personal: personalInit,
-      reason: undefined,
-      find: undefined,
-    });
-    counts["no-find"]++;
-    // skip: already transformed above — no-find factory has nothing further to check
+function migrateNoFindField(
+  obj: ObjectLiteralExpression,
+  factoryName: string,
+  subject: SubjectProp,
+  personal: PersonalInit,
+  findability: FindabilityProps,
+): void {
+  const stray = findability.lookupable ?? findability.searchable ?? findability.sensitive;
+  if (stray) {
+    report(
+      stray,
+      `${factoryName} has no \`find\` in its PersonalAnnotations — findability flag present on a non-text field`,
+    );
+    // skip: reported above — findability flag on a non-text field, no valid find to attach
     return;
   }
+  applyTransform(obj, [subject.prop], {
+    personal: personal.personal,
+    reason: undefined,
+    find: undefined,
+  });
+  counts["no-find"]++;
+}
 
-  const hasLookupable = !!lookupableProp;
-  const hasSearchable = !!searchableProp;
-  const hasSensitive = !!sensitiveProp;
+// lookupable + searchable and searchable alone both map to "fuzzy".
+function findValueOf(findability: FindabilityProps): "exact" | "fuzzy" | "none" | "secret" {
+  if (findability.sensitive) return "secret";
+  if (findability.searchable) return "fuzzy";
+  if (findability.lookupable) return "exact";
+  return "none";
+}
 
-  if (sensitiveProp && (hasLookupable || hasSearchable)) {
+function migrateTextFindField(
+  obj: ObjectLiteralExpression,
+  subject: SubjectProp,
+  personal: PersonalInit,
+  findability: FindabilityProps,
+  support: Exclude<FindSupport, "none">,
+): void {
+  const { lookupable, searchable, sensitive } = findability;
+  if (sensitive && (lookupable || searchable)) {
     report(
-      sensitiveProp,
+      sensitive,
       'sensitive combined with lookupable/searchable — two find values ("secret" vs "exact"/"fuzzy"), needs a human decision',
     );
     // skip: reported above — sensitive plus lookupable/searchable is an ambiguous find value
     return;
   }
 
-  let find: "exact" | "fuzzy" | "none" | "secret";
-  if (hasSensitive) find = "secret";
-  else if (hasLookupable && hasSearchable) find = "fuzzy";
-  else if (hasLookupable) find = "exact";
-  else if (hasSearchable) find = "fuzzy";
-  else find = "none";
-
-  if (isLongTextFind && (find === "exact" || find === "fuzzy")) {
-    const findSite = lookupableProp ?? searchableProp;
+  const find = findValueOf(findability);
+  if (support === "longText" && (find === "exact" || find === "fuzzy")) {
+    const findSite = lookupable ?? searchable;
     if (findSite) {
       report(
         findSite,
@@ -379,7 +380,7 @@ function processObjectLiteral(obj: ObjectLiteralExpression, factoryName: string)
   // searchable-alone -> "fuzzy" makes expandPersonalAnnotations add
   // `lookupable: true`, which the field didn't carry before — that's a
   // new `_bidx` column (DDL migration), tracked separately for the report.
-  if (hasSearchable && !hasLookupable) {
+  if (searchable && !lookupable) {
     newLookupableSites.push({
       file: obj.getSourceFile().getFilePath(),
       line: subject.prop.getStartLineNumber(),
@@ -388,13 +389,51 @@ function processObjectLiteral(obj: ObjectLiteralExpression, factoryName: string)
     });
   }
 
-  const removedProps = [subject.prop, lookupableProp, searchableProp, sensitiveProp].filter(
+  const removedProps = [subject.prop, lookupable, searchable, sensitive].filter(
     (p): p is PropertyAssignment => !!p,
   );
-  applyTransform(obj, removedProps, { personal: personalInit, reason: undefined, find });
+  applyTransform(obj, removedProps, { personal: personal.personal, reason: undefined, find });
   counts[find]++;
 }
 
+function processObjectLiteral(obj: ObjectLiteralExpression, factoryName: string): void {
+  // skip: field already carries `personal` — already migrated, idempotent no-op
+  if (obj.getProperty("personal")) return;
+
+  const piiEncryptedProp = obj.getProperty("piiEncrypted");
+  if (piiEncryptedProp) {
+    report(
+      piiEncryptedProp,
+      "piiEncrypted: true on an entity field (removed from the type system) — needs a human decision, not a mechanical mapping",
+    );
+    // skip: reported above — piiEncrypted needs a human decision, not a mechanical mapping
+    return;
+  }
+
+  const subject = singleSubjectFlag(obj);
+  // skip: no subject flag, or several, reported by singleSubjectFlag where needed
+  if (!subject) return;
+  const support = findSupportOf(factoryName, subject);
+  // skip: factory without a verifiable PersonalAnnotations shape, reported by findSupportOf
+  if (!support) return;
+  const personal = PERSONAL_INIT_BY_SUBJECT[subject.name](subject);
+  // skip: flag value cannot be mapped, reported by its PERSONAL_INIT_BY_SUBJECT row
+  if (!personal) return;
+
+  const findability: FindabilityProps = {
+    lookupable: findProp(obj, "lookupable"),
+    searchable: findProp(obj, "searchable"),
+    sensitive: findProp(obj, "sensitive"),
+  };
+  if (subject.name === "subjectRef" || subject.name === "allowPlaintext") {
+    migrateFindlessSubject(obj, subject, personal, findability.lookupable);
+  } else if (support === "none") {
+    migrateNoFindField(obj, factoryName, subject, personal, findability);
+  } else {
+    migrateTextFindField(obj, subject, personal, findability, support);
+  }
+}
+
 function applyTransform(
   obj: ObjectLiteralExpression,
   removedProps: readonly PropertyAssignment[],
@@ -411,7 +450,9 @@ function applyTransform(
   const removedSet = new Set<PropertyAssignment>(removedProps);
   let insertIndex = 0;
   for (let i = 0; i < anchorIndex; i++) {
-    if (!removedSet.has(properties[i] as PropertyAssignment)) insertIndex++;
+    const property = properties[i];
+    if (!(property && Node.isPropertyAssignment(property) && removedSet.has(property)))
+      insertIndex++;
   }
 
   for (const p of removedProps) p.remove();
@@ -746,9 +787,7 @@ async function main(): Promise<void> {
 
     const countsBefore = { ...counts };
     for (const { name, objArg } of calls) processObjectLiteral(objArg, name);
-    const changed = (Object.keys(counts) as FindBucket[]).some(
-      (k) => counts[k] !== countsBefore[k],
-    );
+    const changed = FIND_BUCKETS.some((k) => counts[k] !== countsBefore[k]);
 
     if (changed) {
       touchedFiles++;

package/src/scripts/codemod/testing-injection.ts

@@ -12,7 +12,14 @@
 // Without a mode flag it writes (kumiko-upgrade --apply calls it that way). --check exits 1
 // while any rewritable or manual site is left; --dry-run only reports.
 
-import { type ImportDeclaration, Project, SyntaxKind } from "ts-morph";
+import {
+  type ExportDeclaration,
+  type ExportSpecifier,
+  type ImportDeclaration,
+  type ImportSpecifier,
+  Project,
+  SyntaxKind,
+} from "ts-morph";
 import {
   type CodemodResult,
   ensureNamedImport,
@@ -64,6 +71,115 @@ function reportNamespaceUses(
   }
 }
 
+function reportStarReexport(
+  declaration: ExportDeclaration,
+  filePath: string,
+  result: SiteLists,
+): void {
+  result.manual.push({
+    file: filePath,
+    line: declaration.getStartLineNumber(),
+    description: `export * from ${declaration.getModuleSpecifierValue()}: re-export the moved names from ${TARGET_MODULE} by hand`,
+  });
+}
+
+function moveNamedReexports(
+  declaration: ExportDeclaration,
+  movedExports: readonly ExportSpecifier[],
+  filePath: string,
+  result: SiteLists,
+): void {
+  const line = declaration.getStartLineNumber();
+  const snapshots = movedExports.map((named) => ({
+    name: named.getName(),
+    alias: named.getAliasNode()?.getText(),
+    isTypeOnly: named.isTypeOnly(),
+  }));
+  for (const named of movedExports) named.remove();
+  const typeOnlyDeclaration = declaration.isTypeOnly();
+  if (declaration.getNamedExports().length === 0) declaration.remove();
+  declaration.getSourceFile().addExportDeclaration({
+    moduleSpecifier: TARGET_MODULE,
+    namedExports: snapshots,
+    isTypeOnly: typeOnlyDeclaration,
+  });
+  result.rewrites.push({
+    file: filePath,
+    line,
+    description: `export { ${snapshots.map((snapshot) => snapshot.name).join(", ")} } -> ${TARGET_MODULE}`,
+  });
+}
+
+function rewriteReexports(
+  declaration: ExportDeclaration,
+  moved: ReadonlySet<string>,
+  filePath: string,
+  result: SiteLists,
+): void {
+  const namedExports = declaration.getNamedExports();
+  const movedExports = namedExports.filter((named) => moved.has(named.getName()));
+  if (namedExports.length === 0) reportStarReexport(declaration, filePath, result);
+  else if (movedExports.length > 0) moveNamedReexports(declaration, movedExports, filePath, result);
+}
+
+function moveNamedImports(
+  declaration: ImportDeclaration,
+  movedImports: readonly ImportSpecifier[],
+  filePath: string,
+  result: SiteLists,
+): void {
+  const line = declaration.getStartLineNumber();
+  const typeOnlyDeclaration = declaration.isTypeOnly();
+  const sourceFile = declaration.getSourceFile();
+  const names = movedImports.map((named) => named.getName());
+  // Collected first: removing a specifier invalidates the nodes of its siblings.
+  const snapshots = movedImports.map((named) => ({
+    name: named.getName(),
+    alias: named.getAliasNode()?.getText(),
+    typeOnly: named.isTypeOnly(),
+  }));
+  for (const named of movedImports) named.remove();
+  if (
+    declaration.getNamedImports().length === 0 &&
+    declaration.getNamespaceImport() === undefined &&
+    declaration.getDefaultImport() === undefined
+  ) {
+    declaration.remove();
+  }
+  for (const snapshot of snapshots) {
+    const typeOnly = typeOnlyDeclaration || snapshot.typeOnly;
+    if (snapshot.alias === undefined) {
+      ensureNamedImport(sourceFile, TARGET_MODULE, snapshot.name, typeOnly);
+    } else {
+      sourceFile.addImportDeclaration({
+        moduleSpecifier: TARGET_MODULE,
+        namedImports: [{ name: snapshot.name, alias: snapshot.alias }],
+        isTypeOnly: typeOnly,
+      });
+    }
+  }
+  result.rewrites.push({
+    file: filePath,
+    line,
+    description: `${names.join(", ")} -> ${TARGET_MODULE}`,
+  });
+}
+
+function rewriteImportDeclaration(
+  declaration: ImportDeclaration,
+  filePath: string,
+  result: SiteLists,
+): void {
+  const moved = movedNamesOf(declaration);
+  if (moved !== undefined) {
+    reportNamespaceUses(declaration, moved, filePath, result);
+    const movedImports = declaration
+      .getNamedImports()
+      .filter((named) => moved.has(named.getName()));
+    if (movedImports.length > 0) moveNamedImports(declaration, movedImports, filePath, result);
+  }
+}
+
 export function transformTestingInjectionSource(
   source: string,
   filePath = "source.ts",
@@ -77,47 +193,11 @@ export function transformTestingInjectionSource(
   });
   const sourceFile = project.createSourceFile(filePath, source);
   for (const declaration of sourceFile.getImportDeclarations()) {
-    const moved = movedNamesOf(declaration);
-    if (moved === undefined) continue;
-    reportNamespaceUses(declaration, moved, filePath, result);
-    const movedImports = declaration
-      .getNamedImports()
-      .filter((named) => moved.has(named.getName()));
-    if (movedImports.length === 0) continue;
-    const line = declaration.getStartLineNumber();
-    const typeOnlyDeclaration = declaration.isTypeOnly();
-    const names = movedImports.map((named) => named.getName());
-    // Collected first: removing a specifier invalidates the nodes of its siblings.
-    const snapshots = movedImports.map((named) => ({
-      name: named.getName(),
-      alias: named.getAliasNode()?.getText(),
-      typeOnly: named.isTypeOnly(),
-    }));
-    for (const named of movedImports) named.remove();
-    if (
-      declaration.getNamedImports().length === 0 &&
-      declaration.getNamespaceImport() === undefined &&
-      declaration.getDefaultImport() === undefined
-    ) {
-      declaration.remove();
-    }
-    for (const snapshot of snapshots) {
-      const typeOnly = typeOnlyDeclaration || snapshot.typeOnly;
-      if (snapshot.alias === undefined) {
-        ensureNamedImport(sourceFile, TARGET_MODULE, snapshot.name, typeOnly);
-      } else {
-        sourceFile.addImportDeclaration({
-          moduleSpecifier: TARGET_MODULE,
-          namedImports: [{ name: snapshot.name, alias: snapshot.alias }],
-          isTypeOnly: typeOnly,
-        });
-      }
-    }
-    result.rewrites.push({
-      file: filePath,
-      line,
-      description: `${names.join(", ")} -> ${TARGET_MODULE}`,
-    });
+    rewriteImportDeclaration(declaration, filePath, result);
+  }
+  for (const declaration of sourceFile.getExportDeclarations()) {
+    const moved = MOVED_NAMES_BY_MODULE.get(declaration.getModuleSpecifierValue() ?? "");
+    if (moved !== undefined) rewriteReexports(declaration, moved, filePath, result);
   }
   const output = result.rewrites.length > 0 ? sourceFile.getFullText() : source;
   return { output, ...result };