@wular/pnext 0.0.1

package/src/compat/bundler/require-context.ts

@@ -0,0 +1,281 @@
+// webpack's `require.context()` (COMPAT).
+//
+// `require.context(dir, recursive, regExp)` is a webpack-only build-time API: it eagerly includes every
+// file under `dir` matching `regExp` and returns a callable context module - `ctx(key)` yields a module,
+// `ctx.keys()` lists the request keys, `ctx.resolve(key)` the underlying path, `ctx.id` the context
+// module id. pnext has no webpack graph, so the call is expanded at transform time: the directory is
+// walked on disk, the matching files become static top-level imports, and the call expression is
+// replaced by a synthesized context object built from them.
+//
+// Wired as a server source transform (covering both the Bun runtime's per-file SSR loading and the
+// esbuild server passes) and as a client source transform.
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+
+/** Extensions whose files also get an extension-less request key (webpack resolves both). */
+const RESOLVABLE_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.json'];
+
+// `require.context(` — also matches the TS-cast form the Next fixtures use,
+// `(require as any).context(`, since the transform runs on pre-compiled source.
+const CONTEXT_CALL = /(?:\(\s*require\s+as\s+[^)]*\)|\brequire)\s*\.\s*context\s*\(/g;
+
+/** Cheap gate: does this source contain any candidate `require.context(` call? */
+export function sourceHasRequireContext(source: string): boolean {
+  return source.includes('.context(') && source.includes('require');
+}
+
+interface ContextEntry {
+  /** Request key, e.g. `./parent/file1.js`. */
+  key: string;
+  /** Absolute path of the file the key resolves to. */
+  file: string;
+}
+
+/**
+ * Split a call's argument list (the text between the outer parens) on top-level
+ * commas, ignoring commas nested in parens/brackets/braces, strings, regex
+ * literals and comments. Returns `undefined` when the parens never balance.
+ */
+function splitCallArguments(source: string, openIndex: number): { args: string[]; end: number } | undefined {
+  const args: string[] = [];
+  let depth = 0;
+  let start = openIndex + 1;
+  let index = openIndex;
+  let quote: string | undefined;
+  let inRegex = false;
+  while (index < source.length) {
+    const char = source[index]!;
+    const prev = source[index - 1];
+    if (quote) {
+      if (char === quote && prev !== '\\') quote = undefined;
+    } else if (inRegex) {
+      if (char === '/' && prev !== '\\') inRegex = false;
+    } else if (char === '"' || char === "'" || char === '`') {
+      quote = char;
+    } else if (char === '/' && source[index + 1] === '/') {
+      index = source.indexOf('\n', index);
+      if (index === -1) return undefined;
+    } else if (char === '/' && source[index + 1] === '*') {
+      const close = source.indexOf('*/', index + 2);
+      if (close === -1) return undefined;
+      index = close + 1;
+    } else if (char === '/' && depth > 0) {
+      // Inside the argument list a `/` can only start a regex literal (the
+      // division case would need a preceding operand, which no argument
+      // position of `require.context` produces).
+      inRegex = true;
+    } else if (char === '(' || char === '[' || char === '{') {
+      depth++;
+    } else if (char === ')' || char === ']' || char === '}') {
+      depth--;
+      if (depth === 0) {
+        args.push(source.slice(start, index));
+        const trimmed = args.map(arg => arg.trim());
+        return { args: trimmed.length === 1 && trimmed[0] === '' ? [] : trimmed, end: index };
+      }
+    } else if (char === ',' && depth === 1) {
+      args.push(source.slice(start, index));
+      start = index + 1;
+    }
+    index++;
+  }
+  return undefined;
+}
+
+/** Parse a `/pattern/flags` literal; returns `undefined` for anything else. */
+function parseRegExpLiteral(text: string): RegExp | undefined {
+  const match = /^\/((?:\\.|\[(?:\\.|[^\]])*\]|[^/])+)\/([a-z]*)$/.exec(text);
+  if (!match) return undefined;
+  try {
+    return new RegExp(match[1]!, match[2]!.replace(/[gy]/g, ''));
+  } catch {
+    return undefined;
+  }
+}
+
+/** Parse a plain string literal argument; returns `undefined` for anything else. */
+function parseStringLiteral(text: string): string | undefined {
+  const match = /^(['"`])((?:\\.|[^\\])*)\1$/.exec(text);
+  if (!match) return undefined;
+  try {
+    return JSON.parse(`"${match[2]!.replace(/"/g, '\\"').replace(/\\'/g, "'")}"`) as string;
+  } catch {
+    return match[2];
+  }
+}
+
+function walkFiles(dir: string, recursive: boolean, prefix = ''): string[] {
+  let names: string[];
+  try {
+    names = readdirSync(dir).sort();
+  } catch {
+    return [];
+  }
+  const files: string[] = [];
+  for (const name of names) {
+    if (name.startsWith('.') || name === 'node_modules') continue;
+    const full = path.join(dir, name);
+    let isDirectory = false;
+    try {
+      isDirectory = statSync(full).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDirectory) {
+      if (recursive) files.push(...walkFiles(full, recursive, `${prefix}${name}/`));
+    } else {
+      files.push(`${prefix}${name}`);
+    }
+  }
+  return files;
+}
+
+/**
+ * The request keys a context over `dir` exposes, webpack-style: `'./'`-prefixed
+ * POSIX paths relative to `dir`, filtered by `regExp` (tested against the key),
+ * sorted lexicographically. With no `regExp` webpack's default (`/^\.\/.*$/`)
+ * accepts everything AND the extension-less form of each resolvable file also
+ * becomes a key, since `require('./parent/file1')` resolves there too.
+ */
+export function requireContextEntries(dir: string, recursive: boolean, regExp?: RegExp): ContextEntry[] {
+  const entries: ContextEntry[] = [];
+  const seen = new Set<string>();
+  for (const relative of walkFiles(dir, recursive)) {
+    const file = path.join(dir, ...relative.split('/'));
+    const keys = [`./${relative}`];
+    if (!regExp && RESOLVABLE_EXTENSIONS.includes(path.extname(relative))) {
+      keys.push(`./${relative.slice(0, -path.extname(relative).length)}`);
+    }
+    for (const key of keys) {
+      if (regExp && !regExp.test(key)) continue;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      entries.push({ key, file });
+    }
+  }
+  return entries.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+}
+
+// Runtime helper injected alongside the expanded contexts. `ctx(key)` mirrors
+// webpack's "returns module.exports": for a CommonJS target esbuild/Bun expose
+// the exports object as the namespace's `default`, so unwrap that case; a real
+// ESM module keeps its namespace.
+const CONTEXT_RUNTIME = `function __pnext_require_context(entries, id) {
+  const map = new Map(entries.map(entry => [entry[0], entry]));
+  const missing = key => {
+    const error = new Error("Cannot find module '" + key + "'");
+    error.code = 'MODULE_NOT_FOUND';
+    return error;
+  };
+  const context = key => {
+    const entry = map.get(key);
+    if (!entry) throw missing(key);
+    const mod = entry[2];
+    if (mod && typeof mod === 'object' && 'default' in mod) {
+      const extra = Object.keys(mod).filter(name => name !== 'default' && name !== '__esModule');
+      if (extra.length === 0 && mod.__esModule !== true) return mod.default;
+    }
+    return mod;
+  };
+  context.keys = () => entries.map(entry => entry[0]);
+  context.resolve = key => {
+    const entry = map.get(key);
+    if (!entry) throw missing(key);
+    return entry[1];
+  };
+  context.id = id;
+  return context;
+}`;
+
+/**
+ * Resolve the context directory argument against the importing file. Server
+ * builds can compile materialized copies of the app tree (see
+ * `originalResourcePath` in webpack-loaders.ts); when the directory does not
+ * exist next to the copy, rebase the importer onto `workspaceRoot` and retry so
+ * sibling directories of the ORIGINAL source are found.
+ */
+function resolveContextDir(
+  specifier: string,
+  file: string,
+  paths: { outPath?: string; workspaceRoot?: string } | undefined,
+): string {
+  const direct = path.resolve(path.dirname(file), specifier);
+  if (existsSync(direct)) return direct;
+  if (paths?.outPath && paths.workspaceRoot) {
+    const cacheRoot = path.join(paths.outPath, 'cache', 'server');
+    const relative = path.relative(cacheRoot, file);
+    if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
+      const segments = relative.split(path.sep);
+      segments.shift(); // drop <profileDir>
+      const original = path.resolve(
+        path.dirname(path.join(paths.workspaceRoot, ...segments)),
+        specifier,
+      );
+      if (existsSync(original)) return original;
+    }
+  }
+  return direct;
+}
+
+/**
+ * Expand every `require.context(dir, recursive?, regExp?)` in `source` into a
+ * static context module. Calls whose arguments are not statically analyzable
+ * (a non-literal directory) are left untouched. Returns the source unchanged
+ * when there is nothing to rewrite.
+ */
+export function rewriteRequireContextSource(
+  source: string,
+  file: string,
+  paths?: { outPath?: string; workspaceRoot?: string },
+): string {
+  if (!sourceHasRequireContext(source)) return source;
+  const imports: string[] = [];
+  const contexts: string[] = [];
+  let output = '';
+  let cursor = 0;
+  CONTEXT_CALL.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = CONTEXT_CALL.exec(source))) {
+    const openIndex = match.index + match[0].length - 1;
+    const parsed = splitCallArguments(source, openIndex);
+    if (!parsed) continue;
+    const [dirArg, recursiveArg, regExpArg] = parsed.args;
+    const specifier = dirArg === undefined ? undefined : parseStringLiteral(dirArg);
+    if (specifier === undefined) continue;
+    const recursive = recursiveArg === undefined ? true : recursiveArg.trim() !== 'false';
+    const regExp = regExpArg === undefined ? undefined : parseRegExpLiteral(regExpArg.trim());
+    if (regExpArg !== undefined && !regExp) continue;
+
+    const dir = resolveContextDir(specifier, file, paths);
+    const entries = requireContextEntries(dir, recursive, regExp);
+    const id = contexts.length;
+    const binding = `__pnext_context_${id}`;
+    const rows = entries.map((entry, index) => {
+      const namespace = `${binding}_${index}`;
+      imports.push(`import * as ${namespace} from ${JSON.stringify(entry.file)};`);
+      return `[${JSON.stringify(entry.key)}, ${JSON.stringify(entry.file)}, ${namespace}]`;
+    });
+    const contextId = `${specifier} ${recursive ? 'recursive ' : ''}${regExp ? regExp.source : '^\\.\\/.*$'}`;
+    contexts.push(
+      `const ${binding} = __pnext_require_context([${rows.join(', ')}], ${JSON.stringify(contextId)});`,
+    );
+    output += source.slice(cursor, match.index) + binding;
+    cursor = parsed.end + 1;
+    CONTEXT_CALL.lastIndex = cursor;
+  }
+  if (contexts.length === 0) return source;
+  output += source.slice(cursor);
+  const injection = [...imports, CONTEXT_RUNTIME, ...contexts].join('\n');
+  return injectAfterDirectives(output, injection);
+}
+
+// Injected declarations go after any leading directive prologue ('use client' /
+// 'use server') and optional shebang so the directive stays the first statement.
+function injectAfterDirectives(source: string, injection: string): string {
+  const prologue = /^(\uFEFF?(?:#![^\n]*\n)?(?:[ \t]*(['"])use [\w-]+\2[ \t]*;?[ \t]*(?:\r?\n|$))*)/.exec(
+    source,
+  );
+  const index = prologue ? prologue[0].length : 0;
+  return `${source.slice(0, index)}${injection}\n${source.slice(index)}`;
+}

package/src/compat/bundler/resolve-extensions.ts

@@ -0,0 +1,75 @@
+// next.config `resolveExtensions` for the CLIENT esbuild graph (COMPAT).
+//
+// The server resolver already honors the configured extension probe order. The client graph is bundled
+// by esbuild, whose native `resolveExtensions` option cannot express two things the Next option allows:
+// an `''` entry ("try the bare name with no extension"), and asset extensions like `.png` whose
+// resolution must still flow through the static-asset onResolve plugin, keyed on the extensioned
+// specifier. So instead of setting the esbuild option, this plugin probes relative specifiers in the
+// configured order and re-dispatches the extensioned specifier through build.resolve(), so every
+// downstream plugin sees the same path it would for an explicit extension. Only registered when the app
+// configures resolveExtensions.
+
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+import type { Plugin } from 'esbuild';
+
+const resolvedMarker = Symbol('pnext-resolve-extensions');
+
+function isFile(file: string): boolean {
+  try {
+    return statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Client esbuild plugin applying the configured `resolveExtensions` probe
+ * order to relative imports (user extension order replaces esbuild's default,
+ * matching the server resolver's semantics: first hit wins, `''` = bare name).
+ */
+export function clientResolveExtensionsPlugin(extensions: readonly string[]): Plugin {
+  return {
+    name: 'pnext-resolve-extensions',
+    setup(build) {
+      build.onResolve({ filter: /^\.\.?\// }, async args => {
+        if ((args.pluginData as Record<PropertyKey, unknown> | undefined)?.[resolvedMarker]) {
+          return undefined;
+        }
+        if (!args.resolveDir) return undefined;
+        const base = path.resolve(args.resolveDir, args.path);
+        // An import that already names an existing file resolves as-is.
+        if (isFile(base)) return undefined;
+        for (const extension of extensions) {
+          const candidate = `${base}${extension}`;
+          if (!isFile(candidate)) continue;
+          // Re-dispatch with the extension made explicit so downstream
+          // onResolve plugins (static assets, css) match on it.
+          return build.resolve(`${args.path}${extension}`, {
+            kind: args.kind,
+            importer: args.importer,
+            namespace: args.namespace,
+            resolveDir: args.resolveDir,
+            pluginData: { ...(args.pluginData as object | undefined), [resolvedMarker]: true },
+          });
+        }
+        // Directory (index probe) or genuinely missing: preserve the probe
+        // order for index files too, then fall back to esbuild's resolution.
+        if (existsSync(base)) {
+          for (const extension of extensions) {
+            if (extension === '') continue;
+            if (!isFile(path.join(base, `index${extension}`))) continue;
+            return build.resolve(`${args.path.replace(/\/$/, '')}/index${extension}`, {
+              kind: args.kind,
+              importer: args.importer,
+              namespace: args.namespace,
+              resolveDir: args.resolveDir,
+              pluginData: { ...(args.pluginData as object | undefined), [resolvedMarker]: true },
+            });
+          }
+        }
+        return undefined;
+      });
+    },
+  };
+}

package/src/compat/bundler/source-cache.ts

@@ -0,0 +1,61 @@
+/**
+ * Per-file memo for the bundler plugins' load/resolve callbacks. Those callbacks are the plugin
+ * chain's whole JS cost - they run once per FILE per BUILD, and the vendor pipeline runs hundreds
+ * of builds over an overlapping set of node_modules files.
+ *
+ * Staleness follows the rule the rest of the runtime uses: a file under `node_modules` is immutable
+ * for the life of the process (the same assumption the vendor artifact cache makes), and anything
+ * else is keyed on mtime + size so an edit is never served from the memo.
+ */
+import { statSync } from 'node:fs';
+import path from 'node:path';
+
+const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
+
+interface Entry<T> {
+  stamp: string;
+  value: T;
+}
+
+/** mtime+size stamp, or '' for a file whose contents cannot change here. */
+function stamp(file: string) {
+  if (file.includes(NODE_MODULES)) return '';
+  try {
+    const info = statSync(file);
+    return `${info.mtimeMs}\0${info.size}`;
+  } catch {
+    // A missing file is a real answer for the callers here (they all catch), so
+    // it is cached like any other — under a stamp no live file can produce.
+    return 'missing';
+  }
+}
+
+/** A memo whose entries are recomputed when their file changes on disk. */
+export function fileMemo<T>(compute: (file: string) => T) {
+  const entries = new Map<string, Entry<T>>();
+  return (file: string): T => {
+    const current = stamp(file);
+    const cached = entries.get(file);
+    if (cached?.stamp === current) return cached.value;
+    const value = compute(file);
+    entries.set(file, { stamp: current, value });
+    return value;
+  };
+}
+
+/**
+ * The same memo for a callback that reads off the event loop. A bundler plugin callback runs on the
+ * SINGLE JS thread the whole pipeline shares, so a synchronous read there is time no other build can
+ * use - awaiting one lets the other builds' callbacks interleave with it.
+ */
+export function fileMemoAsync<T>(compute: (file: string) => Promise<T>) {
+  const entries = new Map<string, Entry<Promise<T>>>();
+  return (file: string): Promise<T> => {
+    const current = stamp(file);
+    const cached = entries.get(file);
+    if (cached?.stamp === current) return cached.value;
+    const value = compute(file);
+    entries.set(file, { stamp: current, value });
+    return value;
+  };
+}

package/src/compat/bundler/static-imports.ts

@@ -0,0 +1,25 @@
+import { pathToFileHref } from '../../config';
+import { rewriteSpecifierLiterals } from '../../resolve/scan-facts';
+
+/**
+ * Resolve registered compat aliases before Bun reaches installed package entries. Folded onto the
+ * memoized module record: only real import/export/dynamic-import/require specifiers are considered, so
+ * an alias key quoted inside a string or a comment - which the old specifier regex rewrote - is never
+ * touched.
+ */
+export function rewriteStaticCompatImports(
+  source: string,
+  file: string,
+  aliases: Readonly<Record<string, string>>,
+  requireAliases: Readonly<Record<string, string>> = {},
+): string {
+  return rewriteSpecifierLiterals(source, file, (specifier, kind) => {
+    // A side-effect `import 'x'` keeps resolving through the host resolver, as
+    // it did under the `from`-anchored regex this replaced.
+    const target = kind === 'side-effect' ? undefined : aliases[specifier];
+    if (!target) return undefined;
+    const resolved =
+      kind === 'require' ? (requireAliases[specifier] ?? target) : pathToFileHref(target);
+    return JSON.stringify(resolved);
+  });
+}

package/src/compat/bundler/symlink-imports.ts

@@ -0,0 +1,119 @@
+import { readdirSync, realpathSync } from 'node:fs';
+import { realpath } from 'node:fs/promises';
+import path from 'node:path';
+import type { Plugin } from 'esbuild';
+import type { ResolvedConfig } from '../../config';
+import { resolveImport } from '../../resolve/imports';
+
+const resolvedMarker = Symbol('pnext-symlink-import');
+
+/**
+ * Whether a file IS its own real path - asked once per relative import, so the same importers are
+ * re-resolved component-by-component across every build. Keyed on the path alone: a path's symlink
+ * identity changes only on an install, which already invalidates every resolved artifact key.
+ */
+const realPaths = new Map<string, Promise<boolean>>();
+
+function isRealPath(file: string) {
+  let real = realPaths.get(file);
+  if (!real) {
+    real = realpath(file).then(
+      resolved => resolved === file,
+      () => true,
+    );
+    realPaths.set(file, real);
+  }
+  return real;
+}
+
+/**
+ * What the layout scan concluded:
+ *   'none'          no symlink anywhere the resolver could meet one
+ *   'package-links' only whole-package node_modules links (workspace or link installs) - esbuild follows
+ *                   these during node_modules resolution, so importers come out as realpaths
+ *   'other'         pnpm trees, symlinked roots, stray source symlinks, or a failed scan
+ */
+type SymlinkLayout = 'none' | 'package-links' | 'other';
+
+const symlinkLayouts = new Map<string, SymlinkLayout>();
+
+/**
+ * Whether this build can see a SYMLINKED importer, so the plugin's onResolve is registered only where it
+ * can matter. `realPathEntries` builds hand esbuild realpath-resolved entries, and esbuild's own
+ * resolution follows symlinks - there, workspace links alone cannot produce a symlinked importer. Any
+ * detection error registers the plugin: a missed hook silently changes resolution.
+ */
+export function symlinkedImportsPossible(
+  config: ResolvedConfig,
+  realPathEntries?: boolean,
+): boolean {
+  const key = `${config.root}\0${config.workspaceRoot}`;
+  let layout = symlinkLayouts.get(key);
+  if (layout === undefined) {
+    layout = detectSymlinkLayout(config);
+    symlinkLayouts.set(key, layout);
+  }
+  if (layout === 'none') return false;
+  if (layout === 'package-links') return !realPathEntries;
+  return true;
+}
+
+function detectSymlinkLayout(config: ResolvedConfig): SymlinkLayout {
+  try {
+    const roots = [...new Set([config.root, config.workspaceRoot])].map(root =>
+      path.resolve(root),
+    );
+    let packageLinks = false;
+    for (const root of roots) {
+      if (realpathSync(root) !== root) return 'other';
+      if (readDirEntries(root).some(entry => entry.isSymbolicLink())) return 'other';
+      const nodeModules = path.join(root, 'node_modules');
+      for (const entry of readDirEntries(nodeModules)) {
+        if (entry.name === '.pnpm') return 'other';
+        if (entry.isSymbolicLink()) packageLinks = true;
+        else if (entry.isDirectory() && entry.name.startsWith('@')) {
+          const scopeDir = path.join(nodeModules, entry.name);
+          if (readDirEntries(scopeDir).some(scoped => scoped.isSymbolicLink()))
+            packageLinks = true;
+        }
+      }
+    }
+    return packageLinks ? 'package-links' : 'none';
+  } catch {
+    return 'other';
+  }
+}
+
+/** Missing dir = no symlinks there; any other failure propagates as "uncertain". */
+function readDirEntries(dir: string) {
+  try {
+    return readdirSync(dir, { withFileTypes: true });
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+}
+
+/** Resolve relative imports from the real target of a symlinked source file. */
+export function serverSymlinkImportPlugin(config: ResolvedConfig): Plugin {
+  return {
+    name: 'pnext-symlink-imports',
+    setup(build) {
+      build.onResolve({ filter: /^\.\.?\// }, async args => {
+        if (!args.importer || (args.pluginData as Record<PropertyKey, unknown> | undefined)?.[resolvedMarker]) {
+          return undefined;
+        }
+        if (await isRealPath(args.importer)) return undefined;
+        const target = resolveImport(config.root, args.importer, args.path);
+        if (!target) return undefined;
+        return build.resolve(target, {
+          kind: args.kind,
+          importer: args.importer,
+          namespace: args.namespace,
+          resolveDir: args.resolveDir,
+          pluginData: { ...(args.pluginData as object | undefined), [resolvedMarker]: true },
+        });
+      });
+    },
+  };
+}

package/src/compat/bundler/tsconfig-paths.ts

@@ -0,0 +1,50 @@
+// ---------------------------------------------------------------------------
+// tsconfig `paths` resolution for esbuild graphs (COMPAT).
+//
+// esbuild natively discovers a `tsconfig.json` next to the resolveDir and
+// applies its `paths`/`baseUrl`. Next's `typescript.tsconfigPath` lets an app
+// keep its compiler config (including `paths`) in a DIFFERENTLY-named file
+// (e.g. `myconfig.json`); esbuild never discovers that file, so bare aliases
+// declared there ("foo" -> "./bar.ts") are unresolved in esbuild bundles.
+//
+// Core's source resolver honors the configured tsconfig, but direct esbuild
+// graphs do not consult it. This plugin resolves matching bare specifiers
+// through the same configured-tsconfig resolver.
+//
+// The filter is the DECLARED `paths` patterns, read once from every tsconfig
+// that can drive a resolution here (the app root, the workspace root and its
+// members). Aliases are the only thing this plugin can ever claim, so a
+// catch-all bare filter just paid a JS round-trip per import to say "not mine"
+// (611 fires on a 401-route app that declares no `paths` at all). No patterns
+// anywhere -> no plugin.
+// ---------------------------------------------------------------------------
+
+import path from 'node:path';
+import type { Plugin } from 'esbuild';
+import type { ResolvedConfig } from '../../config';
+import { configuredTsPathPatterns, resolveConfiguredTsPath } from '../../resolve/imports';
+import { escapeRegex } from '../../utils/source';
+
+export function tsconfigPathsPlugin(config: ResolvedConfig): Plugin | undefined {
+  const patterns = configuredTsPathPatterns(config.root, config.workspaceRoot);
+  if (patterns.length === 0) return undefined;
+  // A TS `paths` key holds at most one `*`; everything else is literal.
+  const filter = new RegExp(
+    `^(?:${patterns
+      .map(pattern => pattern.split('*').map(escapeRegex).join('[^:]*'))
+      .join('|')})$`,
+  );
+  return {
+    name: 'pnext-tsconfig-paths',
+    setup(build) {
+      build.onResolve({ filter }, args => {
+        const resolved = resolveConfiguredTsPath(
+          config.root,
+          path.join(args.resolveDir || config.root, 'pnext-resolve.ts'),
+          args.path,
+        );
+        return resolved ? { path: resolved } : undefined;
+      });
+    },
+  };
+}