@wular/pnext 0.0.1

package/src/compat/bundler/config.ts

@@ -0,0 +1,363 @@
+// ---------------------------------------------------------------------------
+// Bundler config accessors (COMPAT).
+//
+// Small typed readers over the loaded next.config (getNextConfig()) for the
+// bundler-feature plugins. Kept in one place so every plugin reads the same
+// normalized shapes and a pure-core / non-next app (empty config) degrades to
+// safe defaults.
+// ---------------------------------------------------------------------------
+
+import { getNextConfig } from '../next/config-loader';
+import type { ModularizeRule } from './modularize-imports';
+
+/** A predefined built-in set kept external server-side (Next ships this list). */
+const PREDEFINED_SERVER_EXTERNAL_PACKAGES = [
+  'sharp',
+  'sqlite3',
+  'better-sqlite3',
+  'canvas',
+  '@node-rs/argon2',
+  '@node-rs/bcrypt',
+];
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : [];
+}
+
+/**
+ * `serverExternalPackages` + the predefined built-in list: packages kept external
+ * (resolved from node_modules, never bundled) in the server graph.
+ */
+export function serverExternalPackages(): Set<string> {
+  const config = getNextConfig();
+  return new Set([
+    ...PREDEFINED_SERVER_EXTERNAL_PACKAGES,
+    ...stringArray(config.serverExternalPackages),
+  ]);
+}
+
+/**
+ * The build's deployment id: next.config `deploymentId`, else the
+ * `NEXT_DEPLOYMENT_ID` env var (Next accepts either). Inlined into every graph
+ * and written to `required-server-files.json` so tooling can read it back.
+ */
+export function deploymentId(): string | undefined {
+  const configured = getNextConfig().deploymentId;
+  if (typeof configured === 'string' && configured.length > 0) return configured;
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  const fromEnv = process.env.NEXT_DEPLOYMENT_ID;
+  return fromEnv && fromEnv.length > 0 ? fromEnv : undefined;
+}
+
+/** `publicRuntimeConfig`: the subset of runtime config safe to inline into client bundles. */
+export function publicRuntimeConfig(): Record<string, unknown> {
+  const config = getNextConfig().publicRuntimeConfig;
+  return config && typeof config === 'object' ? (config as Record<string, unknown>) : {};
+}
+
+/** `transpilePackages`: node_modules packages force-bundled + transpiled. */
+export function transpilePackages(): string[] {
+  return stringArray(getNextConfig().transpilePackages);
+}
+
+/**
+ * `modularizeImports`: specifier -> `{ transform, skipDefaultConversion }`
+ * rules that split barrel imports into per-member imports. Only the string
+ * `transform` template form is honored (the shape Next's compat fixtures use);
+ * malformed/object-template entries are dropped so a build still proceeds.
+ */
+export function modularizeImports(): Record<string, ModularizeRule> {
+  const raw = getNextConfig().modularizeImports;
+  if (!raw || typeof raw !== 'object') return {};
+  const out: Record<string, ModularizeRule> = {};
+  for (const [specifier, value] of Object.entries(raw as Record<string, unknown>)) {
+    if (value && typeof value === 'object' && typeof (value as ModularizeRule).transform === 'string') {
+      const rule = value as ModularizeRule;
+      out[specifier] = {
+        transform: rule.transform,
+        skipDefaultConversion: Boolean(rule.skipDefaultConversion),
+      };
+    }
+  }
+  return out;
+}
+
+/**
+ * `experimental.optimizePackageImports`: barrel packages whose named imports
+ * are rewritten to their leaf modules (see optimize-package-imports.ts). The
+ * configured list EXTENDS the built-in default set, as Next's does.
+ */
+export function optimizePackageImports(): string[] {
+  const experimental = getNextConfig().experimental as
+    | { optimizePackageImports?: unknown }
+    | undefined;
+  return stringArray(experimental?.optimizePackageImports);
+}
+
+/** A normalized `compiler.relay` entry (see relay-transform.ts). */
+export interface RelayCompilerConfig {
+  /** Source root the transform applies to, relative to `process.cwd()`. */
+  src: string;
+  /** Where relay-compiler wrote its artifacts, relative to `process.cwd()`. */
+  artifactDirectory?: string;
+  /** The artifact language: decides the generated file's extension. */
+  language: 'javascript' | 'typescript' | 'flow';
+}
+
+/**
+ * `compiler.relay`: the Relay SWC transform's config. `src` is required by
+ * Next's schema; `language` defaults to `'javascript'`. Returns undefined when
+ * unconfigured so the transform stays a no-op.
+ */
+export function relayCompilerConfig(): RelayCompilerConfig | undefined {
+  const compiler = getNextConfig().compiler as
+    | { relay?: { src?: unknown; artifactDirectory?: unknown; language?: unknown } }
+    | undefined;
+  const relay = compiler?.relay;
+  if (!relay || typeof relay !== 'object' || typeof relay.src !== 'string') return undefined;
+  const language = relay.language;
+  return {
+    src: relay.src,
+    artifactDirectory:
+      typeof relay.artifactDirectory === 'string' ? relay.artifactDirectory : undefined,
+    language:
+      language === 'typescript' || language === 'flow' || language === 'javascript'
+        ? language
+        : 'javascript',
+  };
+}
+
+/**
+ * `experimental.esmExternals`: `true` (default) | `false` | `'loose'`.
+ * Controls whether ESM externals stay external or are bundled.
+ */
+export function esmExternals(): boolean | 'loose' {
+  const experimental = getNextConfig().experimental as
+    | { esmExternals?: boolean | 'loose' }
+    | undefined;
+  return experimental?.esmExternals ?? true;
+}
+
+/**
+ * `resolveExtensions`: user-supplied resolver extension order, if any. Next accepts the top-level key,
+ * `turbopack.resolveExtensions`, and the legacy `experimental.turbo.resolveExtensions` spelling.
+ */
+export function resolveExtensions(): string[] | undefined {
+  const config = getNextConfig();
+  const turbopack = config.turbopack as { resolveExtensions?: unknown } | undefined;
+  const experimental = config.experimental as
+    | { turbo?: { resolveExtensions?: unknown } }
+    | undefined;
+  for (const value of [
+    config.resolveExtensions,
+    turbopack?.resolveExtensions,
+    experimental?.turbo?.resolveExtensions,
+  ]) {
+    const list = stringArray(value);
+    if (list.length > 0) return list;
+  }
+  return undefined;
+}
+
+/** `typescript.tsconfigPath`: a non-default tsconfig location. */
+export function tsconfigPath(): string | undefined {
+  const ts = getNextConfig().typescript as { tsconfigPath?: string } | undefined;
+  return typeof ts?.tsconfigPath === 'string' ? ts.tsconfigPath : undefined;
+}
+
+export interface CompilerDefines {
+  /** Inlined into BOTH server and client bundles. */
+  define: Record<string, string>;
+  /** Inlined into the SERVER bundle only (client sees the fallback). */
+  defineServer: Record<string, string>;
+}
+
+function normalizeDefineMap(value: unknown): Record<string, string> {
+  if (!value || typeof value !== 'object') return {};
+  const out: Record<string, string> = {};
+  for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {
+    // esbuild `define` values must be JS source text: strings need to be
+    // JSON-encoded, primitives stringified.
+    if (typeof raw === 'string') out[key] = JSON.stringify(raw);
+    else if (typeof raw === 'number' || typeof raw === 'boolean') out[key] = String(raw);
+  }
+  return out;
+}
+
+/** `compiler.define` / `compiler.defineServer` inlined-constant maps. */
+export function compilerDefines(): CompilerDefines {
+  const compiler = getNextConfig().compiler as
+    | { define?: Record<string, unknown>; defineServer?: Record<string, unknown> }
+    | undefined;
+  return {
+    define: normalizeDefineMap(compiler?.define),
+    defineServer: normalizeDefineMap(compiler?.defineServer),
+  };
+}
+
+/** The console methods Next's SWC `removeConsole` transform can target. */
+const CONSOLE_METHODS = [
+  'assert',
+  'clear',
+  'count',
+  'countReset',
+  'debug',
+  'dir',
+  'dirxml',
+  'error',
+  'group',
+  'groupCollapsed',
+  'groupEnd',
+  'info',
+  'log',
+  'table',
+  'time',
+  'timeEnd',
+  'timeLog',
+  'trace',
+  'warn',
+];
+
+/**
+ * `compiler.removeConsole`: `true` strips every `console.*` call; `{ exclude }`
+ * strips all methods except the listed ones. Returns the `console.<method>`
+ * esbuild `pure` targets to strip, or `undefined` when unconfigured.
+ */
+export function removeConsoleTargets(): string[] | undefined {
+  const compiler = getNextConfig().compiler as
+    | { removeConsole?: boolean | { exclude?: unknown } }
+    | undefined;
+  const removeConsole = compiler?.removeConsole;
+  if (!removeConsole) return undefined;
+  const exclude = new Set(
+    typeof removeConsole === 'object' ? stringArray(removeConsole.exclude) : [],
+  );
+  return CONSOLE_METHODS.filter(method => !exclude.has(method)).map(method => `console.${method}`);
+}
+
+/** `cacheComponents` (PPR): gates the `next-js` export condition. */
+export function cacheComponentsEnabled(): boolean {
+  const config = getNextConfig();
+  const experimental = config.experimental as { cacheComponents?: boolean } | undefined;
+  return Boolean(config.cacheComponents ?? experimental?.cacheComponents);
+}
+
+/**
+ * `experimental.swcEnvOptions`: when `mode: 'usage'`, SWC injects core-js
+ * polyfills for JS features the build targets (per browserslist) that the user
+ * code actually uses. pnext mirrors the user-visible outcome for the features
+ * apps rely on: usage-based injection of the matching core-js module into the
+ * client graph. Returns the configured mode (or undefined when unset).
+ */
+export function swcEnvUsageMode(): 'usage' | 'entry' | undefined {
+  const experimental = getNextConfig().experimental as
+    | { swcEnvOptions?: { mode?: unknown } }
+    | undefined;
+  const mode = experimental?.swcEnvOptions?.mode;
+  return mode === 'usage' || mode === 'entry' ? mode : undefined;
+}
+
+/** Next's `reactCompiler` / legacy experimental flag. */
+export function reactCompilerEnabled(): boolean {
+  const config = getNextConfig();
+  const experimental = config.experimental as { reactCompiler?: boolean } | undefined;
+  return Boolean(config.reactCompiler ?? experimental?.reactCompiler);
+}
+
+/** A single `turbopack.rules` entry, normalized to the shapes pnext supports. */
+export interface WebpackLoaderRule {
+  /** The rule's glob key, e.g. `'*.txt'` or `'*.test-file.ts'`. Only a leading `*` wildcard is honored. */
+  glob: string;
+  /** Loader module specifiers (relative path or bare package name), applied in array order. */
+  loaders: string[];
+  /** The virtual extension of the loader chain's final output, e.g. `'*.js'`. */
+  as?: string;
+  /**
+   * A conditional rule guard: the rule only applies when the import's
+   * `resourceQuery` matches (string equality or a regex `.test`). Comes from the
+   * conditional-array rule form `'*.ext': [{ condition: { query }, loaders }]`.
+   */
+  condition?: { query: string | RegExp };
+  /**
+   * A no-loader `type` asset rule: how the raw file is represented as a module.
+   * `'resource'` emits the file under `/_next/static/media` and exports its URL
+   * string; `'bytes'` exports a `Uint8Array`; `'source'` exports the file text.
+   */
+  assetType?: 'resource' | 'bytes' | 'source';
+}
+
+/**
+ * `turbopack.rules`: Next's webpack-loader-rule config, read directly (rather
+ * than executing the `webpack(config)` mutator) since fixtures configure both
+ * spellings with equivalent semantics. Handles the loader shorthand/object
+ * form, the conditional-array form (`[{ condition, loaders, as }]`), and no-
+ * loader `type` asset rules (`{ type: 'asset' | 'bytes' | 'asset/source' }`).
+ */
+export function turbopackLoaderRules(): WebpackLoaderRule[] {
+  const config = getNextConfig();
+  const turbopack = config.turbopack as { rules?: Record<string, unknown> } | undefined;
+  const rules = turbopack?.rules;
+  if (!rules || typeof rules !== 'object') return [];
+  const out: WebpackLoaderRule[] = [];
+  for (const [glob, raw] of Object.entries(rules)) collectLoaderRuleEntries(glob, raw, out);
+  return out;
+}
+
+function collectLoaderRuleEntries(glob: string, raw: unknown, out: WebpackLoaderRule[]): void {
+  if (Array.isArray(raw)) {
+    // A plain array of loader specifiers, or the conditional-array form whose
+    // entries are `{ condition, loaders, as }` objects.
+    if (raw.every(item => typeof item === 'string')) {
+      const loaders = stringArray(raw);
+      if (loaders.length > 0) out.push({ glob, loaders });
+      return;
+    }
+    for (const item of raw) {
+      if (item && typeof item === 'object') pushLoaderRuleObject(glob, item as Record<string, unknown>, out);
+    }
+    return;
+  }
+  if (raw && typeof raw === 'object') pushLoaderRuleObject(glob, raw as Record<string, unknown>, out);
+}
+
+function pushLoaderRuleObject(glob: string, entry: Record<string, unknown>, out: WebpackLoaderRule[]): void {
+  const loaders = stringArray(entry.loaders);
+  const as = typeof entry.as === 'string' ? entry.as : undefined;
+  const condition = parseRuleCondition(entry.condition);
+  if (loaders.length > 0) {
+    out.push({ glob, loaders, as, ...(condition ? { condition } : {}) });
+    return;
+  }
+  const assetType = parseAssetRuleType(entry.type);
+  if (assetType) out.push({ glob, loaders: [], as, assetType });
+}
+
+function parseRuleCondition(value: unknown): { query: string | RegExp } | undefined {
+  if (!value || typeof value !== 'object') return undefined;
+  const query = (value as { query?: unknown }).query;
+  if (typeof query === 'string' || query instanceof RegExp) return { query };
+  return undefined;
+}
+
+function parseAssetRuleType(value: unknown): 'resource' | 'bytes' | 'source' | undefined {
+  if (value === 'asset' || value === 'asset/resource') return 'resource';
+  if (value === 'bytes') return 'bytes';
+  if (value === 'asset/source') return 'source';
+  return undefined;
+}
+
+/**
+ * `turbopack.resolveAlias`: specifier-to-replacement-path mappings. Exact keys and trailing-glob keys
+ * are both honored. Values are returned verbatim - relative paths are resolved against the project root
+ * by the consumer.
+ */
+export function turbopackResolveAlias(): Record<string, string> {
+  const turbopack = getNextConfig().turbopack as { resolveAlias?: unknown } | undefined;
+  const alias = turbopack?.resolveAlias;
+  if (!alias || typeof alias !== 'object') return {};
+  const out: Record<string, string> = {};
+  for (const [key, value] of Object.entries(alias as Record<string, unknown>)) {
+    if (typeof value === 'string') out[key] = value;
+  }
+  return out;
+}

package/src/compat/bundler/externals.ts

@@ -0,0 +1,34 @@
+import type { Plugin } from 'esbuild';
+import type { ResolvedConfig } from '../../config';
+import { packageNameOfSpecifier, resolvePackageSpecifier } from '../../resolve/imports';
+import { escapeRegex } from '../../utils/source';
+
+/**
+ * Bundle configured server externals into client output with browser exports.
+ * The configured package names ARE the filter (plus their subpaths), so an app
+ * with no `serverExternalPackages` registers no plugin at all instead of paying
+ * a hook fire per bare import in the graph.
+ */
+export function clientExternalPackageResolvePlugin(
+  config: ResolvedConfig,
+  externals: ReadonlySet<string>,
+): Plugin | undefined {
+  if (externals.size === 0) return undefined;
+  const filter = new RegExp(`^(?:${[...externals].map(escapeRegex).join('|')})(?:/|$)`);
+  return {
+    name: 'pnext-client-external-package-resolve',
+    setup(build) {
+      build.onResolve({ filter }, args => {
+        const packageName = packageNameOfSpecifier(args.path);
+        if (!packageName || !externals.has(packageName)) return undefined;
+        const resolved = resolvePackageSpecifier(
+          config.root,
+          `${args.importer || config.root}/pnext-resolve.ts`,
+          args.path,
+          ['import', 'browser', 'require', 'default'],
+        );
+        return resolved ? { path: resolved } : undefined;
+      });
+    },
+  };
+}

package/src/compat/bundler/import-meta-url.ts

@@ -0,0 +1,60 @@
+import { realpathSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { rewriteFacts } from '../../resolve/scan-facts';
+import { spliceSource } from '../../dev/module-transform';
+
+export function sourceHasImportMetaUrl(source: string) {
+  return source.includes('import.meta.url');
+}
+
+/**
+ * Inline `import.meta.url` as the module's own file URL. Folded onto the module
+ * record's `importMetas` spans: exact by construction, where
+ * the regex also fired inside strings and comments.
+ */
+export function rewriteImportMetaUrlSource(source: string, file: string) {
+  if (!sourceHasImportMetaUrl(source)) return source;
+  const facts = rewriteFacts(file, source);
+  if (facts.unreliable) return legacyRewriteImportMetaUrl(source, file);
+  const edits = facts.importMetas
+    .filter(meta => /^\.url\b/.test(source.slice(meta.end, meta.end + 5)))
+    .map(meta => ({
+      start: meta.start,
+      end: meta.end + 4,
+      value: JSON.stringify(pathToFileURL(virtualFixturePath(realSourcePath(file))).href),
+    }));
+  return edits.length > 0 ? spliceSource(source, edits) : source;
+}
+
+// A source oxc could only partially recover keeps the textual pass: an
+// incomplete record would silently under-rewrite.
+function legacyRewriteImportMetaUrl(source: string, file: string) {
+  return source.replace(
+    /\bimport\.meta\.url\b/g,
+    JSON.stringify(pathToFileURL(virtualFixturePath(realSourcePath(file))).href),
+  );
+}
+
+// Modules can reach the bundler through the pages-compat mirror's source-app/
+// source-pages symlinks; inlining that symlinked path breaks code that walks
+// the filesystem relative to import.meta.url (Next inlines the real path).
+function realSourcePath(file: string) {
+  try {
+    return realpathSync(file);
+  } catch {
+    return file;
+  }
+}
+
+function virtualFixturePath(file: string) {
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  const root = process.env.PNEXT_IMPORT_META_URL_FIXTURE_ROOT;
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  const virtualRoot = process.env.PNEXT_IMPORT_META_URL_VIRTUAL_ROOT;
+  if (!root || !virtualRoot) return file;
+  const relative = path.relative(root, file);
+  return relative && !relative.startsWith(`..${path.sep}`) && relative !== '..'
+    ? path.join(virtualRoot, relative)
+    : file;
+}

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

@@ -0,0 +1,119 @@
+// next.config `modularizeImports` (COMPAT).
+//
+// Next rewrites barrel `import { A, B } from '<specifier>'` into per-member imports of individual
+// modules, driven by a `transform` template. For fixtures whose barrel file does not exist at all (only
+// the per-member modules do), the rewrite is the ONLY way the import resolves.
+//
+// This is a plain source transform: for each configured specifier it splits a matching named-import
+// statement into one import per member, applying the template with the kebabCase/camelCase/lowerCase/
+// upperCase helpers. `skipDefaultConversion: true` emits a NAMED import of the original member name
+// from the target module; otherwise a DEFAULT import. Aliasing is preserved.
+//
+// It runs BEFORE path-alias resolution, so the emitted specifiers still flow through tsconfig `paths`
+// resolution. Namespace, default and mixed-default imports of the specifier are left untouched - Next
+// bails on those too.
+
+import { rewriteFacts, type ImportBinding } from '../../resolve/scan-facts';
+import { spliceSource } from '../../dev/module-transform';
+import { withSniff, type ServerSourceTransform } from '../../extensions';
+import { specifierSniffTokens } from '../../utils/source';
+
+/** A normalized `modularizeImports[specifier]` entry (string-template form). */
+export interface ModularizeRule {
+  /** The output-path template, e.g. `'#/design-system/icons/{{ kebabCase member }}'`. */
+  transform: string;
+  /** `true` => named import of the member from the target; otherwise a default import. */
+  skipDefaultConversion?: boolean;
+}
+
+/** Split an identifier into words on camelCase / digit / `_` / `-` boundaries. */
+function splitWords(value: string): string[] {
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+    .replace(/[_-]+/g, ' ')
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
+/** Apply a template helper (`kebabCase`/`camelCase`/`lowerCase`/`upperCase`) to a member name. */
+function applyHelper(helper: string, member: string): string {
+  switch (helper) {
+    case 'kebabCase':
+      return splitWords(member)
+        .map(word => word.toLowerCase())
+        .join('-');
+    case 'camelCase':
+      return splitWords(member)
+        .map((word, index) =>
+          index === 0 ? word.toLowerCase() : word[0]!.toUpperCase() + word.slice(1).toLowerCase(),
+        )
+        .join('');
+    case 'lowerCase':
+      return member.toLowerCase();
+    case 'upperCase':
+      return member.toUpperCase();
+    default:
+      return member;
+  }
+}
+
+/** Expand `{{ member }}` / `{{ helper member }}` placeholders in a transform template. */
+function applyTemplate(template: string, member: string): string {
+  return template.replace(/\{\{\s*(?:(\w+)\s+)?member\s*\}\}/g, (_full, helper?: string) =>
+    helper ? applyHelper(helper, member) : member,
+  );
+}
+
+/**
+ * Rewrite the members of one matched named import into per-member import
+ * statements. Returns `undefined` (leaving the original import untouched) for a
+ * clause the rewrite does not own: no members, or a `type` import.
+ */
+function expandMembers(bindings: readonly ImportBinding[], rule: ModularizeRule): string | undefined {
+  if (bindings.length === 0) return undefined;
+
+  const statements: string[] = [];
+  for (const binding of bindings) {
+    if (binding.type || binding.imported === 'default' || binding.imported === '*') return undefined;
+    const original = binding.imported;
+    const local = binding.local;
+    const target = JSON.stringify(applyTemplate(rule.transform, original));
+    if (rule.skipDefaultConversion) {
+      const named = original === local ? original : `${original} as ${local}`;
+      statements.push(`import { ${named} } from ${target};`);
+    } else {
+      statements.push(`import ${local} from ${target};`);
+    }
+  }
+  return statements.join(' ');
+}
+
+/**
+ * Build a source transform applying the configured `modularizeImports` rules.
+ * Returns a no-op transform when nothing is configured so pure-core apps pay
+ * nothing.
+ */
+export function createModularizeImportsTransform(
+  rules: Record<string, ModularizeRule>,
+): ServerSourceTransform {
+  if (Object.keys(rules).length === 0) return withSniff([], source => source);
+
+  // Folded onto the module record: one memoized parse instead
+  // of a per-rule import regex, and a configured specifier quoted in a string or
+  // a comment no longer expands.
+  return withSniff(specifierSniffTokens(Object.keys(rules)), (source, file) => {
+    if (!source.includes('import')) return source;
+    const edits: { start: number; end: number; value: string }[] = [];
+    for (const statement of rewriteFacts(file, source).imports) {
+      const rule = rules[statement.specifier];
+      if (!rule) continue;
+      const expanded = expandMembers(statement.bindings, rule);
+      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/new-url-asset.ts

@@ -0,0 +1,87 @@
+// `new URL('./asset.png', import.meta.url)` asset references (COMPAT).
+//
+// Next/webpack rewrites this so it evaluates to the emitted client asset URL - the same URL an
+// `import img from './asset.png'` produces - rather than a runtime file:// URL relative to the compiled
+// bundle. Left intact, the literal resolves against the built bundle location, a path that never gets
+// served.
+//
+// This reuses the static-image import pipeline: rewrite each matched call to `(<binding>.src)` and
+// inject a top-level `import <binding> from '<spec>'`. That import flows through core's
+// staticAssetModule seam, which emits the asset and yields the client URL. The `.src` string is what
+// `.toString()` and `fileURLToPath()` (which then throws, as in Next's webpack path) observe.
+//
+// Applied to both graphs as a registered source transform.
+
+import { rewriteReactProfilerServerSource } from './react-compiler';
+
+// A `new URL('<image>', import.meta.url)` call whose first argument is a string
+// literal ending in a static-image extension (optional ?query/#hash) and whose
+// second argument is exactly `import.meta.url`. Non-asset `new URL(...)` calls
+// (e.g. `new URL(request.url)`) never match.
+const IMAGE_EXT = 'png|jpe?g|gif|webp|avif|svg|ico|bmp';
+const newUrlAssetPattern = () =>
+  new RegExp(
+    `new\\s+URL\\(\\s*(['"])([^'"]+?\\.(?:${IMAGE_EXT})(?:[?#][^'"]*)?)\\1\\s*,\\s*import\\.meta\\.url\\s*\\)`,
+    'g',
+  );
+
+/** Cheap gate: does the source contain any candidate `new URL(...import.meta.url)`? */
+export function sourceHasNewUrlAsset(source: string): boolean {
+  return source.includes('import.meta.url') && newUrlAssetPattern().test(source);
+}
+
+/**
+ * Rewrite `new URL('<image>', import.meta.url)` occurrences to the emitted
+ * static-image URL by threading them through the static-asset import pipeline.
+ * Returns the source unchanged when there is nothing to rewrite.
+ */
+export function rewriteNewUrlAssetSource(source: string, filePath?: string): string {
+  const rewritten = rewriteReactProfilerServerSource(source, filePath);
+  return rewriteNewUrlAssets(
+    rewritten,
+    typeof filePath === 'string' && filePath.includes('middleware'),
+  );
+}
+
+/**
+ * Client-graph variant: no middleware form (a browser module never runs on the edge, and a client file
+ * merely living under an `app/middleware/...` path must not get the blob: rewrite) and no Profiler pass
+ * - that one is registered as its own client transform.
+ */
+export function rewriteNewUrlAssetClientSource(source: string): string {
+  return rewriteNewUrlAssets(source, false);
+}
+
+function rewriteNewUrlAssets(source: string, isMiddleware: boolean): string {
+  if (!source.includes('import.meta.url')) return source;
+  const bindings = new Map<string, string>();
+  const replaced = source.replace(newUrlAssetPattern(), (_match, _quote, spec: string) => {
+    let binding = bindings.get(spec);
+    if (!binding) {
+      binding = `__pnext_new_url_${bindings.size}`;
+      bindings.set(spec, binding);
+    }
+    if (isMiddleware) {
+      return `('blob:' + ${binding}.src.split('/').pop())`;
+    }
+    return `(${binding}.src)`;
+  });
+  if (bindings.size === 0) return source;
+  const imports = [...bindings]
+    .map(([spec, binding]) => `import ${binding} from ${JSON.stringify(spec)};`)
+    .join('\n');
+  return injectAfterDirectives(replaced, imports);
+}
+
+// Insert injected 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 (otherwise the directive is demoted
+// to a plain expression and the module is treated as server-only).
+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)}`;
+}
+