@wular/pnext 0.0.1

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

@@ -0,0 +1,273 @@
+// `experimental.optimizePackageImports` (COMPAT). A barrel package re-exports its whole catalogue
+// from one entry and the vendor pipeline compiles the ENTRY, so a route naming four icons makes the
+// server evaluate the whole barrel.
+//
+// The fix is Next's: for a listed package, rewrite `import { A, B } from 'pkg'` into per-member
+// imports of the LEAF modules its barrel re-exports them from. Each leaf becomes an ordinary vendor
+// demand, so the existing per-package grouping compiles the demanded subpaths as entries of one
+// `splitting: true` build - the shared graph stays one instance.
+//
+// Unlike `modularizeImports` (a user-written path template), the leaf map is DERIVED from the
+// barrel itself, so nothing here encodes a package's layout. Derivation is also the safety gate:
+// the entry must be re-exports and nothing else - no declarations, no side effects - or the package
+// is left alone, which is why an over-broad list cannot produce wrong code.
+
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { parseSync } from 'oxc-parser';
+import { rewriteFacts, type ImportBinding } from '../../resolve/scan-facts';
+import { spliceSource } from '../../dev/module-transform';
+import { resolvePackageSpecifier, resolveVendorPackageSpecifier } from '../../resolve/imports';
+import { withSniff, type ServerSourceTransform } from '../../extensions';
+import { specifierSniffTokens } from '../../utils/source';
+
+/**
+ * Next's default `optimizePackageImports` set - the barrels big enough that compiling the entry is the
+ * dominant cost. Extended by the config option. Every name is still gated by the derivation below, so a
+ * package that is not a pure re-export barrel costs nothing but one parse.
+ */
+const DEFAULT_OPTIMIZED_PACKAGES = [
+  'lucide-react',
+  'date-fns',
+  'lodash-es',
+  'ramda',
+  'antd',
+  'react-bootstrap',
+  'ahooks',
+  '@ant-design/icons',
+  '@headlessui/react',
+  '@headlessui-float/react',
+  '@heroicons/react/20/solid',
+  '@heroicons/react/24/solid',
+  '@heroicons/react/24/outline',
+  '@visx/visx',
+  '@tremor/react',
+  '@mui/material',
+  '@mui/icons-material',
+  '@material-ui/core',
+  '@material-ui/icons',
+  '@tabler/icons-react',
+  '@phosphor-icons/react',
+  'react-use',
+  'recharts',
+  'rxjs',
+];
+
+export function optimizedPackageSet(configured: readonly string[]): string[] {
+  // Rewriting a barrel changes what the vendor pipeline compiles, so it is also
+  // what a slow or wrong artifact has to be bisected against — and how the
+  // bench A/Bs it (same seam shape as `PNEXT_VENDOR_GROUP=0`).
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  if (process.env.PNEXT_OPTIMIZE_PACKAGE_IMPORTS === '0') return [];
+  return [...new Set([...DEFAULT_OPTIMIZED_PACKAGES, ...configured])];
+}
+
+/** Where one exported name really lives: the barrel's re-export target. */
+interface BarrelMember {
+  /** The leaf module, relative to the barrel entry. */
+  source: string;
+  /** The name to take from it: `default`, `*`, or an export name. */
+  imported: string;
+}
+
+/** The exported names a pure re-export barrel publishes, and their leaves. */
+type BarrelMap = ReadonlyMap<string, BarrelMember>;
+
+const barrelMaps = new Map<string, BarrelMap | undefined>();
+
+/**
+ * The leaf map of a barrel entry, or undefined when the entry is not a pure
+ * re-export barrel. Cached per entry file: one parse per package per process,
+ * however many modules import it.
+ */
+function barrelMap(entry: string): BarrelMap | undefined {
+  if (barrelMaps.has(entry)) return barrelMaps.get(entry);
+  let map: BarrelMap | undefined;
+  try {
+    map = parseBarrel(entry);
+  } catch {
+    map = undefined;
+  }
+  barrelMaps.set(entry, map);
+  return map;
+}
+
+function parseBarrel(entry: string): BarrelMap | undefined {
+  const source = readFileSync(entry, 'utf8');
+  const parsed = parseSync(entry, source, { lang: 'js' });
+  if (parsed.errors.length > 0) return undefined;
+
+  // A namespace re-export (`import * as icons from './icons/index.js'; export
+  // { icons }`) is two statements; the local binding is only allowed to leave
+  // the module through that export, or the barrel is doing something else.
+  const namespaces = new Map<string, string>();
+  for (const node of parsed.program.body) {
+    if (node.type === 'ImportDeclaration') {
+      const specifiers = node.specifiers ?? [];
+      const only = specifiers[0];
+      if (specifiers.length !== 1 || only?.type !== 'ImportNamespaceSpecifier') return undefined;
+      namespaces.set(only.local.name, node.source.value);
+      continue;
+    }
+    if (node.type === 'ExportNamedDeclaration') {
+      // `export const x = …` is a definition, not a re-export: not a barrel.
+      if (node.declaration) return undefined;
+      continue;
+    }
+    // `export * from` hides its names in the target, so a demanded name cannot
+    // be attributed to a leaf; anything else is code with a side effect.
+    return undefined;
+  }
+
+  const members = new Map<string, BarrelMember>();
+  for (const statement of parsed.module.staticExports) {
+    for (const record of statement.entries) {
+      if (record.isType) continue;
+      const exported = record.exportName.name;
+      if (!exported) return undefined;
+      const request = record.moduleRequest?.value;
+      if (request) {
+        const kind: string = record.importName.kind;
+        if (kind === 'AllButDefault') return undefined;
+        const imported =
+          kind === 'Default' ? 'default' : kind === 'All' ? '*' : record.importName.name;
+        if (!imported) return undefined;
+        members.set(exported, { source: request, imported });
+        continue;
+      }
+      const local = record.localName.name;
+      const namespace = local === null ? undefined : namespaces.get(local);
+      if (!namespace) return undefined;
+      members.set(exported, { source: namespace, imported: '*' });
+    }
+  }
+  return members.size > 0 ? members : undefined;
+}
+
+/**
+ * The barrel entry, but only when both layers resolve the specifier to the SAME
+ * file: a package that splits its entry per condition publishes a different
+ * catalogue per layer, and one rewritten source is compiled for both.
+ */
+function barrelEntry(root: string, file: string, specifier: string) {
+  const client = resolveVendorPackageSpecifier(root, file, specifier, CLIENT_CONDITIONS);
+  if (!client) return undefined;
+  return resolveVendorPackageSpecifier(root, file, specifier, SERVER_CONDITIONS) === client
+    ? client
+    : undefined;
+}
+
+/**
+ * The bare specifier that names a leaf module - what the rewrite emits, so the leaf goes through the
+ * ordinary package-resolution and vendor-grouping paths rather than a raw path only this transform could
+ * resolve. Verified by re-resolving it: a package whose `exports` map withholds the subpath resolves to
+ * something else, and then the member is left on the barrel. Verified under BOTH layers' conditions,
+ * because one rewritten source is compiled for both.
+ */
+function leafSpecifier(root: string, entry: string, member: BarrelMember): string | undefined {
+  const key = `${entry}\0${member.source}`;
+  if (leafSpecifiers.has(key)) return leafSpecifiers.get(key);
+  const specifier = resolveLeafSpecifier(root, entry, member);
+  leafSpecifiers.set(key, specifier);
+  return specifier;
+}
+
+const leafSpecifiers = new Map<string, string | undefined>();
+
+const CLIENT_CONDITIONS = ['module', 'import'];
+const SERVER_CONDITIONS = ['react-server', 'node', 'module', 'import'];
+
+function resolveLeafSpecifier(root: string, entry: string, member: BarrelMember) {
+  if (!member.source.startsWith('.')) return undefined;
+  const file = path.resolve(path.dirname(entry), member.source);
+  const packageDir = packageDirOf(entry);
+  if (!packageDir) return undefined;
+  const name = packageNameOfDir(packageDir);
+  const relative = path.relative(packageDir, file);
+  if (!name || relative.startsWith('..') || path.isAbsolute(relative)) return undefined;
+  const specifier = `${name}/${relative.split(path.sep).join('/')}`;
+  for (const conditions of [CLIENT_CONDITIONS, SERVER_CONDITIONS]) {
+    if (resolvePackageSpecifier(root, entry, specifier, conditions) !== file) return undefined;
+  }
+  return specifier;
+}
+
+/** The installed package a barrel entry belongs to, by its `node_modules` segment. */
+function packageDirOf(entry: string) {
+  const marker = `${path.sep}node_modules${path.sep}`;
+  const index = entry.lastIndexOf(marker);
+  if (index < 0) return undefined;
+  const rest = entry.slice(index + marker.length).split(path.sep);
+  const segments = rest[0]?.startsWith('@') ? rest.slice(0, 2) : rest.slice(0, 1);
+  return path.join(entry.slice(0, index + marker.length), ...segments);
+}
+
+function packageNameOfDir(packageDir: string) {
+  const marker = `${path.sep}node_modules${path.sep}`;
+  const index = packageDir.lastIndexOf(marker);
+  if (index < 0) return undefined;
+  return packageDir.slice(index + marker.length).split(path.sep).join('/');
+}
+
+/**
+ * Rewrite one matched import into per-leaf imports, or undefined to leave it alone - a default/namespace
+ * import of the barrel itself, a type-only clause, or a name the barrel does not re-export from a
+ * resolvable leaf.
+ */
+function expandBarrelImport(
+  bindings: readonly ImportBinding[],
+  map: BarrelMap,
+  root: string,
+  entry: string,
+): string | undefined {
+  if (bindings.length === 0) return undefined;
+  const statements: string[] = [];
+  for (const binding of bindings) {
+    // A barrel publishes its types off the same entry, so `{ Icon, type Props }`
+    // is the common shape. The type binding is erased before anything resolves
+    // it, so dropping it is what lets the value bindings split at all.
+    if (binding.type) continue;
+    if (binding.imported === 'default' || binding.imported === '*') return undefined;
+    const member = map.get(binding.imported);
+    if (!member) return undefined;
+    const specifier = leafSpecifier(root, entry, member);
+    if (!specifier) return undefined;
+    const target = JSON.stringify(specifier);
+    if (member.imported === 'default') statements.push(`import ${binding.local} from ${target};`);
+    else if (member.imported === '*') statements.push(`import * as ${binding.local} from ${target};`);
+    else {
+      const named =
+        member.imported === binding.local ? binding.local : `${member.imported} as ${binding.local}`;
+      statements.push(`import { ${named} } from ${target};`);
+    }
+  }
+  return statements.length > 0 ? statements.join(' ') : undefined;
+}
+
+/**
+ * The transform. Registered on both layers' chains: one rewritten source is
+ * compiled for the RSC graph and the browser graph, which is why the leaf
+ * specifier has to resolve identically under both.
+ */
+export function createOptimizePackageImportsTransform(
+  packages: readonly string[],
+  root: string,
+): ServerSourceTransform {
+  if (packages.length === 0) return withSniff([], source => source);
+  const optimized = new Set(packages);
+  return withSniff(specifierSniffTokens(packages), (source, file) => {
+    if (!source.includes('import')) return source;
+    const edits: { start: number; end: number; value: string }[] = [];
+    for (const statement of rewriteFacts(file, source).imports) {
+      if (!optimized.has(statement.specifier)) continue;
+      const entry = barrelEntry(root, file, statement.specifier);
+      const map = entry && barrelMap(entry);
+      if (!map || !entry) continue;
+      const expanded = expandBarrelImport(statement.bindings, map, root, entry);
+      if (expanded !== undefined) {
+        edits.push({ start: statement.start, end: statement.end, value: expanded });
+      }
+    }
+    return edits.length > 0 ? spliceSource(source, edits) : source;
+  });
+}

package/src/compat/bundler/polyfill.ts

@@ -0,0 +1,88 @@
+// core-js polyfill injection (COMPAT - experimental.swcEnvOptions).
+//
+// When an app enables `experimental.swcEnvOptions`, SWC ships core-js polyfills for the JS features the
+// targeted browsers lack. pnext does not run SWC's feature analysis; it mirrors the user-visible outcome
+// by adding the matching `core-js/modules/*` import to the client module that uses the feature - the
+// same placement SWC's usage mode picks, so the polyfill runs ahead of that module and ships in its
+// chunk. Gated on swcEnvOptions being configured, so a pure app pays nothing.
+
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import type { ResolvedConfig } from '../../config';
+
+// No-module polyfills chunk (COMPAT - Next parity).
+//
+// Next ships a `polyfills-<hash>.js` chunk referenced by a `<script noModule>` tag: legacy browsers with
+// no ES-module support load it, module-capable browsers skip every `noModule` script. pnext only ever
+// targets module-capable runtimes, so the chunk's body is inert - it exists so the served document
+// carries the same `noModule` script tag Next emits, which some suites assert on.
+
+/** Inert body for the no-module polyfills chunk (never runs in module browsers). */
+export const POLYFILLS_NOMODULE_SOURCE = '!function(){"use strict"}();\n';
+
+let cachedPolyfillsFileName: string | undefined;
+
+/** Content-hashed filename for the emitted no-module polyfills chunk. */
+export function polyfillsChunkFileName(): string {
+  if (cachedPolyfillsFileName) return cachedPolyfillsFileName;
+  const hash = createHash('sha256').update(POLYFILLS_NOMODULE_SOURCE).digest('hex').slice(0, 16);
+  return (cachedPolyfillsFileName = `polyfills-${hash}.js`);
+}
+
+/** App-absolute served path of the polyfills chunk (before assetPrefix). */
+export function polyfillsChunkPath(): string {
+  return `/_next/static/chunks/${polyfillsChunkFileName()}`;
+}
+
+// The core-js module SWC's usage mode emits per feature, keyed by the syntax
+// that pulls it in. Extend as more features are needed.
+const POLYFILL_FEATURES: { usage: RegExp; module: string }[] = [
+  { usage: /\.replaceAll\s*\(/, module: 'core-js/modules/es.string.replace-all.js' },
+];
+
+/** Sniff tokens for the client transform below (one per feature usage). */
+export const POLYFILL_USAGE_TOKENS = POLYFILL_FEATURES.map(feature => feature.usage);
+
+// core-js resolves from the app, not from pnext. One require per root, reused
+// across the transform's per-module calls.
+const polyfillRequires = new Map<string, NodeJS.Require>();
+
+function polyfillRequire(config: ResolvedConfig) {
+  const existing = polyfillRequires.get(config.root);
+  if (existing) return existing;
+  const created = createRequire(path.join(config.root, 'pnext-polyfill-resolve.cjs'));
+  polyfillRequires.set(config.root, created);
+  return created;
+}
+
+/**
+ * Prepend the core-js imports for the features `source` uses, mirroring SWC's usage mode: the polyfill
+ * belongs to the MODULE that needs it, so it lands in that module's chunk (an `inject` into every entry
+ * would instead be hoisted into a shared chunk of its own, away from the user code). A module core-js
+ * does not ship - or that is not installed - is skipped, never a build failure.
+ *
+ * Only app sources, like SWC: polyfilling a dependency (or pnext's own client runtime) would make
+ * core-js shared across entries and split back out into the very standalone chunk this placement avoids.
+ */
+export function rewriteUsagePolyfillImports(
+  source: string,
+  file: string,
+  config: ResolvedConfig,
+): string {
+  const inApp = file.startsWith(`${config.root}${path.sep}`);
+  if (!inApp || file.includes(`${path.sep}node_modules${path.sep}`)) return source;
+  const require = polyfillRequire(config);
+  const imports = POLYFILL_FEATURES.flatMap(feature => {
+    if (!feature.usage.test(source)) return [];
+    try {
+      return [`import ${JSON.stringify(require.resolve(feature.module))};`];
+    } catch {
+      return [];
+    }
+  });
+  if (imports.length === 0) return source;
+  // After the directive prologue: a `'use client'` module must keep it first.
+  const directive = /^(?:\s*['"][^'"]+['"];?\s*)*/.exec(source)?.[0] ?? '';
+  return `${directive}${imports.join('\n')}\n${source.slice(directive.length)}`;
+}

package/src/compat/bundler/react-compiler.ts

@@ -0,0 +1,61 @@
+// ---------------------------------------------------------------------------
+// `Profiler` import splitting (COMPAT). The React Compiler pass itself is core's
+// (client/react-compiler.ts), driven by the client-source loader; next.config's
+// `reactCompiler` flag reaches it through the compat-mode options seam.
+// ---------------------------------------------------------------------------
+
+import path from 'node:path';
+import { rewriteFacts } from '../../resolve/scan-facts';
+import { spliceSource } from '../../dev/module-transform';
+
+const profilerRuntimePath = path.join(import.meta.dirname, 'react-profiler.tsx');
+
+/**
+ * Split `Profiler` out of a `react` named import onto pnext's own Profiler
+ * shim. Folded onto the module record, so the statement is
+ * matched by shape rather than by a line-anchored regex.
+ */
+export function rewriteReactProfilerImport(source: string, file = 'module.tsx'): string {
+  if (!source.includes('Profiler')) return source;
+  const edits: { start: number; end: number; value: string }[] = [];
+  for (const statement of rewriteFacts(file, source).imports) {
+    if (statement.specifier !== 'react') continue;
+    const profilers = statement.bindings.filter(binding => binding.imported === 'Profiler');
+    if (profilers.length === 0) continue;
+
+    const rest = statement.bindings.filter(binding => binding.imported !== 'Profiler');
+    const named = rest.filter(binding => binding.imported !== 'default' && binding.imported !== '*');
+    const other = rest.filter(binding => binding.imported === 'default' || binding.imported === '*');
+    const indent = importIndent(source, statement.start);
+    const clause = named.map(printBinding).join(', ');
+    const prefix = other.map(binding => (binding.imported === '*' ? `* as ${binding.local}` : binding.local)).join(', ');
+    const lines: string[] = [];
+    if (prefix && clause) lines.push(`${indent}import ${prefix}, { ${clause} } from 'react';`);
+    else if (prefix) lines.push(`${indent}import ${prefix} from 'react';`);
+    else if (clause) lines.push(`${indent}import { ${clause} } from 'react';`);
+    for (const profiler of profilers) {
+      lines.push(
+        `${indent}import { Profiler as ${profiler.local} } from ${JSON.stringify(profilerRuntimePath)};`,
+      );
+    }
+    edits.push({ start: statement.start, end: statement.end, value: lines.join('\n').slice(indent.length) });
+  }
+  return edits.length > 0 ? spliceSource(source, edits) : source;
+}
+
+function printBinding(binding: { imported: string; local: string; type: boolean }) {
+  const name = binding.imported === binding.local ? binding.local : `${binding.imported} as ${binding.local}`;
+  return binding.type ? `type ${name}` : name;
+}
+
+/** Leading whitespace of the statement's own line (the splice keeps the first one). */
+function importIndent(source: string, start: number) {
+  const lineStart = source.lastIndexOf('\n', start - 1) + 1;
+  const indent = source.slice(lineStart, start);
+  return /^[ \t]*$/.test(indent) ? indent : '';
+}
+
+export function rewriteReactProfilerServerSource(source: string, file?: string): string {
+  return rewriteReactProfilerImport(source, file);
+}
+

package/src/compat/bundler/react-profiler.tsx

@@ -0,0 +1,25 @@
+import { Fragment, type ComponentChildren } from 'preact';
+import { useLayoutEffect, useRef } from 'preact/hooks';
+
+export interface ProfilerProps {
+  id: string;
+  children?: ComponentChildren;
+  onRender?: (
+    id: string,
+    phase: 'mount' | 'update',
+    actualDuration: number,
+    baseDuration: number,
+    startTime: number,
+    commitTime: number,
+  ) => void;
+}
+
+export function Profiler({ id, children, onRender }: ProfilerProps) {
+  const phase = useRef<'mount' | 'update'>('mount');
+  useLayoutEffect(() => {
+    const now = typeof performance === 'undefined' ? 0 : performance.now();
+    onRender?.(id, phase.current, 0, 0, now, now);
+    phase.current = 'update';
+  });
+  return <Fragment>{children}</Fragment>;
+}

package/src/compat/bundler/relay-transform.ts

@@ -0,0 +1,116 @@
+// next.config `compiler.relay` (COMPAT).
+//
+// Next runs the Relay SWC transform, which replaces every graphql-tagged template with a reference to
+// the artifact relay-compiler generated for that operation. Without the transform the tag survives into
+// the bundle and relay-runtime's `graphql()` throws its "Unexpected invocation at runtime" invariant on
+// the first render.
+//
+// pnext has no SWC, so this is a plain source transform: for each tagged template it reads the
+// operation/fragment name out of the GraphQL body, resolves the matching artifact on disk, hoists an
+// `import * as <binding>` and substitutes the binding for the tag. Passing the module namespace rather
+// than the default export is exactly what the babel/SWC transforms emit - relay-runtime's `getNode()`
+// unwraps `node.default` for ES-module artifacts and takes the object as-is for the CommonJS ones.
+//
+// Everything is resolved relative to `process.cwd()`, matching the SWC transform's root. That is what
+// makes the multi-project fixture work: each sub-project is built with its own cwd.
+
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { withSniff, type ServerSourceTransform } from '../../extensions';
+import type { RelayCompilerConfig } from './config';
+
+/** The artifact extension relay-compiler emits for each `language` setting. */
+function artifactExtensions(language: RelayCompilerConfig['language']): string[] {
+  // Try the configured language's extension first, then the other one: a
+  // project can point `artifactDirectory` at output generated with a different
+  // `language` than next.config declares (the multi-project fixture reads its
+  // `language` from a sibling project's relay config).
+  return language === 'typescript' ? ['.ts', '.js'] : ['.js', '.ts'];
+}
+
+/** `graphql`-tagged templates. GraphQL has no backticks, so a lazy scan is exact. */
+function relayTagPattern(): RegExp {
+  return /(?<![\w$.])graphql\s*`([\s\S]*?)`/g;
+}
+
+const OPERATION_NAME = /\b(?:query|mutation|subscription|fragment)\s+([A-Za-z_][\w]*)/;
+
+function isUnder(dir: string, file: string): boolean {
+  const relative = path.relative(dir, file);
+  return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+
+// Insert hoisted imports after any leading directive prologue ('use client' /
+// 'use server' / 'use strict') and optional shebang, so a client module's
+// `'use client'` 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)}`;
+}
+
+/**
+ * Build a source transform applying `compiler.relay`. Returns a no-op transform
+ * when nothing is configured so pure-core apps pay nothing.
+ */
+export function createRelayTransform(relay: RelayCompilerConfig | undefined): ServerSourceTransform {
+  if (!relay) return withSniff([], source => source);
+
+  const cwd = path.resolve(process.cwd());
+  const srcDir = path.resolve(cwd, relay.src);
+  const artifactDir = relay.artifactDirectory
+    ? path.resolve(cwd, relay.artifactDirectory)
+    : undefined;
+  const extensions = artifactExtensions(relay.language);
+  const resolved = new Map<string, string | undefined>();
+
+  /** The on-disk artifact for one operation name, or undefined when absent. */
+  function artifactFor(fileDir: string, name: string): string | undefined {
+    // Without `artifactDirectory`, relay-compiler writes `__generated__` next
+    // to the source file.
+    const directory = artifactDir ?? path.join(fileDir, '__generated__');
+    const key = `${directory}\0${name}`;
+    if (resolved.has(key)) return resolved.get(key);
+    let found: string | undefined;
+    for (const extension of extensions) {
+      const candidate = path.join(directory, `${name}.graphql${extension}`);
+      if (existsSync(candidate)) {
+        found = candidate;
+        break;
+      }
+    }
+    resolved.set(key, found);
+    return found;
+  }
+
+  return withSniff(['graphql'], (source, file) => {
+    if (!source.includes('graphql`') && !/graphql\s*`/.test(source)) return source;
+    const absolute = path.resolve(file);
+    // Next scopes the transform to `src`. Files outside the build cwd entirely
+    // (materialized copies) are not covered by that check, so only skip a file
+    // that lives under the cwd but outside the configured source root.
+    if (isUnder(cwd, absolute) && !isUnder(srcDir, absolute)) return source;
+
+    const bindings = new Map<string, string>();
+    const replaced = source.replace(relayTagPattern(), (match, body: string) => {
+      const name = OPERATION_NAME.exec(body)?.[1];
+      if (!name) return match;
+      const artifact = artifactFor(path.dirname(absolute), name);
+      if (!artifact) return match;
+      let binding = bindings.get(artifact);
+      if (!binding) {
+        binding = `__pnext_relay_${bindings.size}`;
+        bindings.set(artifact, binding);
+      }
+      return binding;
+    });
+    if (bindings.size === 0) return source;
+
+    const imports = [...bindings]
+      .map(([artifact, binding]) => `import * as ${binding} from ${JSON.stringify(artifact)};`)
+      .join('\n');
+    return injectAfterDirectives(replaced, imports);
+  });
+}