akanjs 2.0.7 → 2.1.0-rc.0

package/devkit/transforms/barrelAnalyzer.ts

@@ -1,249 +0,0 @@
-import path from "node:path";
-import { Logger } from "akanjs/common";
-
-export interface BarrelExportTarget {
-  /** Subpath specifier to emit in rewritten import, e.g. `akanjs/ui/Empty`. */
-  subpath: string;
-  /** Name as it is exported by the leaf module. */
-  originalName: string;
-}
-
-export type BarrelExportMap = Map<string, BarrelExportTarget>;
-
-export interface PackageEntry {
-  /** Package specifier (e.g. `akanjs/ui`). */
-  pkgName: string;
-  /** Absolute path of the barrel entry file. */
-  entryFile: string;
-  /** Absolute directory used as the base for subpath computation. Typically dirname(entryFile). */
-  pkgDir: string;
-  /** Preserve concrete file paths for package exports that do not support extensionless deep imports. */
-  preserveFilePath?: boolean;
-}
-
-export interface BarrelAnalyzerOptions {
-  resolvePackage: (pkgName: string) => Promise<PackageEntry | null>;
-  /** Resolve a relative specifier from `fromFile` to an absolute file path on disk. */
-  resolveRelative?: (fromFile: string, relSpec: string) => Promise<string | null>;
-}
-
-const REEXPORT_RE =
-  /(?:^|\n)\s*export\s+(?:type\s+)?(?:(\*)(?:\s+as\s+(\w+))?|\{\s*([^}]*?)\s*\})\s+from\s+(["'])([^"']+)\4;?/g;
-
-const LOCAL_NAMED_RE = /(?:^|\n)\s*export\s+\{\s*([^}]*?)\s*\}(?!\s*from)/g;
-
-const CANDIDATE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-
-export class BarrelAnalyzer {
-  readonly #logger = new Logger("BarrelAnalyzer");
-  readonly #opts: BarrelAnalyzerOptions;
-  readonly #cache = new Map<string, Promise<BarrelExportMap | null>>();
-  readonly #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
-  readonly #tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
-
-  constructor(opts: BarrelAnalyzerOptions) {
-    this.#opts = opts;
-  }
-
-  analyze(pkgName: string): Promise<BarrelExportMap | null> {
-    const cached = this.#cache.get(pkgName);
-    if (cached) return cached;
-    const promise = this.#analyzeSafe(pkgName);
-    this.#cache.set(pkgName, promise);
-    return promise;
-  }
-
-  async #analyzeSafe(pkgName: string): Promise<BarrelExportMap | null> {
-    try {
-      return await this.#analyzeUncached(pkgName);
-    } catch (err) {
-      this.#logger.error(`analyze failed for ${pkgName}: ${(err as Error).message}`);
-      return null;
-    }
-  }
-
-  async #analyzeUncached(pkgName: string): Promise<BarrelExportMap | null> {
-    const pkg = await this.#opts.resolvePackage(pkgName);
-    if (!pkg) return null;
-    const map: BarrelExportMap = new Map();
-    const visited = new Set<string>();
-    await this.#walk(pkg.entryFile, pkg, map, visited);
-    return map;
-  }
-
-  async #walk(absFile: string, pkg: PackageEntry, map: BarrelExportMap, visited: Set<string>): Promise<void> {
-    if (visited.has(absFile)) return;
-    visited.add(absFile);
-    const source = await readIfExists(absFile);
-    if (source === null) return;
-    const currentSubpath = this.#subpathFor(pkg, absFile);
-    if (!currentSubpath) return;
-
-    const authoritative = this.#scanExports(source, absFile);
-
-    authoritative.delete("default");
-
-    const attributed = new Set<string>();
-
-    REEXPORT_RE.lastIndex = 0;
-    let m: RegExpExecArray | null = REEXPORT_RE.exec(source);
-    while (m !== null) {
-      const star = m[1];
-      const nsAs = m[2];
-      const namedList = m[3];
-      const spec = m[5] ?? "";
-      m = REEXPORT_RE.exec(source);
-      if (!isRelative(spec)) continue;
-
-      if (star) {
-        if (nsAs) {
-
-          authoritative.delete(nsAs);
-          continue;
-        }
-        const targetAbs = await this.#resolveRel(absFile, spec);
-        if (!targetAbs) continue;
-
-        await this.#walk(targetAbs, pkg, map, visited);
-        continue;
-      }
-
-      if (namedList !== undefined) {
-        const targetAbs = await this.#resolveRel(absFile, spec);
-        if (!targetAbs) continue;
-        const targetSubpath = this.#subpathFor(pkg, targetAbs);
-        if (!targetSubpath) continue;
-        for (const item of parseNamedList(namedList)) {
-          if (item.isType) continue;
-          if (item.imported === "default") continue;
-
-          if (!authoritative.has(item.local)) continue;
-          attributed.add(item.local);
-          if (!map.has(item.local)) {
-            map.set(item.local, { subpath: targetSubpath, originalName: item.imported });
-          }
-        }
-      }
-    }
-
-    LOCAL_NAMED_RE.lastIndex = 0;
-    let n: RegExpExecArray | null = LOCAL_NAMED_RE.exec(source);
-    while (n !== null) {
-      const body = n[1] ?? "";
-      n = LOCAL_NAMED_RE.exec(source);
-      for (const item of parseNamedList(body)) {
-        if (item.isType) continue;
-        if (item.imported === "default") continue;
-
-        if (!authoritative.has(item.local)) continue;
-        attributed.add(item.local);
-        if (!map.has(item.local)) {
-          map.set(item.local, { subpath: currentSubpath, originalName: item.imported });
-        }
-      }
-    }
-
-    for (const name of authoritative) {
-      if (attributed.has(name)) continue;
-      if (map.has(name)) continue;
-      map.set(name, { subpath: currentSubpath, originalName: name });
-    }
-  }
-
-  #scanExports(source: string, absFile: string): Set<string> {
-    try {
-      const transpiler = [".tsx", ".jsx"].includes(path.extname(absFile)) ? this.#tsxTranspiler : this.#tsTranspiler;
-      const { exports } = transpiler.scan(source);
-      return new Set(exports);
-    } catch (err) {
-      this.#logger.error(`scan failed: ${(err as Error).message}`);
-      return new Set();
-    }
-  }
-
-  #subpathFor(pkg: PackageEntry, absFile: string): string | null {
-    const rel = path.relative(pkg.pkgDir, absFile);
-    if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return null;
-    if (pkg.preserveFilePath) return `${pkg.pkgName}/${rel.split(path.sep).join("/")}`;
-    const noExt = stripKnownExt(rel);
-
-    const tail = collapseIndex(noExt);
-    if (tail === "") return pkg.pkgName;
-    return `${pkg.pkgName}/${tail.split(path.sep).join("/")}`;
-  }
-
-  async #resolveRel(fromFile: string, relSpec: string): Promise<string | null> {
-    if (this.#opts.resolveRelative) return this.#opts.resolveRelative(fromFile, relSpec);
-    return defaultResolveRelative(fromFile, relSpec);
-  }
-}
-
-interface NamedItem {
-  imported: string;
-  local: string;
-  isType: boolean;
-}
-
-const parseNamedList = (listBody: string): NamedItem[] => {
-  const out: NamedItem[] = [];
-  for (const raw of listBody.split(",")) {
-    const s = raw.trim();
-    if (!s) continue;
-    let rest = s;
-    let isType = false;
-    if (rest.startsWith("type ")) {
-      isType = true;
-      rest = rest.slice(5).trim();
-    }
-    const asMatch = /^(\w+)\s+as\s+(\w+)$/.exec(rest);
-    if (asMatch) {
-      out.push({ imported: asMatch[1] ?? "", local: asMatch[2] ?? "", isType });
-      continue;
-    }
-    if (/^\w+$/.test(rest)) {
-      out.push({ imported: rest, local: rest, isType });
-    }
-  }
-  return out;
-};
-
-const isRelative = (spec: string): boolean => {
-  return spec.startsWith("./") || spec.startsWith("../") || spec === "." || spec === "..";
-};
-
-const readIfExists = async (absFile: string): Promise<string | null> => {
-  const file = Bun.file(absFile);
-  if (!(await file.exists())) return null;
-  return file.text();
-};
-
-const defaultResolveRelative = async (fromFile: string, relSpec: string): Promise<string | null> => {
-  const baseDir = path.dirname(fromFile);
-  const joined = path.resolve(baseDir, relSpec);
-  if (path.extname(joined)) {
-    if (await Bun.file(joined).exists()) return joined;
-    return null;
-  }
-  for (const ext of CANDIDATE_EXTS) {
-    const cand = joined + ext;
-    if (await Bun.file(cand).exists()) return cand;
-  }
-  for (const ext of CANDIDATE_EXTS) {
-    const cand = path.join(joined, `index${ext}`);
-    if (await Bun.file(cand).exists()) return cand;
-  }
-  return null;
-};
-
-const stripKnownExt = (relPath: string): string => {
-  for (const ext of CANDIDATE_EXTS) {
-    if (relPath.endsWith(ext)) return relPath.slice(0, -ext.length);
-  }
-  return relPath;
-};
-
-const collapseIndex = (relPathNoExt: string): string => {
-  const parts = relPathNoExt.split(path.sep);
-  if (parts[parts.length - 1] === "index") parts.pop();
-  return parts.join(path.sep);
-};

package/devkit/transforms/barrelImportsPlugin.ts

@@ -1,457 +0,0 @@
-import path from "node:path";
-import type { BunPlugin } from "bun";
-import ts from "typescript";
-import type { App } from "../commandDecorators";
-import { BarrelAnalyzer, type BarrelExportMap, type PackageEntry } from "./barrelAnalyzer";
-
-export interface BarrelImportsPluginOptions {
-  /** Absolute paths whose content should be returned unchanged (e.g. node_modules). */
-  skipPath?: (absPath: string) => boolean;
-  /**
-   * Optional transform applied after the barrel rewrite in the same onLoad
-   * pass. Useful to chain further transforms (e.g. `"use client"` stubbing)
-   * that would otherwise be blocked — Bun's `onLoad` cannot fall through to a
-   * second plugin once a response is returned.
-   * Return the transformed source, or `null` to indicate no change.
-   */
-  pipeAfter?: (source: string, args: { path: string }) => string | Promise<string | null> | null;
-}
-
-export const createBarrelImportsPlugin = async (
-  app: App,
-  { skipPath = defaultSkipPath, pipeAfter }: BarrelImportsPluginOptions = {},
-): Promise<BunPlugin> => {
-  const akanConfig = await app.getConfig();
-  const barrels = [...new Set(akanConfig.barrelImports)].filter(Boolean);
-  const analyzer = new BarrelAnalyzer({
-    resolvePackage: await createTsconfigPackageResolver(app),
-  });
-
-  return {
-    name: "barrel-imports",
-    setup(build) {
-
-      build.onLoad(
-        {
-          filter:
-            /^(?:(?!.*[\\/]node_modules[\\/]).*|.*[\\/]node_modules[\\/]akanjs[\\/].*)\.(tsx|ts|jsx|js)(\?v=\d+)?$/,
-        },
-        async (args) => {
-          const realPath = args.path.replace(/\?v=\d+$/, "");
-          const loader = loaderFor(realPath);
-          if (skipPath(realPath)) {
-            const raw = await Bun.file(realPath).text();
-            return { contents: raw, loader };
-          }
-
-          let source = await Bun.file(realPath).text();
-
-          const hasMacroAttr = MACRO_ATTR_RE.test(source);
-
-          if (!hasMacroAttr && barrels.length > 0) {
-            
-            let maybe = false;
-            for (const b of barrels) {
-              if (source.includes(b)) {
-                maybe = true;
-                break;
-              }
-            }
-            if (maybe) {
-              const rewritten = await rewriteBarrelImports(source, barrels, analyzer);
-              if (rewritten !== null) source = rewritten;
-            }
-          }
-
-          if (pipeAfter) {
-            const piped = await pipeAfter(source, { path: realPath });
-            if (piped !== null) source = piped;
-          }
-
-          return { contents: source, loader };
-        },
-      );
-    },
-  };
-};
-
-/**
- * Build a `resolvePackage` that maps a package specifier (like `akanjs/ui`)
- * to its barrel entry file using the workspace tsconfig `paths`. If no direct
- * mapping exists, falls back to node_modules resolution.
- */
-export const createTsconfigPackageResolver = async (
-  app: App,
-): Promise<(pkgName: string) => Promise<PackageEntry | null>> => {
-  const tsconfig = await app.getTsConfig();
-  const tsconfigPaths = tsconfig.compilerOptions.paths ?? {};
-
-  const wildcardEntries = Object.entries(tsconfigPaths)
-    .filter(([k]) => k.endsWith("/*"))
-    .map(([k, v]) => ({
-      prefix: k.slice(0, -1), // keep trailing `/`
-      replacements: v,
-    }))
-    .sort((a, b) => b.prefix.length - a.prefix.length);
-
-  return async (pkgName) => {
-    const exact = tsconfigPaths[pkgName];
-    if (exact && exact.length > 0) {
-      const raw = exact[0];
-      if (!raw) return null;
-      const entryFile = path.resolve(app.workspace.workspaceRoot, raw);
-      if (!(await Bun.file(entryFile).exists())) return null;
-
-      const parsed = path.parse(entryFile);
-      const lastSlash = pkgName.lastIndexOf("/");
-      if (parsed.name !== "index" && lastSlash !== -1) {
-        const facet = pkgName.slice(lastSlash + 1);
-        const parentSpec = pkgName.slice(0, lastSlash);
-        if (facet === parsed.name && parentSpec.length > 0) {
-          return { pkgName: parentSpec, entryFile, pkgDir: parsed.dir };
-        }
-      }
-      return { pkgName, entryFile, pkgDir: path.dirname(entryFile) };
-    }
-
-    for (const { prefix, replacements } of wildcardEntries) {
-      if (!pkgName.startsWith(prefix)) continue;
-      const suffix = pkgName.slice(prefix.length);
-      for (const repl of replacements) {
-        if (!repl) continue;
-        const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
-        const candidate = path.resolve(app.workspace.workspaceRoot, replPath + suffix);
-
-        for (const ext of CANDIDATE_EXTS) {
-          const file = `${candidate}${ext}`;
-          if (await Bun.file(file).exists()) {
-            const lastSlash = pkgName.lastIndexOf("/");
-            if (lastSlash !== -1) {
-              const parentSpec = pkgName.slice(0, lastSlash);
-              if (parentSpec.length > 0) {
-                return { pkgName: parentSpec, entryFile: file, pkgDir: path.dirname(file) };
-              }
-            }
-            return { pkgName, entryFile: file, pkgDir: path.dirname(file) };
-          }
-        }
-        for (const ext of CANDIDATE_EXTS) {
-          const file = path.join(candidate, `index${ext}`);
-          if (await Bun.file(file).exists()) {
-            return { pkgName, entryFile: file, pkgDir: candidate };
-          }
-        }
-      }
-
-      return null;
-    }
-
-    const exported = await resolveNodePackageExport(app.workspace.workspaceRoot, pkgName);
-    if (exported) return exported;
-
-    const pkgJsonPath = path.join(app.workspace.workspaceRoot, "node_modules", pkgName, "package.json");
-    if (!(await Bun.file(pkgJsonPath).exists())) return null;
-    try {
-      const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text()) as {
-        main?: string;
-        module?: string;
-      };
-      const rel = pkgJson.module ?? pkgJson.main ?? "index.js";
-      const entryFile = path.resolve(path.dirname(pkgJsonPath), rel);
-      if (!(await Bun.file(entryFile).exists())) return null;
-      return { pkgName, entryFile, pkgDir: path.dirname(pkgJsonPath) };
-    } catch {
-      return null;
-    }
-  };
-};
-
-const CANDIDATE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-
-const NODE_MODULES_RE = /[\\/]node_modules[\\/]/;
-const AKANJS_NODE_MODULE_RE = /[\\/]node_modules[\\/]akanjs[\\/]/;
-const defaultSkipPath = (absPath: string) => NODE_MODULES_RE.test(absPath) && !AKANJS_NODE_MODULE_RE.test(absPath);
-
-type ExportValue = string | string[] | { [condition: string]: ExportValue | undefined };
-
-const resolveNodePackageExport = async (workspaceRoot: string, specifier: string): Promise<PackageEntry | null> => {
-  const packageName = getPackageName(specifier);
-  if (!packageName) return null;
-  const pkgJsonPath = path.join(workspaceRoot, "node_modules", packageName, "package.json");
-  if (!(await Bun.file(pkgJsonPath).exists())) return null;
-
-  try {
-    const pkgDir = path.dirname(pkgJsonPath);
-    const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text()) as {
-      exports?: Record<string, ExportValue>;
-      module?: string;
-      main?: string;
-    };
-    const subpath = specifier === packageName ? "." : `.${specifier.slice(packageName.length)}`;
-    const exported = resolvePackageExport(pkgJson.exports, subpath);
-    const rel = exported ?? (subpath === "." ? (pkgJson.module ?? pkgJson.main ?? "index.js") : null);
-    if (!rel || !rel.startsWith(".")) return null;
-    const entryFile = await resolveFileCandidate(path.resolve(pkgDir, rel));
-    if (!entryFile) return null;
-    const pkgEntryName = specifier;
-    return { pkgName: pkgEntryName, entryFile, pkgDir: path.dirname(entryFile), preserveFilePath: true };
-  } catch {
-    return null;
-  }
-};
-
-const resolveExportValue = (value: ExportValue | undefined): string | null => {
-  if (!value) return null;
-  if (typeof value === "string") return value;
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      const resolved = resolveExportValue(item);
-      if (resolved) return resolved;
-    }
-    return null;
-  }
-  for (const condition of ["source", "import", "default", "types"]) {
-    const resolved = resolveExportValue(value[condition]);
-    if (resolved) return resolved;
-  }
-  return null;
-};
-
-const resolvePackageExport = (exportsMap: Record<string, ExportValue> | undefined, subpath: string): string | null => {
-  if (!exportsMap) return null;
-  const exact = resolveExportValue(exportsMap[subpath]);
-  if (exact) return exact;
-
-  for (const [key, value] of Object.entries(exportsMap)) {
-    const starIdx = key.indexOf("*");
-    if (starIdx === -1) continue;
-    const prefix = key.slice(0, starIdx);
-    const suffix = key.slice(starIdx + 1);
-    if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix)) continue;
-    const wildcard = subpath.slice(prefix.length, subpath.length - suffix.length);
-    const resolved = resolveExportValue(value);
-    if (resolved) return resolved.replace("*", wildcard);
-  }
-
-  return null;
-};
-
-const getPackageName = (specifier: string): string | null => {
-  const parts = specifier.split("/");
-  if (!parts[0]) return null;
-  if (specifier.startsWith("@")) return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
-  return parts[0];
-};
-
-const resolveFileCandidate = async (candidate: string): Promise<string | null> => {
-  if (await Bun.file(candidate).exists()) return candidate;
-  if (path.extname(candidate)) return null;
-  for (const ext of CANDIDATE_EXTS) {
-    const file = `${candidate}${ext}`;
-    if (await Bun.file(file).exists()) return file;
-  }
-  for (const ext of CANDIDATE_EXTS) {
-    const file = path.join(candidate, `index${ext}`);
-    if (await Bun.file(file).exists()) return file;
-  }
-  return null;
-};
-
-const MACRO_ATTR_RE = /with\s*\{\s*type\s*:\s*["']macro["']\s*\}/;
-
-/** Exposed for testing. */
-export const rewriteBarrelImports = async (
-  source: string,
-  barrels: string[],
-  analyzer: BarrelAnalyzer,
-): Promise<string | null> => {
-  const statements = findImportStatements(source);
-  if (statements.length === 0) return null;
-
-  let changed = false;
-  let out = source;
-  for (let i = statements.length - 1; i >= 0; i--) {
-    const stmt = statements[i];
-    if (!stmt) continue;
-    if (!barrels.includes(stmt.specifier)) continue;
-    const map = await analyzer.analyze(stmt.specifier);
-    if (!map || map.size === 0) continue;
-    const replacement = rewriteSingleStatement(stmt, map);
-    if (replacement === null) continue;
-    out = out.slice(0, stmt.start) + replacement + out.slice(stmt.end);
-    changed = true;
-  }
-  return changed ? out : null;
-};
-
-interface ImportStatement {
-  start: number;
-  end: number;
-  clause: string;
-  specifier: string;
-  trailingSemicolon: boolean;
-  raw: string;
-}
-
-const findImportStatements = (source: string): ImportStatement[] => {
-  const statements: ImportStatement[] = [];
-  const sourceFile = ts.createSourceFile("barrel-imports.tsx", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
-  for (const statement of sourceFile.statements) {
-    if (!ts.isImportDeclaration(statement)) continue;
-    if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
-    const importClause = statement.importClause;
-    if (!importClause) continue;
-    const statementStart = statement.getStart(sourceFile);
-    const statementEnd = statement.end;
-    statements.push({
-      start: statementStart,
-      end: statementEnd,
-      clause: source.slice(importClause.getStart(sourceFile), importClause.end).trim(),
-      specifier: statement.moduleSpecifier.text,
-      trailingSemicolon: source.slice(statement.moduleSpecifier.end, statement.end).includes(";"),
-      raw: source.slice(statementStart, statementEnd),
-    });
-  }
-  return statements;
-};
-
-interface NamedImportItem {
-  imported: string;
-  local: string;
-  isType: boolean;
-}
-
-interface ParsedClause {
-  defaultImport?: string;
-  namespaceImport?: string;
-  named?: NamedImportItem[];
-  /** Whole clause is `import type { ... } from "..."`. */
-  typeOnly: boolean;
-}
-
-const parseImportClause = (clause: string): ParsedClause | null => {
-  let rest = clause.trim();
-  let typeOnly = false;
-  if (rest.startsWith("type ")) {
-    typeOnly = true;
-    rest = rest.slice(5).trim();
-  }
-  const parsed: ParsedClause = { typeOnly };
-  
-  const commaMatch = /^(\w+)\s*,\s*(.+)$/.exec(rest);
-  if (commaMatch) {
-    parsed.defaultImport = commaMatch[1];
-    rest = commaMatch[2] ?? "";
-  } else if (/^\w+$/.test(rest)) {
-    parsed.defaultImport = rest;
-    return parsed;
-  }
-  if (rest.startsWith("*")) {
-    const ns = /^\*\s+as\s+(\w+)$/.exec(rest);
-    if (!ns) return null;
-    parsed.namespaceImport = ns[1];
-    return parsed;
-  }
-  if (rest.startsWith("{")) {
-    const close = rest.indexOf("}");
-    if (close === -1) return null;
-    const inner = rest.slice(1, close);
-    parsed.named = parseNamedImportList(inner);
-    return parsed;
-  }
-  return parsed;
-};
-
-const parseNamedImportList = (body: string): NamedImportItem[] => {
-  const out: NamedImportItem[] = [];
-  for (const raw of body.split(",")) {
-    const s = raw.trim();
-    if (!s) continue;
-    let isType = false;
-    let rest = s;
-    if (rest.startsWith("type ")) {
-      isType = true;
-      rest = rest.slice(5).trim();
-    }
-    const asMatch = /^(\w+)\s+as\s+(\w+)$/.exec(rest);
-    if (asMatch) {
-      out.push({ imported: asMatch[1] ?? "", local: asMatch[2] ?? "", isType });
-      continue;
-    }
-    if (/^\w+$/.test(rest)) {
-      out.push({ imported: rest, local: rest, isType });
-    }
-  }
-  return out;
-};
-
-const rewriteSingleStatement = (stmt: ImportStatement, map: BarrelExportMap): string | null => {
-  const clause = parseImportClause(stmt.clause);
-  if (!clause) return null;
-  
-  if (clause.namespaceImport) return null;
-  
-  if (clause.typeOnly && !clause.defaultImport) return null;
-  if (!clause.named || clause.named.length === 0) {
-    
-    return null;
-  }
-
-  const remaining: NamedImportItem[] = [];
-  const rewrites = new Map<string, NamedImportItem[]>();
-  for (const item of clause.named) {
-    if (item.isType) {
-      remaining.push(item);
-      continue;
-    }
-    const target = map.get(item.imported);
-    if (!target) {
-      remaining.push(item);
-      continue;
-    }
-    const list = rewrites.get(target.subpath) ?? [];
-    
-    list.push({ imported: target.originalName, local: item.local, isType: false });
-    rewrites.set(target.subpath, list);
-  }
-
-  if (rewrites.size === 0) return null;
-
-  const lines: string[] = [];
-  
-  const tail = ";";
-
-  if (shouldPreserveBarrelSideEffects(stmt.specifier)) {
-    lines.push(`import "${stmt.specifier}"${tail}`);
-  }
-
-  if (clause.defaultImport || remaining.length > 0) {
-    const parts: string[] = [];
-    if (clause.defaultImport) parts.push(clause.defaultImport);
-    if (remaining.length > 0) {
-      parts.push(`{ ${remaining.map(serializeNamedItem).join(", ")} }`);
-    }
-    lines.push(`import ${parts.join(", ")} from "${stmt.specifier}"${tail}`);
-  }
-
-  for (const [subpath, items] of rewrites) {
-    lines.push(`import { ${items.map(serializeNamedItem).join(", ")} } from "${subpath}"${tail}`);
-  }
-
-  return lines.join("\n");
-};
-
-const shouldPreserveBarrelSideEffects = (specifier: string): boolean => /^@(apps|libs)\/[^/]+\/client$/.test(specifier);
-
-const serializeNamedItem = (item: NamedImportItem): string => {
-  const prefix = item.isType ? "type " : "";
-  if (item.imported === item.local) return `${prefix}${item.imported}`;
-  return `${prefix}${item.imported} as ${item.local}`;
-};
-
-const loaderFor = (absPath: string): "ts" | "tsx" | "js" | "jsx" => {
-  if (absPath.endsWith(".tsx")) return "tsx";
-  if (absPath.endsWith(".jsx")) return "jsx";
-  if (absPath.endsWith(".ts")) return "ts";
-  return "js";
-};