@wular/pnext 0.0.24 → 0.1.0

package/src/client/router/types.ts

@@ -4,6 +4,8 @@ export interface PrefetchedPage {
   html: string
   finalUrl: string
   ok: boolean
+  /** Entry-bound whole-page client props restored before mounting a history traversal. */
+  p?: unknown
   /** `x-nextjs-stale-time` from the response (seconds), when the server sent it. */
   staleTimeSeconds?: number
   /** Complete body segment was emitted from a prerendered route artifact. */
@@ -207,6 +209,12 @@ export interface SegmentCacheRecord {
   static: boolean
   /** True when the payload came from a runtime (request-sampled) prefetch. */
   runtime: boolean
+  /**
+   * The server DECLARED this payload its POSTPONED (PPR) shell for this exact URL - the
+   * truncated prefetch response `x-nextjs-postponed` marks. Such a payload is the
+   * destination's own prerendered static stage, holes and all.
+   */
+  postponedShell?: boolean
 }
 
 export interface SegmentCacheLookup {
@@ -226,6 +234,13 @@ export interface SegmentCacheHit {
    * dynamic remainder. Absent (older policies) reads as `networkFree`.
    */
   prefetchSatisfied?: boolean
+  /**
+   * This hit is THIS URL's own postponed (PPR) shell - the static stage the server
+   * prerendered for it, not a sibling's bytes. It paints even when its whole page is one
+   * unresolved boundary, because that boundary IS what the destination renders until its
+   * dynamic stage lands.
+   */
+  postponedShell?: boolean
 }
 
 export interface SegmentCachePolicy {

package/src/compat/actions/client-plugin.ts

@@ -117,6 +117,10 @@ export function actionClientStubPlugin(): Plugin {
 
 async function stubSourceFor(file: string, root?: string) {
   const source = await readText(file)
+  return stubSourceFromSource(file, source, root)
+}
+
+export function stubSourceFromSource(file: string, source: string, root?: string) {
   if (!moduleLevelUseServer(source) && !moduleLevelUseCache(source)) return 'export {};'
   const exports = moduleActionExports(source)
   const actionIds: Record<string, string> = {}
@@ -124,6 +128,12 @@ async function stubSourceFor(file: string, root?: string) {
   return clientStubSource({ modulePath: file, exports, actionIds })
 }
 
+export async function loadClientActionSource(file: string, root?: string) {
+  const source = await readText(file)
+  if (!moduleLevelUseServer(source) && !moduleLevelUseCache(source)) return { source }
+  return { source, stubSource: stubSourceFromSource(file, source, root) }
+}
+
 /**
  * Compute an action wire id from a realpath-canonical (file, root) basis so every producer -
  * discovery/registry, the client stub, and render-side form tagging - agrees regardless of

package/src/compat/actions/rewrite.ts

@@ -24,6 +24,7 @@ export function rewriteInlineActionTags(source: string, file: string, root?: str
   const insertions: { at: number; text: string }[] = []
   const fallbacks: string[] = []
   for (const action of topLevel) {
+    if (source.includes(`__pnextTagInlineAction(${action.name},`)) continue
     const id = inlineActionId(key, action.name)
     const tag = `\n;typeof ${action.name} === 'function' && globalThis.__pnextTagInlineAction && globalThis.__pnextTagInlineAction(${action.name}, ${JSON.stringify(id)});`
     const at = declarationEnd(source, action.directiveEnd)

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

@@ -2,18 +2,19 @@
 // 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.
+// Rewrite `import { A, B } from 'pkg'` into per-member imports of the LEAF modules. Configured and
+// Next-default packages use explicit re-exports; large generated catalogues are detected from their
+// export/leaf shape. Each leaf becomes an ordinary vendor demand, so the existing per-package grouping
+// compiles demanded subpaths as entries of one `splitting: true` build.
 //
 // 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.
+// listed entries must be pure re-export barrels, and automatic catalogue detection additionally
+// verifies each export's re-export target against its same-named sibling file, or - for a catalogue
+// that aliases many names onto few leaves - that the entry is nothing but unambiguous re-exports.
 
 import path from 'node:path'
-import { readFileSync } from 'node:fs'
+import { readFileSync, readdirSync, statSync } from 'node:fs'
 // Lazy: the oxc-parser native binding costs ~12.6 MB RSS; load it only when a parse happens.
 const parseSync: typeof import('oxc-parser').parseSync = (...args) =>
   // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -23,12 +24,12 @@ import { rewriteFacts, type ImportBinding } from '../../resolve/scan-facts'
 import { spliceSource } from '../../runtime/module-transform'
 import { resolvePackageSpecifier, resolveVendorPackageSpecifier } from '../../resolve/imports'
 import { withSniff, type ServerSourceTransform } from '../../extensions'
-import { specifierSniffTokens } from '../../utils/code'
+import { escapeRegex, stripComments } from '../../utils/code'
 
 /**
  * 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.
+ * dominant cost. Extended by the config option. Every name is still gated by the applicable derivation
+ * below, so a package that fails its safety gate costs nothing but one parse.
  */
 const DEFAULT_OPTIMIZED_PACKAGES = [
   'lucide-react',
@@ -57,6 +58,11 @@ const DEFAULT_OPTIMIZED_PACKAGES = [
   'rxjs',
 ]
 
+const GENERATED_BARREL_MIN_BYTES = 64 * 1024
+const GENERATED_BARREL_MIN_EXPORTS = 16
+const GENERATED_BARREL_LEAF_RATIO = 0.8
+const OPTIMIZE_PACKAGE_IMPORTS_SNIFF_TOKENS = ['import'] as const
+
 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
@@ -72,6 +78,8 @@ interface BarrelMember {
   source: string
   /** The name to take from it: `default`, `*`, or an export name. */
   imported: string
+  /** Font Awesome entry binding, checked lazily against the demanded leaf. */
+  fontAwesomeLocal?: string
 }
 
 /** The exported names a pure re-export barrel publishes, and their leaves. */
@@ -80,19 +88,19 @@ 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.
+ * The leaf map of a barrel entry, or undefined when its configured/automatic
+ * safety gate fails. Cached per entry file and mode.
  */
-function barrelMap(entry: string): BarrelMap | undefined {
-  if (barrelMaps.has(entry)) return barrelMaps.get(entry)
+function barrelMap(entry: string, automatic: boolean): BarrelMap | undefined {
+  const key = `${automatic ? 'auto' : 'listed'}\0${entry}`
+  if (barrelMaps.has(key)) return barrelMaps.get(key)
   let map: BarrelMap | undefined
   try {
-    map = parseBarrel(entry)
+    map = automatic ? parseGeneratedBarrel(entry) : parseBarrel(entry)
   } catch {
     map = undefined
   }
-  barrelMaps.set(entry, map)
+  barrelMaps.set(key, map)
   return map
 }
 
@@ -136,18 +144,241 @@ function parseBarrel(entry: string): BarrelMap | undefined {
         const imported =
           kind === 'Default' ? 'default' : kind === 'All' ? '*' : record.importName.name
         if (!imported) return undefined
-        members.set(exported, { source: request, imported })
+        if (!addMember(members, exported, { source: request, imported })) return undefined
         continue
       }
       const local = record.localName.name
       const namespace = local === null ? undefined : namespaces.get(local)
       if (!namespace) return undefined
-      members.set(exported, { source: namespace, imported: '*' })
+      if (!addMember(members, exported, { source: namespace, imported: '*' })) return undefined
     }
   }
   return members.size > 0 ? members : undefined
 }
 
+function addMember(members: Map<string, BarrelMember>, name: string, member: BarrelMember) {
+  const prior = members.get(name)
+  if (prior && (prior.source !== member.source || prior.imported !== member.imported)) return false
+  members.set(name, member)
+  return true
+}
+
+/**
+ * Detect generated catalogues whose entry explicitly re-exports same-named
+ * sibling modules. Requiring a large entry, a side-effect-free package, and an
+ * overwhelming filename/export match keeps this automatic path away from
+ * ordinary package entries. Inline definitions are not equivalent merely
+ * because a sibling has the same name; the only exception is Font Awesome's
+ * generated Pro/Sharp shape, whose leaf definition is checked against the
+ * entry definition before it is mapped.
+ */
+function parseGeneratedBarrel(entry: string): BarrelMap | undefined {
+  if (statSync(entry).size < GENERATED_BARREL_MIN_BYTES) return undefined
+  const packageDir = packageDirOf(entry)
+  if (!packageDir || !packageHasNoSideEffects(packageDir)) return undefined
+
+  const source = readFileSync(entry, 'utf8')
+  if (isGeneratedFontAwesomePackage(packageDir)) {
+    return parseGeneratedFontAwesomeBarrel(entry, source)
+  }
+  const parsed = parseSync(entry, source, { lang: 'js' })
+  if (parsed.errors.length > 0) return undefined
+  const siblings = siblingFilesByStem(path.dirname(entry), entry)
+  const exports = new Map<string, BarrelMember>()
+  const exportNames = new Set<string>()
+  let exportCount = 0
+  for (const statement of parsed.module.staticExports) {
+    for (const record of statement.entries) {
+      if (record.isType) continue
+      const name = record.exportName.name
+      if (!name || exportNames.has(name)) return undefined
+      exportNames.add(name)
+      exportCount++
+      const request = record.moduleRequest?.value
+      if (!request) {
+        return undefined
+      }
+      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
+      exports.set(name, { source: request, imported })
+    }
+  }
+  if (exportCount < GENERATED_BARREL_MIN_EXPORTS) return undefined
+
+  const members = new Map<string, BarrelMember>()
+  for (const [name, member] of exports) {
+    const files = siblings.get(name)
+    const file = files?.[0]
+    if (
+      file &&
+      files.length === 1 &&
+      path.resolve(path.dirname(entry), member.source) === path.resolve(path.dirname(entry), file)
+    ) {
+      members.set(name, member)
+    }
+  }
+  if (members.size / exportCount >= GENERATED_BARREL_LEAF_RATIO) return members
+  return manyToFewBarrelMembers(parsed.program.body, exports, entry)
+}
+
+/**
+ * The same-named-sibling ratio describes one-export-per-file catalogues. A generated barrel may
+ * instead publish thousands of aliases over a handful of leaves, where no export name is a filename.
+ * The invariant that makes THAT shape safe is the one the listed path already relies on: every
+ * demanded name resolves statically to exactly one re-export record, and the entry runs no code
+ * beyond those re-exports. Members whose leaf stem is ambiguous on disk are dropped, so a demanded
+ * name that could resolve to a different extension stays on the barrel. Leaf contents are still only
+ * read for demanded members.
+ */
+function manyToFewBarrelMembers(
+  body: readonly { type: string; declaration?: unknown }[],
+  exports: ReadonlyMap<string, BarrelMember>,
+  entry: string,
+): BarrelMap | undefined {
+  for (const node of body) {
+    if (node.type !== 'ExportNamedDeclaration' || node.declaration) return undefined
+  }
+  const byDirectory = new Map<string, Map<string, string[]>>()
+  const members = new Map<string, BarrelMember>()
+  for (const [name, member] of exports) {
+    if (!member.source.startsWith('.')) continue
+    const file = path.resolve(path.dirname(entry), member.source)
+    const directory = path.dirname(file)
+    let siblings = byDirectory.get(directory)
+    if (!siblings) {
+      siblings = siblingFilesByStem(directory, entry)
+      byDirectory.set(directory, siblings)
+    }
+    if (siblings.get(path.basename(file).replace(/\.(?:c|m)?js$/, ''))?.length !== 1) continue
+    members.set(name, member)
+  }
+  return members.size > 0 ? members : undefined
+}
+
+/** The `.js`-family files of a directory, grouped by stem, so an ambiguous stem is visible. */
+function siblingFilesByStem(directory: string, exclude: string) {
+  const siblings = new Map<string, string[]>()
+  for (const file of readdirSync(directory)) {
+    const match = /^(.*)\.(?:c|m)?js$/.exec(file)
+    if (!match?.[1] || path.resolve(directory, file) === exclude) continue
+    const files = siblings.get(match[1]) ?? []
+    files.push(file)
+    siblings.set(match[1], files)
+  }
+  return siblings
+}
+
+function isGeneratedFontAwesomePackage(packageDir: string) {
+  const packageName = packageNameOfDir(packageDir)
+  return packageName !== undefined && /^@fortawesome\/(?:pro|sharp)-.+-svg-icons$/.test(packageName)
+}
+
+/**
+ * Font Awesome's generated Pro/Sharp entries are multi-megabyte inline catalogues with one final
+ * export list. Parsing the whole catalogue synchronously costs more than a second per style even
+ * though an import demands only a handful of leaves. Read that explicit export list directly, then
+ * retain the same per-demand definition/leaf identity check in `resolveLeafSpecifier`.
+ */
+function parseGeneratedFontAwesomeBarrel(entry: string, source: string): BarrelMap | undefined {
+  const start = source.lastIndexOf('\nexport {')
+  if (start < 0) return undefined
+  const open = source.indexOf('{', start)
+  const close = source.indexOf('};', open + 1)
+  if (open < 0 || close < 0 || source.slice(close + 2).trim() !== '') return undefined
+
+  const siblings = siblingFilesByStem(path.dirname(entry), entry)
+
+  const members = new Map<string, BarrelMember>()
+  let exportCount = 0
+  for (const raw of source.slice(open + 1, close).split(',')) {
+    const match = /^\s*([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?\s*$/.exec(raw)
+    if (!match?.[1]) return undefined
+    const local = match[1]
+    const exported = match[2] ?? local
+    exportCount++
+    const files = siblings.get(exported)
+    const file = files?.[0]
+    if (!file || files.length !== 1 || members.has(exported)) continue
+    members.set(exported, {
+      source: `./${file}`,
+      imported: exported,
+      fontAwesomeLocal: local,
+    })
+  }
+  if (exportCount < GENERATED_BARREL_MIN_EXPORTS) return undefined
+  if (members.size / exportCount < GENERATED_BARREL_LEAF_RATIO) return undefined
+  fontAwesomeBarrelSources.set(entry, source)
+  return members
+}
+
+const fontAwesomeBarrelSources = new Map<string, string>()
+
+function leafMatchesFontAwesomeDefinition(file: string, exported: string, definition: string) {
+  const leaf = readFileSync(file, 'utf8')
+  if (
+    !new RegExp(`(?:^|\\n)exports\\.${escapeRegex(exported)}\\s*=\\s*exports\\.definition;`).test(
+      leaf,
+    )
+  ) {
+    return false
+  }
+  for (const field of ['prefix', 'iconName', 'unicode', 'svgPathData']) {
+    const match = new RegExp(`(?:^|\\n)var ${field} = (['"])(.*)\\1;`).exec(leaf)
+    if (!match?.[2] || !definition.includes(match[2])) return false
+  }
+  return true
+}
+
+function fontAwesomeEntryDefinition(source: string, exportedLocal: string) {
+  let local = exportedLocal
+  const visited = new Set<string>()
+  while (!visited.has(local)) {
+    visited.add(local)
+    const marker = `var ${local} = `
+    const markerAt = source.indexOf(`\n${marker}`)
+    const start = markerAt >= 0 ? markerAt + 1 : source.startsWith(marker) ? 0 : -1
+    if (start < 0) return undefined
+    const valueStart = start + marker.length
+    if (source[valueStart] === '{') {
+      const end = source.indexOf('\n};', valueStart)
+      return end < 0 ? undefined : source.slice(start, end + 3)
+    }
+    const end = source.indexOf(';', valueStart)
+    if (end < 0) return undefined
+    const alias = source.slice(valueStart, end).trim()
+    if (!/^[A-Za-z_$][\w$]*$/.test(alias)) return undefined
+    local = alias
+  }
+  return undefined
+}
+
+function packageHasNoSideEffects(packageDir: string) {
+  return packageMetadata(packageDir)?.sideEffects === false
+}
+
+const packageMetadataCache = new Map<
+  string,
+  { sideEffects?: unknown; exports?: unknown } | undefined
+>()
+
+function packageMetadata(packageDir: string) {
+  if (packageMetadataCache.has(packageDir)) return packageMetadataCache.get(packageDir)
+  let metadata: { sideEffects?: unknown; exports?: unknown } | undefined
+  try {
+    metadata = JSON.parse(readFileSync(path.join(packageDir, 'package.json'), 'utf8')) as {
+      sideEffects?: unknown
+      exports?: unknown
+    }
+  } catch {
+    metadata = undefined
+  }
+  packageMetadataCache.set(packageDir, metadata)
+  return metadata
+}
+
 /**
  * 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
@@ -169,7 +400,7 @@ function barrelEntry(root: string, file: string, specifier: string) {
  * because one rewritten source is compiled for both.
  */
 function leafSpecifier(root: string, entry: string, member: BarrelMember): string | undefined {
-  const key = `${entry}\0${member.source}`
+  const key = `${entry}\0${member.source}\0${member.imported}`
   if (leafSpecifiers.has(key)) return leafSpecifiers.get(key)
   const specifier = resolveLeafSpecifier(root, entry, member)
   leafSpecifiers.set(key, specifier)
@@ -184,16 +415,121 @@ 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)
+  if (member.fontAwesomeLocal) {
+    const source = fontAwesomeBarrelSources.get(entry)
+    const definition = source && fontAwesomeEntryDefinition(source, member.fontAwesomeLocal)
+    if (!definition || !leafMatchesFontAwesomeDefinition(file, member.imported, definition)) {
+      return undefined
+    }
+  }
   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
+  const subpath = relative.split(path.sep).join('/')
+  const extensionless = subpath.replace(/\.(?:c|m)?js$/, '')
+  const full = `${name}/${subpath}`
+  const short = `${name}/${extensionless}`
+  const mirrored =
+    packageMetadata(packageDir)?.exports === undefined || extensionless === subpath
+      ? [full]
+      : [short, full]
+  // The published subpath first: a package whose `exports` maps its leaves under a rewritten prefix
+  // (`"./icons/*": "./dist/icons/*.js"`) has no public specifier that mirrors the file path, and
+  // pnext's resolver would otherwise settle for one `exports` withholds.
+  const candidates = new Set([...exportsMapSpecifiers(packageDir, name, subpath), ...mirrored])
+  for (const specifier of candidates) {
+    if (
+      [CLIENT_CONDITIONS, SERVER_CONDITIONS].every(
+        conditions => resolvePackageSpecifier(root, entry, specifier, conditions) === file,
+      ) &&
+      leafHasExport(file, member.imported)
+    ) {
+      return specifier
+    }
   }
-  return specifier
+  return undefined
+}
+
+/**
+ * The specifiers a package's `exports` map could publish a leaf file under, by inverting each
+ * subpath target against the file. Only a proposal: every candidate is still accepted by
+ * re-resolving it back to the same file under both layers' conditions.
+ */
+function exportsMapSpecifiers(packageDir: string, name: string, subpath: string): string[] {
+  const map = packageMetadata(packageDir)?.exports
+  if (map === undefined) return []
+  const target = `./${subpath}`
+  const specifiers: string[] = []
+  const visit = (key: string, value: unknown) => {
+    if (typeof value === 'string') {
+      const matched = matchExportsTarget(key, value, target)
+      if (matched !== undefined)
+        specifiers.push(`${name}${matched === '.' ? '' : matched.slice(1)}`)
+      return
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) visit(key, item)
+      return
+    }
+    if (!value || typeof value !== 'object') return
+    for (const [inner, nested] of Object.entries(value)) {
+      visit(inner.startsWith('.') ? inner : key, nested)
+    }
+  }
+  visit('.', map)
+  return specifiers
+}
+
+/** The subpath key `target` publishes `file` under, substituting one wildcard. */
+function matchExportsTarget(key: string, target: string, file: string) {
+  if (!key.startsWith('.')) return undefined
+  const star = target.indexOf('*')
+  if (star < 0) return target === file ? key : undefined
+  const prefix = target.slice(0, star)
+  const suffix = target.slice(star + 1)
+  if (!file.startsWith(prefix) || !file.endsWith(suffix)) return undefined
+  const value = file.slice(prefix.length, file.length - suffix.length)
+  return value && key.includes('*') ? key.replace('*', value) : undefined
+}
+
+const leafExports = new Map<string, ReadonlySet<string> | undefined>()
+
+function leafHasExport(file: string, name: string) {
+  if (name === '*') return true
+  if (!leafExports.has(file)) {
+    let names: Set<string> | undefined
+    try {
+      const source = readFileSync(file, 'utf8')
+      const parsed = parseSync(file, source, { lang: 'js' })
+      if (parsed.errors.length === 0) {
+        names = new Set<string>()
+        for (const statement of parsed.module.staticExports) {
+          for (const record of statement.entries) {
+            if (record.isType) continue
+            const kind: string = record.exportName.kind
+            if (kind === 'Default') names.add('default')
+            else if (record.exportName.name) names.add(record.exportName.name)
+          }
+        }
+        const code = stripComments(source)
+        for (const match of code.matchAll(/(?:^|\n)\s*exports\.([A-Za-z_$][\w$]*)\s*=/g)) {
+          if (match[1]) names.add(match[1])
+        }
+        if (/(?:^|\n)\s*module\.exports\s*=/.test(code)) names.add('default')
+      }
+    } catch {
+      names = undefined
+    }
+    leafExports.set(file, names)
+  }
+  const names = leafExports.get(file)
+  if (names?.has(name)) return true
+  // Computed CommonJS export names are rare but valid identifiers in generated leaves.
+  if (!names) return false
+  const source = stripComments(readFileSync(file, 'utf8'))
+  return new RegExp(`(?:^|\\n)\\s*exports\\[(['"])${escapeRegex(name)}\\1\\]\\s*=`).test(source)
 }
 
 /** The installed package a barrel entry belongs to, by its `node_modules` segment. */
@@ -263,13 +599,14 @@ export function createOptimizePackageImportsTransform(
 ): 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
+  return withSniff(OPTIMIZE_PACKAGE_IMPORTS_SNIFF_TOKENS, (source, file) => {
     const edits: { start: number; end: number; value: string }[] = []
     for (const statement of rewriteFacts(file, source).imports) {
-      if (!optimized.has(statement.specifier)) continue
+      const listed = optimized.has(statement.specifier)
+      if (!listed && packageNameOfDirSpecifier(statement.specifier) !== statement.specifier)
+        continue
       const entry = barrelEntry(root, file, statement.specifier)
-      const map = entry && barrelMap(entry)
+      const map = entry && barrelMap(entry, !listed)
       if (!map || !entry) continue
       const expanded = expandBarrelImport(statement.bindings, map, root, entry)
       if (expanded !== undefined) {
@@ -279,3 +616,13 @@ export function createOptimizePackageImportsTransform(
     return edits.length > 0 ? spliceSource(source, edits) : source
   })
 }
+
+function packageNameOfDirSpecifier(specifier: string) {
+  const parts = specifier.split('/')
+  return specifier.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]
+}
+
+/** Sniff used by load hooks that re-offer this transform outside source roots. */
+export function optimizePackageImportsSniffTokens(packages: readonly string[]) {
+  return packages.length > 0 ? OPTIMIZE_PACKAGE_IMPORTS_SNIFF_TOKENS : []
+}

package/src/compat/client/navigation-scroll.ts

@@ -20,7 +20,33 @@ export function topOnlyScrollPosition(scrollX: number): [number, number] {
   return [scrollX, 0]
 }
 
+// A pop restore fires right after the body swap, when the incoming tree can still be shorter
+// than the saved offset — the browser clamps scrollTo against the live height and the position
+// is lost even though a reapply comes a frame later. Reserving the departing document's
+// recorded height keeps the restore un-clamped; released once content is tall enough (the
+// reapply) or on the next navigation of any kind. The attribute both marks the reservation as
+// pnext's own and preserves an app-authored inline min-height for the release.
+const SCROLL_RESERVE_ATTR = 'data-pnext-scroll-reserve'
+
+function releaseScrollHeightReservation() {
+  const root = document.documentElement
+  const original = root.getAttribute(SCROLL_RESERVE_ATTR)
+  if (original === null) return
+  root.removeAttribute(SCROLL_RESERVE_ATTR)
+  root.style.minHeight = original
+}
+
+function restoreScrollWithReservedHeight(x: number, y: number, height: number | undefined) {
+  const root = document.documentElement
+  if (height && root.scrollHeight < y + root.clientHeight) {
+    root.setAttribute(SCROLL_RESERVE_ATTR, root.style.minHeight)
+    root.style.minHeight = `${height}px`
+  }
+  window.scrollTo(x, y)
+}
+
 export const applyNextNavigationScroll: NavigationScrollAction = (url, options) => {
+  releaseScrollHeightReservation()
   const segmentElements = changedSegmentElements()
   const target = scrollFocusTarget(segmentElements)
   const plan = nextScrollPlan(
@@ -29,9 +55,9 @@ export const applyNextNavigationScroll: NavigationScrollAction = (url, options)
     target ? targetTopInViewport(target, document.documentElement.clientHeight) : undefined,
   )
   if (plan === 'restore') {
-    const state = history.state as { __pnextScroll?: [number, number] } | null
-    const [x, y] = state?.__pnextScroll ?? [0, 0]
-    window.scrollTo(x, y)
+    const state = history.state as { __pnextScroll?: [number, number, number?] } | null
+    const [x, y, height] = state?.__pnextScroll ?? [0, 0]
+    restoreScrollWithReservedHeight(x, y, height)
     return
   }
   // React hoists a rendered <style precedence>/<link rel=stylesheet>/metadata element out of the segment

package/src/compat/client/optimistic-routing.ts

@@ -165,12 +165,12 @@ function materializeClientMarkers(doc: Document): void {
   const walker = doc.createTreeWalker(doc, NodeFilter.SHOW_COMMENT)
   while (walker.nextNode()) comments.push(walker.currentNode as Comment)
   for (const start of comments.reverse()) {
-    const match = /^(pnext-client|pnext-page):([^>]*)$/.exec(start.data)
+    const match = /^(pnext-client|pnext-static-children|pnext-page):([^>]*)$/.exec(start.data)
     const kind = match?.[1]
     const encoded = match?.[2]
     if (!kind || !encoded || !start.parentNode) continue
     const container = doc.createElement('div')
-    const tag = kind === 'pnext-page' ? 'div' : 'pnext-client'
+    const tag = kind === 'pnext-page' ? 'div' : kind
     container.innerHTML = `<${tag} ${encoded}></${tag}>`
     const island = container.firstElementChild
     if (!island) continue