@wular/pnext 0.0.3 → 0.0.6

package/src/compat/register/cache.ts

@@ -10,8 +10,8 @@
 // Ordering: registerCompatExtensions runs cache BEFORE actions, so the use-cache source transform is
 // registered ahead of the inline-action-tag transform, matching the old rewriteServerSource order.
 
-import type { ResolvedConfig } from '../../config';
-import { nextCompatEnabled } from '../../compat';
+import type { ResolvedConfig } from '../../config'
+import { nextCompatEnabled } from '../../compat/aliases'
 import {
   registerBundledSourceTransforms,
   registerInitHooks,
@@ -19,7 +19,7 @@ import {
   setRenderExtensions,
   setRequestExtensions,
   withSniff,
-} from '../../extensions';
+} from '../../extensions'
 import {
   collectRenderCacheMeta,
   currentRenderCacheMeta,
@@ -28,13 +28,13 @@ import {
   tagsRevalidatedSince,
   tagsRevalidationReasonSince,
   tagsStaleSince,
-} from '../cache/revalidate';
-import { setBuildFlagsOutPath } from '../cache/build-flags';
-import { installCompatFetchCache } from '../cache/fetch-patch';
-import { installCustomCacheHandler } from '../cache/custom-handler';
-import { installModernCacheHandlers } from '../cache/modern-handler';
-import { rewriteUseCacheSource } from '../cache/use-cache-transform';
-import { resumeDataCacheExtension } from '../cache/resume-data-cache';
+} from '../cache/revalidate'
+import { setBuildFlagsOutPath } from '../cache/build-flags'
+import { installCompatFetchCache } from '../cache/fetch-patch'
+import { installCustomCacheHandler } from '../cache/custom-handler'
+import { installModernCacheHandlers } from '../cache/modern-handler'
+import { rewriteUseCacheSource } from '../cache/use-cache-transform'
+import { resumeDataCacheExtension } from '../cache/resume-data-cache'
 
 export function registerCacheExtensions(config: ResolvedConfig): void {
   // Render cache-meta collection scope (tags/revalidate/no-store) wrapped
@@ -45,7 +45,7 @@ export function registerCacheExtensions(config: ResolvedConfig): void {
     // the document can inline its own reuse window for hard loads.
     currentCacheStaleSeconds: () => currentRenderCacheMeta()?.staleSeconds,
     prerenderSidecar: resumeDataCacheExtension,
-  });
+  })
 
   // ISR on-demand staleness: fold the path + tag revalidation checks start.ts
   // used to OR together into the single registry predicate.
@@ -56,7 +56,7 @@ export function registerCacheExtensions(config: ResolvedConfig): void {
       pathRevalidationReasonSince(pathname, mtimeMs) ??
       tagsRevalidationReasonSince(tags, mtimeMs) ??
       (tagsStaleSince(tags, mtimeMs) ? 'soft' : undefined),
-  });
+  })
 
   // 'use cache' source rewrite (server bundles): registered first so it runs
   // before the inline-action-tag transform, exactly as before. Also registered
@@ -64,22 +64,22 @@ export function registerCacheExtensions(config: ResolvedConfig): void {
   // the directive is the one trigger in the chain that survives bundling.
   const useCache = withSniff(['use cache'], (source, file, root) =>
     rewriteUseCacheSource(source, file, root),
-  );
-  registerServerSourceTransforms(useCache);
-  registerBundledSourceTransforms(useCache);
+  )
+  registerServerSourceTransforms(useCache)
+  registerBundledSourceTransforms(useCache)
 
   // Prerenders + runtime renders must observe Next fetch-cache options
   // (force-cache, next: { revalidate, tags }). Idempotent; next-compat only.
   if (nextCompatEnabled(config)) {
     registerInitHooks(cfg => {
-      installCompatFetchCache();
+      installCompatFetchCache()
       // Where `pnext start` reads the build's --debug-prerender flag back from
       // (the runtime 'use cache' error funnel shapes its log around it).
-      setBuildFlagsOutPath(cfg.outPath);
+      setBuildFlagsOutPath(cfg.outPath)
       // Load + instantiate the configured `cacheHandler` (next.config) and
       // install it into the core cache seam so the data cache defers to it.
-      installCustomCacheHandler(cfg.root);
-      installModernCacheHandlers(cfg.root);
-    });
+      installCustomCacheHandler(cfg.root)
+      installModernCacheHandlers(cfg.root)
+    })
   }
 }

package/src/compat/register/client-errors.ts

@@ -7,11 +7,11 @@
 // contract. The compat entry already imports the route's nearest error.js and installs the action-error
 // overlay; to activate the general client error pipeline it additionally calls installClientErrors.
 
-import type { ResolvedConfig } from '../../config';
-import { nextCompatEnabled } from '../../compat';
+import type { ResolvedConfig } from '../../config'
+import { nextCompatEnabled } from '../../compat/aliases'
 
 export function registerClientErrorExtensions(config: ResolvedConfig): void {
-  if (!nextCompatEnabled(config)) return;
+  if (!nextCompatEnabled(config)) return
   // No server-side render/routing extension: the client runtime installs in the
   // browser from the generated entry (seam 5, clientEntryModules). Kept as the
   // stable registration seam so the orchestrator can wire it uniformly.

package/src/compat/register/config.ts

@@ -5,13 +5,13 @@
 // next.config values feed pnext's resolved config for build AND start/dev. The orchestrator must call
 // this from register.ts too, so a single registerCompatExtensions() pass leaves the source installed.
 
-import { registerConfigSource as registerCoreConfigSource } from '../../config';
-import type { ConfigSourceOverrides } from '../../config';
-import { loadNextConfig } from '../next/config-loader';
+import { registerConfigSource as registerCoreConfigSource } from '../../config'
+import type { ConfigSourceOverrides } from '../../config'
+import { loadNextConfig } from '../next/config-loader'
 
 export function registerConfigSource(): void {
   registerCoreConfigSource(async (root, options): Promise<ConfigSourceOverrides> => {
-    const { overrides } = await loadNextConfig(root, options);
-    return overrides;
-  });
+    const { overrides } = await loadNextConfig(root, options)
+    return overrides
+  })
 }

package/src/compat/register/css-extras.ts

@@ -18,38 +18,34 @@
 // Gated on next-compat: a pure-core or react-only app keeps every no-op default and never loads the sass
 // module.
 
-import type { Plugin } from 'esbuild';
-import type { ResolvedConfig } from '../../config';
-import {
-  getBundlerExtensions,
-  setBundlerExtensions,
-  setCssExtensions,
-} from '../../extensions';
-import { nextCompatEnabled } from '../../render/hooks';
+import type { Plugin } from 'esbuild'
+import type { ResolvedConfig } from '../../config'
+import { getBundlerExtensions, setBundlerExtensions, setCssExtensions } from '../../extensions'
+import { nextCompatEnabled } from '../../render/hooks'
 import {
   sassChunkPlugin,
   sassLoadCssModuleForClient,
   sassResolveCssModule,
-} from '../css/sass-plugin';
-import { isSassFile, isSassModuleFile, sassModuleMapping } from '../css/sass';
+} from '../css/sass-plugin'
+import { isSassFile, isSassModuleFile, sassModuleMapping } from '../css/sass'
 import {
   nextCssLoadModuleForClient,
   nextCssModuleChunkPlugin,
   nextCssResolveModule,
-} from '../css/modules';
-import { nextPlanRouteCssChunks } from '../css/chunking';
-import { inlineCssStylesheets } from '../css/inline-css';
+} from '../css/modules'
+import { nextPlanRouteCssChunks } from '../css/chunking'
+import { inlineCssStylesheets } from '../css/inline-css'
 
 export function registerCssExtrasExtensions(config: ResolvedConfig): void {
-  if (!nextCompatEnabled(config)) return;
+  if (!nextCompatEnabled(config)) return
 
   // (1) CSS-chunk + module-map registry consumed by src/css.ts. The two entries
   // the route scanner needs (extraCssExtensions, resolveCssDependency) plus the
   // source materialization are boot facts — register-boot.ts owns them.
-  const resolveNextCssModule = nextCssResolveModule(config);
-  const loadNextCssModuleForClient = nextCssLoadModuleForClient(config);
-  const resolveSassCssModule = sassResolveCssModule(config);
-  const loadSassCssModuleForClient = sassLoadCssModuleForClient(config);
+  const resolveNextCssModule = nextCssResolveModule(config)
+  const loadNextCssModuleForClient = nextCssLoadModuleForClient(config)
+  const resolveSassCssModule = sassResolveCssModule(config)
+  const loadSassCssModuleForClient = sassLoadCssModuleForClient(config)
   setCssExtensions({
     deferRootNotFoundCss: () => true,
     inlineStylesheets: inlineCssStylesheets,
@@ -58,12 +54,12 @@ export function registerCssExtrasExtensions(config: ResolvedConfig): void {
     loadCssModuleForClient: file =>
       loadNextCssModuleForClient(file) ?? loadSassCssModuleForClient(file),
     planRouteCssChunks: nextPlanRouteCssChunks,
-  });
+  })
 
   // (2) Compose the sass module-loader onto the JS bundle esbuild seams.
-  const current = getBundlerExtensions();
-  const priorClient = current.clientEsbuildPlugins;
-  const priorServer = current.serverEsbuildPlugins;
+  const current = getBundlerExtensions()
+  const priorClient = current.clientEsbuildPlugins
+  const priorServer = current.serverEsbuildPlugins
   setBundlerExtensions({
     clientEsbuildPlugins: (cfg: ResolvedConfig): Plugin[] => [
       ...priorClient(cfg),
@@ -74,20 +70,20 @@ export function registerCssExtrasExtensions(config: ResolvedConfig): void {
       nextCssServerModuleLoaderPlugin(cfg),
       sassModuleLoaderPlugin(cfg),
     ],
-  });
+  })
 }
 
 function nextCssServerModuleLoaderPlugin(config: ResolvedConfig): Plugin {
-  const loadModule = nextCssLoadModuleForClient(config);
+  const loadModule = nextCssLoadModuleForClient(config)
   return {
     name: 'pnext-compat-server-css-module',
     setup(build) {
       build.onLoad({ filter: /\.module\.css$/ }, ({ path: file }) => {
-        const contents = loadModule(file);
-        return contents ? { contents, loader: 'js' } : null;
-      });
+        const contents = loadModule(file)
+        return contents ? { contents, loader: 'js' } : null
+      })
     },
-  };
+  }
 }
 
 /**
@@ -101,14 +97,14 @@ function sassModuleLoaderPlugin(config: ResolvedConfig): Plugin {
     name: 'pnext-compat-sass-module',
     setup(build) {
       build.onLoad({ filter: /\.(?:scss|sass)$/ }, ({ path: file }) => {
-        if (!isSassFile(file)) return null;
+        if (!isSassFile(file)) return null
         const contents = isSassModuleFile(file)
           ? `export default ${JSON.stringify(sassModuleMapping(file, config.root, sassIncludePathsFor(config)))};`
-          : 'export default undefined;';
-        return { contents, loader: 'js' };
-      });
+          : 'export default undefined;'
+        return { contents, loader: 'js' }
+      })
     },
-  };
+  }
 }
 
 // Local include-paths read kept here to avoid importing sass-plugin internals;
@@ -116,5 +112,5 @@ function sassModuleLoaderPlugin(config: ResolvedConfig): Plugin {
 // file itself), so an empty list is acceptable — the CSS-chunk plugin
 // (sass-plugin.ts) threads the real sassOptions.includePaths.
 function sassIncludePathsFor(_config: ResolvedConfig): string[] {
-  return [];
+  return []
 }

package/src/compat/register/edge-runtime.ts

@@ -1,6 +1,6 @@
-import { setRuntimeExtensions } from '../../extensions';
-import { withEdgeRuntime } from '../edge-runtime';
+import { setRuntimeExtensions } from '../../extensions'
+import { withEdgeRuntime } from '../edge-runtime'
 
 export function registerEdgeRuntimeExtensions(): void {
-  setRuntimeExtensions({ withEdgeRuntime });
+  setRuntimeExtensions({ withEdgeRuntime })
 }

package/src/compat/register/errors.ts

@@ -5,20 +5,20 @@
 // global-error / global-not-found boundary discovery. A pure-core app registers none of these, keeping
 // the compact core error UI and no digest/redaction.
 
-import type { ResolvedConfig } from '../../config';
-import { setRenderExtensions } from '../../extensions';
-import { nextCompatEnabled } from '../../compat';
+import type { ResolvedConfig } from '../../config'
+import { setRenderExtensions } from '../../extensions'
+import { nextCompatEnabled } from '../../compat/aliases'
 import {
   serializeBoundaryError,
   wrapThrownValue,
   formatErrorLog,
-} from '../lifecycle/error-serialize';
+} from '../lifecycle/error-serialize'
 import {
   httpAccessFallbackUi,
   defaultGlobalErrorUi,
   globalErrorReportScript,
-} from '../lifecycle/error-ui';
-import { getNextConfig } from '../next/config-loader';
+} from '../lifecycle/error-ui'
+import { getNextConfig } from '../next/config-loader'
 
 // global-error / global-not-found are CORE document conventions (discovered by
 // src/routing/routes.ts findGlobalError + src/render renderGlobalNotFoundResponse);
@@ -26,7 +26,7 @@ import { getNextConfig } from '../next/config-loader';
 // digest protocol here. forbidden/unauthorized stay compat conventions
 // (registered in register-routing.ts).
 export function registerErrorExtensions(config: ResolvedConfig): void {
-  if (!nextCompatEnabled(config)) return;
+  if (!nextCompatEnabled(config)) return
 
   setRenderExtensions({
     serializeError: serializeBoundaryError,
@@ -37,10 +37,8 @@ export function registerErrorExtensions(config: ResolvedConfig): void {
     formatErrorLog,
     // Read lazily per call: next.config loads after registration.
     globalNotFoundEnabled: () => {
-      const experimental = getNextConfig().experimental as
-        | { globalNotFound?: boolean }
-        | undefined;
-      return experimental?.globalNotFound === true;
+      const experimental = getNextConfig().experimental as { globalNotFound?: boolean } | undefined
+      return experimental?.globalNotFound === true
     },
-  });
+  })
 }

package/src/compat/register/export.ts

@@ -1,23 +1,23 @@
-import { nextCompatEnabled } from '../../compat';
-import { onExtensionHostReset, registerBuildCompleteHooks } from '../../extensions';
-import type { ResolvedConfig } from '../../config';
-import { emitMetadataRouteArtifacts } from '../metadata-route-artifacts';
-import { emitStaticExport } from '../export';
-import { emitCustomServerShim } from '../next/custom-server';
+import { nextCompatEnabled } from '../../compat/aliases'
+import { onExtensionHostReset, registerBuildCompleteHooks } from '../../extensions'
+import type { ResolvedConfig } from '../../config'
+import { emitMetadataRouteArtifacts } from '../metadata-artifacts'
+import { emitStaticExport } from '../export/emit'
+import { emitCustomServerShim } from '../next/custom-server'
 
-let registered = false;
+let registered = false
 // Host-scoped guard: a fresh host must be registered into again.
-onExtensionHostReset(() => (registered = false));
+onExtensionHostReset(() => (registered = false))
 
 export function registerExportExtensions(config: ResolvedConfig): void {
-  if (registered) return;
-  if (!nextCompatEnabled(config)) return;
-  registered = true;
+  if (registered) return
+  if (!nextCompatEnabled(config)) return
+  registered = true
 
   registerBuildCompleteHooks(async ctx => {
-    if (!nextCompatEnabled(ctx.config)) return;
-    await emitStaticExport(ctx);
-    await emitMetadataRouteArtifacts(ctx);
-    await emitCustomServerShim(ctx.config);
-  });
+    if (!nextCompatEnabled(ctx.config)) return
+    await emitStaticExport(ctx)
+    await emitMetadataRouteArtifacts(ctx)
+    await emitCustomServerShim(ctx.config)
+  })
 }

package/src/compat/register/font.ts

@@ -11,26 +11,26 @@
 // Registration is idempotent and also happens lazily on the first font-collection scope, so it is safe
 // to call in a pure-core app and works before the orchestrator wires it in.
 
-import type { ResolvedConfig } from '../../config';
+import type { ResolvedConfig } from '../../config'
 import {
   registerClientSourceTransforms,
   registerServerSourceTransforms,
   withSniff,
-} from '../../extensions';
-import { rewriteNextFontSource } from '../index';
-import { registerFontFinalizerOnce } from '../next/font/runtime';
+} from '../../extensions'
+import { rewriteNextFontSource } from '../aliases'
+import { registerFontFinalizerOnce } from '../next/font/runtime'
 
-const fontSourceTransformRoots = new Set<string>();
+const fontSourceTransformRoots = new Set<string>()
 
 export function registerFontExtensions(config: ResolvedConfig): void {
-  registerFontFinalizerOnce();
-  if (!config.compat?.next || fontSourceTransformRoots.has(config.root)) return;
-  fontSourceTransformRoots.add(config.root);
-  const sniff = ['next/font', 'next/root-params'];
+  registerFontFinalizerOnce()
+  if (!config.compat?.next || fontSourceTransformRoots.has(config.root)) return
+  fontSourceTransformRoots.add(config.root)
+  const sniff = ['next/font', 'next/root-params']
   registerServerSourceTransforms(
     withSniff(sniff, (source, file) => rewriteNextFontSource(source, file, 'server', config.root)),
-  );
+  )
   registerClientSourceTransforms(
     withSniff(sniff, (source, file) => rewriteNextFontSource(source, file, 'client', config.root)),
-  );
+  )
 }

package/src/compat/register/hooks.ts

@@ -2,7 +2,7 @@
 // Registration seam for the next/navigation router hooks (COMPAT).
 //
 // The hooks themselves (useSelectedLayoutSegment(s), usePathname,
-// useSearchParams, useParams) need no runtime registration: compat/index.ts maps
+// useSearchParams, useParams) need no runtime registration: compat/aliases.ts maps
 // `next/navigation` to compat/next/{navigation,client-navigation}.ts, and the
 // per-layout segment scope is installed by the core renderer (render/slots.ts +
 // render/renderer.ts applyLayouts), gated on next-compat.
@@ -22,7 +22,7 @@
 // today it only re-exports the canonical setter for the proxy wiring.
 // ---------------------------------------------------------------------------
 
-export { recordCanonicalUrl, canonicalUrlHref } from '../next/canonical-url';
+export { recordCanonicalUrl, canonicalUrlHref } from '../next/canonical-url'
 
 /**
  * Placeholder registration entry point kept for symmetry with the other register-<x> modules. The router

package/src/compat/register/image.ts

@@ -4,37 +4,37 @@
 // endpoint, and buildExtensions.steps gets images-manifest.json emission. Safe to call in a pure-core
 // app: the interceptor and build step no-op unless compat.next is enabled.
 
-import path from 'node:path';
-import { mkdir, writeFile } from 'node:fs/promises';
-import type { ResolvedConfig } from '../../config';
-import { nextCompatEnabled } from '../../compat';
+import path from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import type { ResolvedConfig } from '../../config'
+import { nextCompatEnabled } from '../../compat/aliases'
 import {
   registerBuildCompleteHooks,
   registerBuildSteps,
   registerRequestInterceptors,
   type BuildStepContext,
   type RequestInterceptor,
-} from '../../extensions';
-import { getImagesConfig, type ResolvedImagesConfig } from '../next/image/config';
-import { isImageOptimizerRequest, serveImageOptimizer } from '../next/image/optimizer';
-import { manifestLocalPatterns } from '../next/image/patterns';
-import { getDocumentScriptExtensions, setDocumentScriptExtensions } from '../../render/hooks';
-import { setWorkUnitRoute } from '../../request/context';
+} from '../../extensions'
+import { getImagesConfig, type ResolvedImagesConfig } from '../next/image/config'
+import { isImageOptimizerRequest, serveImageOptimizer } from '../next/image/optimizer'
+import { manifestLocalPatterns } from '../next/image/patterns'
+import { getDocumentScriptExtensions, setDocumentScriptExtensions } from '../../render/hooks'
+import { setWorkUnitRoute } from '../../request/context'
 
 export function registerImageExtensions(config: ResolvedConfig): void {
-  globalThis.__PNEXT_IMAGE_CONFIG__ = getImagesConfig();
-  registerRequestInterceptors(imageOptimizerInterceptor);
-  registerBuildSteps(writeImagesManifestStep);
+  globalThis.__PNEXT_IMAGE_CONFIG__ = getImagesConfig()
+  registerRequestInterceptors(imageOptimizerInterceptor)
+  registerBuildSteps(writeImagesManifestStep)
   registerBuildCompleteHooks(async ctx => {
-    if (nextCompatEnabled(ctx.config)) await mirrorStaticMedia(ctx.config);
-  });
+    if (nextCompatEnabled(ctx.config)) await mirrorStaticMedia(ctx.config)
+  })
 
   if (nextCompatEnabled(config)) {
-    const previousHeadTags = getDocumentScriptExtensions().documentHeadTags;
+    const previousHeadTags = getDocumentScriptExtensions().documentHeadTags
     setDocumentScriptExtensions({
       documentHeadTags: (cfg, ctx) =>
         `${previousHeadTags?.(cfg, ctx) ?? ''}${PLACEHOLDER_SCRIPT_TAG}`,
-    });
+    })
   }
 }
 
@@ -52,36 +52,36 @@ export function registerImageExtensions(config: ResolvedConfig): void {
 // INSIDE the post-decode callback, not at bind time. A hydrating route's ClientImage vdom carries no
 // `data-nimg-ph`, so preact's hydration strips the SSR attribute; by the time this callback fires the
 // attribute is gone on any hydrated image, the check bails, and ClientImage stays the sole owner.
-const PLACEHOLDER_SCRIPT_TAG = `<script>(function(){try{function b(){var l=document.querySelectorAll("img[data-nimg-ph]");for(var i=0;i<l.length;i++){(function(img){if(img.closest("[data-pnext-client]"))return;var done=false;function r(){if(done)return;done=true;("decode"in img?img.decode():Promise.resolve()).catch(function(){}).then(function(){var t=img.getAttribute("data-nimg-ph");if(t==null||!img.isConnected)return;img.style.cssText=t;img.removeAttribute("data-nimg-ph")})}if(img.complete&&img.naturalWidth>0)r();else{img.addEventListener("load",r);img.addEventListener("error",r)}})(l[i])}}if(document.readyState==="loading")document.addEventListener("DOMContentLoaded",b);else b()}catch(e){}})();</script>`;
+const PLACEHOLDER_SCRIPT_TAG = `<script>(function(){try{function b(){var l=document.querySelectorAll("img[data-nimg-ph]");for(var i=0;i<l.length;i++){(function(img){if(img.closest("[data-pnext-client]"))return;var done=false;function r(){if(done)return;done=true;("decode"in img?img.decode():Promise.resolve()).catch(function(){}).then(function(){var t=img.getAttribute("data-nimg-ph");if(t==null||!img.isConnected)return;img.style.cssText=t;img.removeAttribute("data-nimg-ph")})}if(img.complete&&img.naturalWidth>0)r();else{img.addEventListener("load",r);img.addEventListener("error",r)}})(l[i])}}if(document.readyState==="loading")document.addEventListener("DOMContentLoaded",b);else b()}catch(e){}})();</script>`
 
 declare global {
-  var __PNEXT_IMAGE_CONFIG__: ResolvedImagesConfig | undefined;
+  var __PNEXT_IMAGE_CONFIG__: ResolvedImagesConfig | undefined
 }
 
 const imageOptimizerInterceptor: RequestInterceptor = async (request, ctx) => {
-  const config = ctx.config;
-  if (!nextCompatEnabled(config)) return undefined;
-  const url = new URL(request.url);
-  const images = getImagesConfig();
-  if (!isImageOptimizerRequest(url, images)) return undefined;
-  if (request.method !== 'GET' && request.method !== 'HEAD') return undefined;
+  const config = ctx.config
+  if (!nextCompatEnabled(config)) return undefined
+  const url = new URL(request.url)
+  const images = getImagesConfig()
+  if (!isImageOptimizerRequest(url, images)) return undefined
+  if (request.method !== 'GET' && request.method !== 'HEAD') return undefined
   // Optimizer responses own their headers outright — classify as a static
   // asset so the app-router finalizers (Vary token merge, x-nextjs-* stamps)
   // leave them untouched. Next serves /_next/image outside the router too.
-  setWorkUnitRoute('static-asset');
-  return serveImageOptimizer(request, config);
-};
+  setWorkUnitRoute('static-asset')
+  return serveImageOptimizer(request, config)
+}
 
 // Next-compatible images-manifest.json (.next/): the qualities/localpatterns
 // e2e suites read it in production to assert the resolved images config.
 async function writeImagesManifestStep(ctx: BuildStepContext): Promise<void> {
-  const config = ctx.config;
-  if (!nextCompatEnabled(config)) return;
-  const images = getImagesConfig();
+  const config = ctx.config
+  if (!nextCompatEnabled(config)) return
+  const images = getImagesConfig()
 
   // normalizeLocalPatterns already appends the internal media patterns when
   // localPatterns is configured, so manifest and runtime share one source.
-  const localPatterns = manifestLocalPatterns(images.localPatterns);
+  const localPatterns = manifestLocalPatterns(images.localPatterns)
 
   const manifest = {
     version: 1,
@@ -108,11 +108,11 @@ async function writeImagesManifestStep(ctx: BuildStepContext): Promise<void> {
       unoptimized: images.unoptimized,
       customCacheHandler: images.customCacheHandler,
     },
-  };
+  }
 
-  const outDir = path.join(config.root, '.next');
-  await mkdir(outDir, { recursive: true });
-  await writeFile(path.join(outDir, 'images-manifest.json'), JSON.stringify(manifest, null, 2));
+  const outDir = path.join(config.root, '.next')
+  await mkdir(outDir, { recursive: true })
+  await writeFile(path.join(outDir, 'images-manifest.json'), JSON.stringify(manifest, null, 2))
 }
 
 // Tooling (and Next's e2e suites) discover fingerprinted static-import images
@@ -120,12 +120,12 @@ async function writeImagesManifestStep(ctx: BuildStepContext): Promise<void> {
 // outPath/public/_next/static/media. Mirror them into .next so both layouts
 // hold the same files.
 async function mirrorStaticMedia(config: ResolvedConfig): Promise<void> {
-  const { cp } = await import('node:fs/promises');
+  const { cp } = await import('node:fs/promises')
   for (const dir of ['media', 'immutable/media']) {
-    const source = path.join(config.outPath, 'public', '_next', 'static', dir);
-    const target = path.join(config.root, '.next', 'static', dir);
+    const source = path.join(config.outPath, 'public', '_next', 'static', dir)
+    const target = path.join(config.root, '.next', 'static', dir)
     try {
-      await cp(source, target, { recursive: true, force: true });
+      await cp(source, target, { recursive: true, force: true })
     } catch {
       // no static media emitted for this build
     }