@nifrajs/cli 5.0.0 → 5.1.0

package/src/dev-feed-tool.ts

@@ -793,6 +793,117 @@ export const logsSpec: CommandSpec<LogsInput, LogsOutput> = {
   json: (out) => out,
 }
 
+export interface ExplainInput {
+  readonly error?: string | undefined
+  readonly stack?: string | undefined
+  readonly name?: string | undefined
+  readonly port?: number | undefined
+  readonly dir?: string | undefined
+  readonly json?: boolean | undefined
+}
+
+/** A diagnostic, or `NIFRA_NONE` with why there was nothing to explain. */
+export type ExplainOutput =
+  | (Diagnostic & { readonly entry?: object; readonly note?: string })
+  | { code: "NIFRA_NONE"; message: string }
+
+const explained = (out: ExplainOutput): out is Diagnostic => out.code !== "NIFRA_NONE"
+
+export const explainSpec: CommandSpec<ExplainInput, ExplainOutput> = {
+  name: "explain",
+  summary:
+    "Turn an error into a structured diagnostic: its code, the frame in your source with a codeframe, and the cause and fix when nifra recognises it. With no message, the running dev server's latest error.",
+  input: {
+    jsonSchema: {
+      type: "object",
+      properties: {
+        error: { type: "string", description: "The error message to explain." },
+        stack: {
+          type: "string",
+          description: "Its stack trace, for the codeframe and source frame.",
+        },
+        name: { type: "string", description: "Its class name, such as TypeError." },
+        port: SHARED_PROPERTIES.port,
+        dir: { type: "string", description: "The app directory." },
+        json: { type: "boolean" },
+      },
+      additionalProperties: false,
+    },
+    parse: (value) => {
+      const raw = fields(value)
+      return {
+        error: text(raw, "error"),
+        stack: text(raw, "stack"),
+        name: text(raw, "name"),
+        port: count(raw, "port"),
+        dir: text(raw, "dir"),
+        json: flag(raw, "json"),
+      }
+    },
+  },
+  output: {
+    version: 1,
+    jsonSchema: {
+      type: "object",
+      properties: { code: { type: "string" }, message: { type: "string" } },
+      required: ["code", "message"],
+    },
+    parse: (value) => {
+      if (isDiagnostic(value)) return value
+      if (
+        typeof value === "object" &&
+        value !== null &&
+        "code" in value &&
+        value.code === "NIFRA_NONE" &&
+        "message" in value &&
+        typeof value.message === "string"
+      )
+        return { code: "NIFRA_NONE", message: value.message }
+      throw new TypeError("explain output must be a diagnostic or NIFRA_NONE")
+    },
+  },
+  transports: ["cli"],
+  stability: "experimental",
+  argv: {
+    positionals: ["error"],
+    flags: [
+      { name: "stack", field: "stack", type: "string" },
+      { name: "name", field: "name", type: "string" },
+      { name: "port", field: "port", type: "number" },
+      { name: "dir", field: "dir", type: "string" },
+      { name: "json", field: "json", type: "boolean" },
+    ],
+  },
+  async run(input, ctx) {
+    const root = resolve(ctx.cwd, input.dir ?? ".")
+    if (input.error === undefined && input.stack === undefined) {
+      return explainLatest(root, input.port, ctx.signal)
+    }
+    const { buildDiagnostic } = await import("@nifrajs/web/diagnostic")
+    const { explainSourceGate } = await import("./mcp-exec.ts")
+    const error = new Error(input.error ?? "")
+    if (input.name !== undefined) error.name = input.name
+    // Without --stack the frames would be this command's own, not the app's.
+    error.stack = input.stack ?? `${error.name}: ${error.message}`
+    return buildDiagnostic(error, { root, showSource: explainSourceGate(root) })
+  },
+  render: (out) => {
+    if (!explained(out)) return [out.message]
+    const at = topFrame(out)
+    return [
+      `${out.code}  ${headline(out)}`,
+      ...(at === undefined ? [] : [`  at ${at}`]),
+      ...(out.codeframe?.lines ?? []).map(
+        (line) => `  ${line.caret ? ">" : " "} ${String(line.number).padStart(4)} | ${line.text}`,
+      ),
+      ...(out.cause === undefined ? [] : [`  cause: ${out.cause}`]),
+      ...(out.fix === undefined ? [] : [`  fix: ${out.fix}`]),
+    ]
+  },
+  exitCode: (out) => (explained(out) ? 0 : 2),
+  json: (out) => out,
+}
+
 // ---------------------------------------------------------------------------------------------------
 // nifra_explain / nifra_inspect reads
 // ---------------------------------------------------------------------------------------------------
@@ -802,7 +913,7 @@ export async function explainLatest(
   cwd: string,
   port: number | undefined,
   signal?: AbortSignal,
-): Promise<unknown> {
+): Promise<ExplainOutput> {
   const { findDevServer, describeLookup, readDevFeed } = await import("./dev-server-client.ts")
   const lookup = await findDevServer(cwd, { port }, signal)
   if (lookup.status === "live") {

package/src/fix-recipes.ts

@@ -7,6 +7,8 @@ import { resolveWorkspaceLinkedPackage } from "./workspace-link.ts"
 export interface FixRecipe {
   readonly id: string
   readonly description: string
+  /** Run only by `nifra fix --code <code>`: the change it makes is a decision a person reviews first. */
+  readonly onlyWhenNamed?: true
   apply(root: string, diagnostic: Diagnostic): Promise<readonly string[]>
   readonly verify: string
 }
@@ -84,22 +86,39 @@ registerFixRecipe({
   description:
     "Serve the backend over HTTP at /api by exporting apiPrefix from the framework config.",
   verify: "nifra check",
-  async apply(root, diagnostic) {
-    if (diagnostic.file === undefined) return []
-    const path = await resolveInsideProject(root, diagnostic.file)
-    if (path === undefined) return []
-    const { withDefaultApiPrefix } = await import("./rules/pages.ts")
-    const file = Bun.file(path)
-    const next = withDefaultApiPrefix((await file.exists()) ? await file.text() : undefined)
-    if (next === undefined) return []
-    await writeFile(path, next, "utf8")
-    return [diagnostic.file]
+  async apply(root) {
+    const { CONFIG_FILE, FRAMEWORK_FILE } = await import("./app-files.ts")
+    const { apiPrefixFix } = await import("./rules/pages.ts")
+    const frameworkPath = await resolveInsideProject(root, FRAMEWORK_FILE)
+    const configPath = await resolveInsideProject(root, CONFIG_FILE)
+    if (frameworkPath === undefined || configPath === undefined) return []
+    const source = async (path: string): Promise<string | undefined> => {
+      const file = Bun.file(path)
+      return (await file.exists()) ? await file.text() : undefined
+    }
+    const next = apiPrefixFix({
+      framework: await source(frameworkPath),
+      config: await source(configPath),
+    })
+    const edits: readonly (readonly [string, string, string | undefined])[] = [
+      [FRAMEWORK_FILE, frameworkPath, next.framework],
+      [CONFIG_FILE, configPath, next.config],
+    ]
+    const changed: string[] = []
+    for (const [file, path, text] of edits) {
+      if (text === undefined) continue
+      await writeFile(path, text, "utf8")
+      changed.push(file)
+    }
+    return changed
   },
 })
 
 registerFixRecipe({
   id: "contracts.snapshot",
   description: "Refresh the opt-in contract lock after reviewing an intentional route change.",
+  // Rewriting the lock accepts whatever the routes changed to, which is the review the lock exists for.
+  onlyWhenNamed: true,
   verify: "nifra contracts check",
   async apply(root) {
     const { snapshotContracts } = await import("./contracts.ts")
@@ -158,6 +177,78 @@ registerFixRecipe({
   },
 })
 
+registerFixRecipe({
+  id: "route.split",
+  description:
+    "Move a route frontend file's server-only exports, and the code only they use, into its x.backend.ts.",
+  verify: "nifra check",
+  async apply(root, diagnostic) {
+    const file = diagnostic.file
+    if (file === undefined || (await resolveInsideProject(root, file)) === undefined) return []
+    const { splitRouteFile } = await import("./migrate-layout.ts")
+    return splitRouteFile(root, file)
+  },
+})
+
+registerFixRecipe({
+  id: "layout.migrate",
+  description:
+    "Move the app onto the frontend/backend layout, as `nifra migrate layout --write` does.",
+  onlyWhenNamed: true,
+  verify: "nifra check --lints-only",
+  async apply(root) {
+    const { migrateLayout } = await import("./migrate-layout.ts")
+    const result = await migrateLayout(root, { write: true })
+    return [
+      ...new Set([
+        ...result.moves.map((move) => move.to),
+        ...result.splits.flatMap((split) => [split.file, split.backend]),
+        ...result.rewritten,
+        ...result.tooling.map((edit) => edit.file),
+      ]),
+    ].sort()
+  },
+})
+
+registerFixRecipe({
+  id: "schemas.draft",
+  description:
+    "Draft the missing loader or action output schema from the function's return type, for the author to review.",
+  verify: "nifra check --lints-only",
+  async apply(root, diagnostic) {
+    const file = diagnostic.file
+    if (file === undefined) return []
+    const path = await resolveInsideProject(root, file)
+    if (path === undefined) return []
+    const schema = diagnostic.evidence
+      ?.find((line) => line.startsWith("missing: "))
+      ?.slice("missing: ".length)
+    if (schema !== "loaderOutput" && schema !== "actionOutput") return []
+    const { planOutputSchemas } = await import("./output-schemas.ts")
+    const source = await readFile(path, "utf8")
+    // Only this declaration: other schemas in the file, generated or hand-written, stay as they are.
+    const plan = await planOutputSchemas(
+      root,
+      [file],
+      (read) => (read === file ? source : undefined),
+      {
+        draft: (at, name) => at === file && name === schema,
+      },
+    )
+    const blocked =
+      plan.warnings.length > 0
+        ? plan.warnings.join("; ")
+        : plan.entries.find((entry) => entry.schema === schema && entry.reason !== undefined)
+            ?.reason
+    if (blocked !== undefined)
+      throw new Error(`[nifra] no ${schema} was drafted in ${file}: ${blocked}`)
+    const drafted = plan.edits.get(file)
+    if (drafted === undefined) return []
+    await writeFile(path, drafted, "utf8")
+    return [file]
+  },
+})
+
 /**
  * How many typecheck passes the reserved-segment codemod will run. A nested collision
  * (`/api/delete/then`) only reveals its second site once the first is rewritten, so one pass is not

package/src/init-agents.ts

@@ -258,7 +258,7 @@ function nameMember(
   return { text: rewritten, named }
 }
 
-interface PinScan {
+export interface PinScan {
   /** The input with every stale pin rewritten - every other character untouched. */
   readonly text: string
   /** Pins found, current or stale. */
@@ -302,8 +302,9 @@ function repinRegistry(text: string, target: string, member?: string): PinScan {
   return named ? { ...scan, text: rewritten, named: member } : scan
 }
 
-/** Every file that carries the pin, and the part of it --sync-mcp may rewrite. */
-const PIN_SITES: readonly {
+/** Every file that carries the pin, and the part of it --sync-mcp and `nifra upgrade --write` may
+ * rewrite. */
+export const PIN_SITES: readonly {
   readonly path: string
   readonly repin: (text: string, target: string, member?: string) => PinScan
 }[] = [

package/src/internal/config-paths.ts

@@ -0,0 +1,154 @@
+/**
+ * The module path a nifra config names, read from its source without running it. The loader reads a
+ * string from the app root (`"./src/client.tsx"`, or an alias or package name the bundler resolves);
+ * `resolve`/`join` from `node:path` of the config's own folder and literal segments, or
+ * `fileURLToPath(new URL("x", import.meta.url))`, names a file relative to the config itself.
+ */
+import { posix } from "node:path"
+import type * as TS from "typescript"
+
+export interface StaticConfigPath {
+  /** `"app"`: read from the app root as the loader reads a string. `"config"`: from the config's folder. */
+  readonly base: "app" | "config"
+  readonly path: string
+  /** The string literal's text, quotes excluded, for an `"app"` path: [start, end). */
+  readonly span?: readonly [number, number]
+}
+
+const OWN_DIR = new Set(["import.meta.dir", "import.meta.dirname", "__dirname"])
+const PATH_MODULES = new Set(["node:path", "path", "node:path/posix", "path/posix"])
+const URL_MODULES = new Set(["node:url", "url"])
+
+interface PathBindings {
+  /** Local names of `resolve` and `join`. */
+  readonly calls: ReadonlySet<string>
+  /** Default and namespace imports of `node:path`. */
+  readonly namespaces: ReadonlySet<string>
+  readonly fileURLToPath: ReadonlySet<string>
+}
+
+function pathBindings(ts: typeof TS, sf: TS.SourceFile): PathBindings {
+  const calls = new Set<string>()
+  const namespaces = new Set<string>()
+  const fileURLToPath = new Set<string>()
+  for (const statement of sf.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+      continue
+    const from = statement.moduleSpecifier.text
+    const clause = statement.importClause
+    if (clause === undefined || clause.isTypeOnly) continue
+    const isPath = PATH_MODULES.has(from)
+    if (!isPath && !URL_MODULES.has(from)) continue
+    if (isPath && clause.name !== undefined) namespaces.add(clause.name.text)
+    const bindings = clause.namedBindings
+    if (bindings === undefined) continue
+    if (ts.isNamespaceImport(bindings)) {
+      if (isPath) namespaces.add(bindings.name.text)
+      continue
+    }
+    for (const element of bindings.elements) {
+      if (element.isTypeOnly) continue
+      const imported = (element.propertyName ?? element.name).text
+      if (isPath && (imported === "resolve" || imported === "join")) calls.add(element.name.text)
+      else if (!isPath && imported === "fileURLToPath") fileURLToPath.add(element.name.text)
+    }
+  }
+  return { calls, namespaces, fileURLToPath }
+}
+
+const unwrap = (ts: typeof TS, node: TS.Expression): TS.Expression => {
+  let current = node
+  while (
+    ts.isAsExpression(current) ||
+    ts.isSatisfiesExpression(current) ||
+    ts.isParenthesizedExpression(current) ||
+    ts.isNonNullExpression(current)
+  )
+    current = current.expression
+  return current
+}
+
+const isLiteral = (
+  ts: typeof TS,
+  node: TS.Node | undefined,
+): node is TS.StringLiteral | TS.NoSubstitutionTemplateLiteral =>
+  node !== undefined && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+
+/** A readable static path, normalized; `undefined` for an absolute one or a URL. */
+function relativeSegments(segments: readonly string[]): string | undefined {
+  if (segments.some((segment) => segment.startsWith("/") || /^[a-z][a-z\d+.-]*:/i.test(segment)))
+    return undefined
+  const path = posix.normalize(posix.join(...segments))
+  return path === "." ? undefined : path
+}
+
+/**
+ * Create a reader for one config file. It answers for an expression the config exports, so a path
+ * built any other way (a variable, `process.cwd()`, a template with substitutions) is `undefined`.
+ */
+export function configPathReader(
+  ts: typeof TS,
+  sf: TS.SourceFile,
+): (node: TS.Expression | undefined) => StaticConfigPath | undefined {
+  const bindings = pathBindings(ts, sf)
+  const isPathCall = (callee: TS.Expression): boolean =>
+    ts.isIdentifier(callee)
+      ? bindings.calls.has(callee.text)
+      : ts.isPropertyAccessExpression(callee) &&
+        ts.isIdentifier(callee.expression) &&
+        bindings.namespaces.has(callee.expression.text) &&
+        (callee.name.text === "resolve" || callee.name.text === "join")
+  return (node) => {
+    if (node === undefined) return undefined
+    const value = unwrap(ts, node)
+    if (isLiteral(ts, value))
+      return { base: "app", path: value.text, span: [value.getStart(sf) + 1, value.getEnd() - 1] }
+    if (!ts.isCallExpression(value)) return undefined
+    const [first, ...rest] = value.arguments
+    if (isPathCall(value.expression)) {
+      if (first === undefined || !OWN_DIR.has(first.getText(sf)) || rest.length === 0)
+        return undefined
+      const segments: string[] = []
+      for (const segment of rest) {
+        if (!isLiteral(ts, segment)) return undefined
+        segments.push(segment.text)
+      }
+      const path = relativeSegments(segments)
+      return path === undefined ? undefined : { base: "config", path }
+    }
+    if (
+      ts.isIdentifier(value.expression) &&
+      bindings.fileURLToPath.has(value.expression.text) &&
+      first !== undefined &&
+      ts.isNewExpression(first) &&
+      first.expression.getText(sf) === "URL" &&
+      first.arguments?.length === 2 &&
+      first.arguments[1]?.getText(sf) === "import.meta.url" &&
+      isLiteral(ts, first.arguments[0])
+    ) {
+      const path = relativeSegments([first.arguments[0].text])
+      return path === undefined ? undefined : { base: "config", path }
+    }
+    return undefined
+  }
+}
+
+/** The `export const <name> = ...` initializer in a config, or `undefined`. */
+export function exportedInitializer(
+  ts: typeof TS,
+  sf: TS.SourceFile,
+  name: string,
+): TS.Expression | undefined {
+  for (const statement of sf.statements) {
+    if (
+      !ts.isVariableStatement(statement) ||
+      !statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)
+    )
+      continue
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts.isIdentifier(declaration.name) && declaration.name.text === name)
+        return declaration.initializer
+    }
+  }
+  return undefined
+}

package/src/internal/installed-package.ts

@@ -0,0 +1,15 @@
+import { existsSync } from "node:fs"
+import { dirname, join } from "node:path"
+
+/** The manifest of the installed package `name`, as Node finds it: the nearest `node_modules/<name>`
+ * at or above the importing file. A workspace link resolves through its symlink. */
+export function installedManifest(fromFile: string, name: string): string | undefined {
+  let dir = dirname(fromFile)
+  for (;;) {
+    const manifest = join(dir, "node_modules", name, "package.json")
+    if (existsSync(manifest)) return manifest
+    const parent = dirname(dir)
+    if (parent === dir) return undefined
+    dir = parent
+  }
+}

package/src/internal/project-specifiers.ts

@@ -22,6 +22,12 @@ export interface ProjectResolver extends SpecifierResolver {
   readonly respell: (fromFile: string, specifier: string, file: string) => string | undefined
   /** The `paths` patterns of the nearest tsconfig at or above `dir`, after its `extends` chain. */
   readonly pathPatterns: (dir: string) => readonly string[]
+  /**
+   * Whether the compiler settings for `file` keep an import whose named specifiers are all
+   * type-only, as `import {} from "x"` (`verbatimModuleSyntax`). `true` when its tsconfig chain
+   * cannot be read, so a scan that trusts the answer keeps the edge.
+   */
+  readonly keepsTypeOnlyImports: (file: string) => boolean
 }
 
 /** How an alias specifier reached its file: what a rewrite through the same alias has to fit. */
@@ -59,8 +65,19 @@ interface PathsConfig {
   readonly pathsBase: string
   readonly paths: ReadonlyArray<readonly [string, readonly string[]]>
   readonly baseUrl: string | undefined
+  /** The {@link IMPORT_EMIT_OPTIONS} the chain sets, later configs winning; `undefined` when part of
+   * the chain could not be read. */
+  readonly importEmit: Readonly<Record<string, unknown>> | undefined
 }
 
+// The options that decide whether an import left with only type specifiers is emitted. The last two
+// are removed in TypeScript 6 but still read by older compilers and bundlers.
+const IMPORT_EMIT_OPTIONS = [
+  "verbatimModuleSyntax",
+  "importsNotUsedAsValues",
+  "preserveValueImports",
+]
+
 /** JSON with comments and trailing commas, as tsconfig files are written. Throws on anything else. */
 export function parseJsonc(text: string): unknown {
   let code = ""
@@ -101,8 +118,14 @@ const record = (value: unknown): Readonly<Record<string, unknown>> | undefined =
     ? Object.fromEntries(Object.entries(value))
     : undefined
 
-const isFile = (path: string): boolean =>
-  statSync(path, { throwIfNoEntry: false })?.isFile() ?? false
+/** Whether `path` is a file. A path through a file (`a.ts/index.ts`) is none, not an error. */
+export const isFile = (path: string): boolean => {
+  try {
+    return statSync(path, { throwIfNoEntry: false })?.isFile() ?? false
+  } catch {
+    return false
+  }
+}
 
 const real = (path: string): string => {
   try {
@@ -113,18 +136,18 @@ const real = (path: string): string => {
 }
 
 /** The file a path names: as written, its source for a `.js` name, with an extension, or an index. */
-function probe(base: string): string | undefined {
-  if (isFile(base)) return base
+function probe(base: string, exists: (path: string) => boolean): string | undefined {
+  if (exists(base)) return base
   const ext = extname(base)
   for (const source of SOURCE_FOR[ext] ?? []) {
     const candidate = `${base.slice(0, -ext.length)}${source}`
-    if (isFile(candidate)) return candidate
+    if (exists(candidate)) return candidate
   }
   for (const extension of EXTENSIONS)
-    if (isFile(`${base}${extension}`)) return `${base}${extension}`
+    if (exists(`${base}${extension}`)) return `${base}${extension}`
   for (const extension of EXTENSIONS) {
     const index = join(base, `index${extension}`)
-    if (isFile(index)) return index
+    if (exists(index)) return index
   }
   return undefined
 }
@@ -164,7 +187,14 @@ function matchPattern(
   return best
 }
 
-export function createSpecifierResolver(): ProjectResolver {
+export interface SpecifierResolverOptions {
+  /** Whether a module file exists, for resolving against a planned layout rather than the disk.
+   * Config files (tsconfig, package.json) are still read from the disk. */
+  readonly moduleExists?: (path: string) => boolean
+}
+
+export function createSpecifierResolver(options: SpecifierResolverOptions = {}): ProjectResolver {
+  const exists = options.moduleExists ?? isFile
   const configs = new Map<string, PathsConfig | undefined>()
   const tsconfigByDir = new Map<string, string | undefined>()
   const manifests = new Map<string, Readonly<Record<string, unknown>> | undefined>()
@@ -209,7 +239,7 @@ export function createSpecifierResolver(): ProjectResolver {
     }
   }
 
-  /** The `paths` and `baseUrl` a config ends up with after its `extends` chain. */
+  /** The `paths`, `baseUrl` and import-emit options a config ends up with after its `extends` chain. */
   const pathsConfig = (
     file: string,
     seen: ReadonlySet<string> = new Set(),
@@ -218,6 +248,7 @@ export function createSpecifierResolver(): ProjectResolver {
     if (seen.has(file) || seen.size >= MAX_EXTENDS) return undefined
     const config = readJsonc(file)
     let inherited: PathsConfig | undefined
+    let importEmit: Record<string, unknown> | undefined = {}
     const extended = config?.extends
     for (const name of typeof extended === "string"
       ? [extended]
@@ -227,15 +258,24 @@ export function createSpecifierResolver(): ProjectResolver {
       if (typeof name !== "string") continue
       const base = extendedConfig(file, name)
       const parent = base === undefined ? undefined : pathsConfig(base, new Set([...seen, file]))
+      importEmit =
+        importEmit === undefined || parent?.importEmit === undefined
+          ? undefined
+          : { ...importEmit, ...parent.importEmit }
       if (parent === undefined) continue
       inherited = {
         paths: parent.paths.length > 0 ? parent.paths : (inherited?.paths ?? []),
         baseUrl: parent.baseUrl ?? inherited?.baseUrl,
         pathsBase:
           parent.paths.length > 0 ? parent.pathsBase : (inherited?.pathsBase ?? parent.pathsBase),
+        importEmit,
       }
     }
     const options = record(config?.compilerOptions)
+    if (importEmit !== undefined) {
+      for (const key of IMPORT_EMIT_OPTIONS)
+        if (options?.[key] !== undefined) importEmit = { ...importEmit, [key]: options[key] }
+    }
     const baseUrl =
       typeof options?.baseUrl === "string"
         ? join(dirname(file), options.baseUrl)
@@ -255,7 +295,7 @@ export function createSpecifierResolver(): ProjectResolver {
           )
     const pathsBase =
       baseUrl ?? (ownPaths === undefined ? (inherited?.pathsBase ?? dirname(file)) : dirname(file))
-    const resolved = config === undefined ? undefined : { paths, baseUrl, pathsBase }
+    const resolved = config === undefined ? undefined : { paths, baseUrl, pathsBase, importEmit }
     configs.set(file, resolved)
     return resolved
   }
@@ -315,7 +355,7 @@ export function createSpecifierResolver(): ProjectResolver {
     if (template === undefined) return undefined
     const base = dirname(manifestPath)
     const written = join(base, template.replaceAll(STAR, match.star ?? ""))
-    const found = probe(written)
+    const found = probe(written, exists)
     return found === undefined
       ? undefined
       : { key: match.pattern, keys, base, templates: [template], written, found }
@@ -335,7 +375,7 @@ export function createSpecifierResolver(): ProjectResolver {
     if (match === undefined) {
       if (config.baseUrl === undefined) return undefined
       const written = join(config.baseUrl, specifier)
-      const found = probe(written)
+      const found = probe(written, exists)
       return found === undefined
         ? undefined
         : { key: undefined, keys, base: config.baseUrl, templates: [STAR], written, found }
@@ -346,7 +386,7 @@ export function createSpecifierResolver(): ProjectResolver {
     )
     for (const target of targets) {
       const written = join(config.pathsBase, target.replaceAll("*", match.star ?? ""))
-      const found = probe(written)
+      const found = probe(written, exists)
       if (found === undefined) continue
       const templates = targets.map((t) => t.replaceAll("*", STAR))
       return { key: match.pattern, keys, base: config.pathsBase, templates, written, found }
@@ -401,7 +441,20 @@ export function createSpecifierResolver(): ProjectResolver {
     return (config?.paths ?? []).map(([pattern]) => pattern)
   }
 
-  return Object.assign(resolve, { respell, pathPatterns })
+  const keepsTypeOnlyImports = (file: string): boolean => {
+    const tsconfig = tsconfigFor(dirname(file))
+    if (tsconfig === undefined) return false
+    const emit = pathsConfig(tsconfig)?.importEmit
+    if (emit === undefined) return true
+    return (
+      emit.verbatimModuleSyntax === true ||
+      emit.preserveValueImports === true ||
+      emit.importsNotUsedAsValues === "preserve" ||
+      emit.importsNotUsedAsValues === "error"
+    )
+  }
+
+  return Object.assign(resolve, { respell, pathPatterns, keepsTypeOnlyImports })
 
   function resolveFrom(fromFile: string, specifier: string): string | undefined {
     let found: string | undefined
@@ -411,8 +464,8 @@ export function createSpecifierResolver(): ProjectResolver {
       specifier === "." ||
       specifier === ".."
     )
-      found = probe(join(dirname(fromFile), specifier))
-    else if (isAbsolute(specifier)) found = probe(specifier)
+      found = probe(join(dirname(fromFile), specifier), exists)
+    else if (isAbsolute(specifier)) found = probe(specifier, exists)
     // A `#` name is a package.json import first; a tsconfig may still map it.
     else if (specifier.startsWith("#"))
       found = viaImports(fromFile, specifier) ?? viaTsconfig(fromFile, specifier)