@wular/pnext 0.0.24 → 0.1.0

package/src/resolve/scan-facts.ts

@@ -33,6 +33,8 @@ export interface ScanEdge {
   star?: boolean
   /** `export … from` rather than `import`. */
   reexport?: boolean
+  /** Public export name -> name imported from the target. */
+  exportMap?: Record<string, string>
 }
 
 /** One module specifier literal, with the span of its quoted text. */
@@ -192,6 +194,12 @@ export function rewriteFacts(file: string, source: string): RewriteFacts {
   return parsed(file, source).rewrite
 }
 
+/** Every specifier literal with the syntax that determines when it is resolved. */
+export function moduleSpecifierEdges(source: string, file = 'source'): SpecifierEdge[] {
+  const facts = rewriteFacts(file, source)
+  return facts.unreliable ? textualEdges(source) : facts.edges
+}
+
 function parsed(file: string, source: string, lang = langForFile(file)) {
   const key = `${lang}\0${source.length}\0${bun.hash(source).toString()}`
   const cached = memo.get(key)
@@ -216,10 +224,9 @@ export function rewriteSpecifierLiterals(
   file: string,
   replace: (specifier: string, kind: SpecifierEdge['kind']) => string | undefined,
 ): string {
-  const facts = rewriteFacts(file, source)
   // A partially recovered parse has a partial record; the textual scan the
   // folded passes replaced is the safe answer there.
-  const edges = facts.unreliable ? textualEdges(source) : facts.edges
+  const edges = moduleSpecifierEdges(source, file)
   const edits: { start: number; end: number; value: string }[] = []
   for (const edge of edges) {
     const value = replace(edge.specifier, edge.kind)
@@ -341,13 +348,25 @@ function parseFacts(file: string, source: string, lang: ParserLang) {
       if (star) exportStars.push(specifier)
       let edge = edges.get(specifier)
       if (!edge) {
-        edge = { specifier, exports: [], index: statement.start, reexport: true }
+        edge = {
+          specifier,
+          exports: [],
+          index: statement.start,
+          reexport: true,
+          exportMap: {},
+        }
         edges.set(specifier, edge)
         imports.push(edge)
       }
       if (star) edge.star = true
       else if (importKind === 'All') edge.exports.push('*')
-      else if (entry.importName.name) edge.exports.push(entry.importName.name)
+      else {
+        const imported = importKind === 'Default' ? 'default' : entry.importName.name
+        if (!imported) continue
+        edge.exports.push(imported)
+        const exported = exportKind === 'Default' ? 'default' : entry.exportName.name
+        if (exported) edge.exportMap![exported] = imported
+      }
     }
   }
 

package/src/routing/proxy.ts

@@ -231,10 +231,9 @@ export function createProxyRunner(
 
     if (!response) return { request }
 
-    // Same-origin middleware redirects follow the app's trailing-slash rule,
-    // exactly like a direct navigation would (Next normalizes the Location).
-    // skipTrailingSlashRedirect and cross-origin targets are left untouched.
-    response = normalizeRedirectLocation(response, url, config)
+    // Redirects use the router-server envelope: relative same-origin target in
+    // both Location and body, with trailing-slash normalization when enabled.
+    response = await normalizeRedirectResponse(response, url, request.method, config)
 
     const meta = nextResponseMeta(response)
     if (!meta) return response
@@ -299,12 +298,13 @@ export function createProxyRunner(
   return runner
 }
 
-// Apply the app's trailing-slash rule to a same-origin redirect emitted by the
-// middleware (e.g. `NextResponse.redirect(new URL('/somewhere', req.url))` under
-// `trailingSlash: true` must land on `/somewhere/`). Cross-origin targets, the
-// skipTrailingSlashRedirect opt-out, and non-redirect responses pass through.
-function normalizeRedirectLocation(response: Response, requestUrl: URL, config: ResolvedConfig) {
-  if (config.skipTrailingSlashRedirect || !config.trailingSlash) return response
+// Normalize the redirect emitted by middleware into the router-server envelope.
+async function normalizeRedirectResponse(
+  response: Response,
+  requestUrl: URL,
+  method: string,
+  config: ResolvedConfig,
+) {
   if (response.status < 300 || response.status >= 400) return response
   const location = response.headers.get('location')
   if (!location) return response
@@ -314,22 +314,26 @@ function normalizeRedirectLocation(response: Response, requestUrl: URL, config:
   } catch {
     return response
   }
-  if (target.origin !== requestUrl.origin) return response
-  const normalized = canonicalTrailingSlashPath(target.pathname, true)
-  if (normalized === target.pathname) return response
-  target.pathname = normalized
-  try {
-    response.headers.set('location', target.href)
-    return response
-  } catch {
-    const headers = new Headers(response.headers)
-    headers.set('location', target.href)
-    return new Response(response.body, {
-      status: response.status,
-      statusText: response.statusText,
-      headers,
-    })
+  if (target.origin === requestUrl.origin) {
+    if (!config.skipTrailingSlashRedirect && config.trailingSlash) {
+      target.pathname = canonicalTrailingSlashPath(target.pathname, true)
+    }
   }
+  const destination =
+    target.origin === requestUrl.origin
+      ? `${target.pathname}${target.search}${target.hash}`
+      : target.href
+  const headers = new Headers(response.headers)
+  headers.set('location', destination)
+  const body =
+    method.toUpperCase() === 'HEAD' || response.body === null ? null : await response.arrayBuffer()
+  const synthesizeDestination = method.toUpperCase() !== 'HEAD' && (!body || body.byteLength === 0)
+  if (synthesizeDestination) headers.delete('content-length')
+  return new Response(synthesizeDestination ? destination : body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  })
 }
 
 // Human label for the truncation warning ("10MB", "500KB") — whole units only,

package/src/routing/routes.ts

@@ -2342,7 +2342,7 @@ function publishedClientExports(
   const found: ModuleEdge[] = []
   for (const edge of facts.imports) {
     if (!edge.reexport) continue
-    const map = esmReexportMap(source, edge.specifier)
+    const map = { ...esmReexportMap(source, edge.specifier), ...edge.exportMap }
     const next = edge.star
       ? requested.filter(name => name !== 'default')
       : requested.map(name => map[name]).filter((name): name is string => Boolean(name))

package/src/runtime/loader.ts

@@ -131,6 +131,7 @@ const rootPathCache = new Map<string, string[]>()
 const runtimeConfigLookupCache = new Map<string, RuntimeConfig | null>()
 const firstAliasCache = new Map<string, string | null>()
 const transformCache = new Map<string, TransformCacheEntry>()
+const pendingTransforms = new Map<string, Promise<string>>()
 const nodeModuleTransformCache = new Map<string, TransformCacheEntry>()
 // Freshness of generated `.pnext-require.cjs` sidecars (see inlineModuleScopeRequires).
 const requireSidecarCache = new Map<string, { mtimeMs: number; size: number }>()
@@ -427,6 +428,19 @@ async function transformSource(file: string) {
   if (cached?.mtimeMs === fileStat.mtimeMs && cached.size === fileStat.size) {
     return cached.code
   }
+  const pendingKey = `${file}\0${fileStat.mtimeMs}\0${fileStat.size}`
+  const pending = pendingTransforms.get(pendingKey)
+  if (pending) return pending
+  const started = transformSourceUncached(file, fileStat)
+  pendingTransforms.set(pendingKey, started)
+  try {
+    return await started
+  } finally {
+    if (pendingTransforms.get(pendingKey) === started) pendingTransforms.delete(pendingKey)
+  }
+}
+
+async function transformSourceUncached(file: string, fileStat: { mtimeMs: number; size: number }) {
   // The in-memory cache is empty on every restart, so a restarted server
   // re-transforms the whole materialized module set on the request path.
   const diskCache = transformCacheFile(file, fileStat)
@@ -469,11 +483,43 @@ async function transformSource(file: string) {
   })
   if (diskCache) {
     await mkdir(path.dirname(diskCache), { recursive: true }).catch(() => undefined)
-    void writeFileAtomic(diskCache, result.code).catch(() => undefined)
+    // Off the caller's path: a render never waits on the cache it is filling.
+    // Tracked so a process whose whole job IS filling it can await them.
+    const write = writeFileAtomic(diskCache, result.code).catch(() => undefined)
+    transformWrites.add(write)
+    void write.finally(() => transformWrites.delete(write))
   }
   return result.code
 }
 
+// Transform writes in flight; see prewarmServerTransforms.
+const transformWrites = new Set<Promise<unknown>>()
+
+/**
+ * Fill the on-disk transform cache for compiled artifacts a build just wrote.
+ *
+ * Importing a materialized module transforms it first, and that transform is the last piece of the
+ * compile pipeline a built app would otherwise reach on its first served request - esbuild service
+ * child included. Running it here is pure build work on build output: no app module is evaluated,
+ * unlike the import pass the vercel adapter needs for its vendor bundles.
+ */
+export async function prewarmServerTransforms(root: string, files: Iterable<string>) {
+  // The load hook's own filter, so this warms exactly the files an import would
+  // route through it — never a `.css` shim or the natively-loaded vendor tree.
+  const loadable = rootFilter(root)
+  await Promise.all(
+    [...files].map(async file => {
+      if (!loadable.test(file)) return
+      const stats = await stat(file).catch(() => undefined)
+      if (!stats || !transformCacheFile(file, stats)) return
+      await transformSource(file).catch(() => undefined)
+    }),
+  )
+  // Settle the writes above, or this process exits with entries in flight and
+  // the next boot recompiles exactly what this pass was for.
+  while (transformWrites.size > 0) await Promise.all([...transformWrites])
+}
+
 // eslint-disable-next-line turbo/no-undeclared-env-vars
 const transformDiskCacheDisabled = process.env.PNEXT_TRANSFORM_DISK_CACHE === '0'
 const materializedSegment = `${path.sep}cache${path.sep}server${path.sep}`