@wular/pnext 0.0.24 → 0.1.1

package/src/runtime/vendor-build.ts

@@ -10,7 +10,7 @@
  */
 
 import { builtinModules, createRequire } from 'node:module'
-import { existsSync, readFileSync, statSync } from 'node:fs'
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs'
 import { copyFile, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -104,6 +104,8 @@ export function clearServerRuntimeCaches() {
   clearVendorPipeline()
   clearVendorNativeCaches()
   vendorEntryResolutions.clear()
+  canonicalVendorEntries.clear()
+  nearestManifestDirs.clear()
   clearVendorPackageResolutions()
   vendorLayerRecords.clear()
   vendorSharedEntries.clear()
@@ -209,23 +211,40 @@ function resolveVendorEntry(
   resolveDir: string,
   conditionTarget: ServerBundleTarget,
 ) {
-  if (path.isAbsolute(specifier)) return path.resolve(specifier)
   // Every demand builds a plan before dedup can see it, so this resolve runs
   // once per DEMAND, not once per artifact — and the same specifier arrives
   // from hundreds of importers. The answer is pure in its inputs.
   const key = `${config.root}\0${conditionTarget}\0${resolveDir}\0${specifier}`
   if (vendorEntryResolutions.has(key)) return vendorEntryResolutions.get(key)
-  const entry = resolveVendorPackageSpecifier(
-    config.root,
-    path.join(resolveDir, 'pnext-resolve.ts'),
-    specifier,
-    [...serverBundleConditions(conditionTarget), 'import'],
+  const entry = canonicalVendorEntry(
+    path.isAbsolute(specifier)
+      ? path.resolve(specifier)
+      : resolveVendorPackageSpecifier(
+          config.root,
+          path.join(resolveDir, 'pnext-resolve.ts'),
+          specifier,
+          [...serverBundleConditions(conditionTarget), 'import'],
+        ),
   )
   vendorEntryResolutions.set(key, entry)
   return entry
 }
 
+function canonicalVendorEntry(entry: string | undefined) {
+  if (!entry) return entry
+  if (canonicalVendorEntries.has(entry)) return canonicalVendorEntries.get(entry)!
+  let canonical = entry
+  try {
+    canonical = realpathSync.native(entry)
+  } catch {
+    // Keep the unresolved path when the file disappeared between resolution and canonicalization.
+  }
+  canonicalVendorEntries.set(entry, canonical)
+  return canonical
+}
+
 const vendorEntryResolutions = new Map<string, string | undefined>()
+const canonicalVendorEntries = new Map<string, string>()
 
 function vendorBuildPlan(
   config: ResolvedConfig,
@@ -940,10 +959,10 @@ async function preplanDependencyDecision(
   resolveDir: string,
 ): Promise<OnResolveResult | undefined> {
   const depName = packageNameFromSpecifier(specifier)
-  if (!depName || !isPackageSpecifier(specifier)) return undefined
-  if (builtinModules.includes(depName) || isBunBuiltin(depName)) return undefined
-  if (getExternalPackagePolicy().external(depName)) return undefined
-  if (getExternalPackagePolicy().transpile(depName)) return undefined
+  if (!isVendorModuleSpecifier(specifier)) return undefined
+  if (depName && (builtinModules.includes(depName) || isBunBuiltin(depName))) return undefined
+  if (depName && getExternalPackagePolicy().external(depName)) return undefined
+  if (depName && getExternalPackagePolicy().transpile(depName)) return undefined
   const entry = resolveVendorEntry(config, specifier, resolveDir, conditionTarget)
   if (!entry || /\.[cm]?tsx?$/.test(entry) || !isEsmModuleEntry(entry)) return undefined
   const plan = vendorBuildPlan(config, specifier, target, resolveDir, conditionTarget)
@@ -1251,7 +1270,16 @@ async function buildVendorGroupWithPlugins(
       reactServerLayer: target === 'server',
     }),
     vendorGroupSiblingPlugin(siblings),
-    externalPackageDependencyPlugin(config, packageName, target, conditionTarget, context, preplan),
+    externalPackageDependencyPlugin(
+      config,
+      packageName,
+      target,
+      conditionTarget,
+      resolveDir,
+      entryPoints.map(entry => entry.in),
+      context,
+      preplan,
+    ),
     externalBuiltinBuildPlugin(),
   ])
   if (trace) trace.plugins = groupPlugins.map(plugin => plugin.name)
@@ -1720,15 +1748,32 @@ function vendorPackageShape(request: VendorNativeRequest): VendorPackageShape {
 }
 
 function nearestManifestDir(from: string) {
+  if (nearestManifestDirs.has(from)) return nearestManifestDirs.get(from)
   let dir = from
   while (true) {
-    if (existsSync(path.join(dir, 'package.json'))) return dir
+    const manifest = path.join(dir, 'package.json')
+    if (existsSync(manifest)) {
+      try {
+        const parsed = JSON.parse(readFileSync(manifest, 'utf8')) as { name?: unknown }
+        if (typeof parsed.name === 'string') {
+          nearestManifestDirs.set(from, dir)
+          return dir
+        }
+      } catch {
+        // Malformed manifests cannot establish a package root; continue walking.
+      }
+    }
     const parent = path.dirname(dir)
-    if (parent === dir) return undefined
+    if (parent === dir) {
+      nearestManifestDirs.set(from, undefined)
+      return undefined
+    }
     dir = parent
   }
 }
 
+const nearestManifestDirs = new Map<string, string | undefined>()
+
 /**
  * Decide what each external reference in the emitted code means - the work the resolve callbacks used
  * to do, off the bundler's critical path. Undefined when a reference cannot be expressed as a rewrite
@@ -1899,8 +1944,11 @@ async function preplanVendorRefUncached(
     )
     return asset ? { kind: 'inline', file: asset } : undefined
   }
-  if (!depName || !isPackageSpecifier(specifier)) return undefined
-  if (getExternalPackagePolicy().external(depName)) {
+  if (sameVendorPackageFile(specifier, importerFile)) {
+    return { kind: 'inline', file: canonicalVendorEntry(specifier)! }
+  }
+  if (!isVendorModuleSpecifier(specifier)) return undefined
+  if (depName && getExternalPackagePolicy().external(depName)) {
     const fromImporter = resolveNestedPackageFromImporter(importerFile, specifier, conditions)
     const fromRoot = resolveVendorPackageSpecifier(
       config.root,
@@ -1990,11 +2038,14 @@ async function decideVendorRefUncached(
     )
     return asset ? { kind: 'inline', file: asset } : undefined
   }
-  if (!depName || !isPackageSpecifier(specifier)) return undefined
+  if (sameVendorPackageFile(specifier, importerFile)) {
+    return { kind: 'inline', file: canonicalVendorEntry(specifier)! }
+  }
+  if (!isVendorModuleSpecifier(specifier)) return undefined
 
   // B7: a serverExternalPackage stays external, pinned to the importing
   // package's own copy when that differs from the hoisted root version.
-  if (getExternalPackagePolicy().external(depName)) {
+  if (depName && getExternalPackagePolicy().external(depName)) {
     const fromImporter = resolveNestedPackageFromImporter(importerFile, specifier, conditions)
     const fromRoot = resolveVendorPackageSpecifier(
       config.root,
@@ -2334,7 +2385,16 @@ async function bundleExternalPackageImpl(
       // bundles are the SSR pass and keep the full-hooks shim).
       reactServerLayer: target === 'server',
     }),
-    externalPackageDependencyPlugin(config, specifier, target, conditionTarget, context, preplan),
+    externalPackageDependencyPlugin(
+      config,
+      specifier,
+      target,
+      conditionTarget,
+      resolveDir,
+      nativeEntry ? [nativeEntry] : [],
+      context,
+      preplan,
+    ),
     externalBuiltinBuildPlugin(),
   ])
   if (trace) trace.plugins = vendorPlugins.map(plugin => plugin.name)
@@ -2410,16 +2470,32 @@ function externalPackageDependencyPlugin(
   entrySpecifier: string,
   target: CompatAliasTarget,
   conditionTarget: ServerBundleTarget,
+  resolveDir: string,
+  ownEntries: string[],
   context?: { nestedExternalFiles: string[] },
   preplan = false,
 ): Plugin {
   const entryPackageName = packageNameFromSpecifier(entrySpecifier)
+  const ownPackageRoots = new Set(
+    [...ownEntries, resolveVendorEntry(config, entrySpecifier, resolveDir, conditionTarget)]
+      .filter((entry): entry is string => entry !== undefined)
+      .map(entry => nearestManifestDir(path.dirname(canonicalVendorEntry(entry)!)))
+      .filter((root): root is string => root !== undefined),
+  )
   return {
     name: 'pnext-external-package-dependencies',
     setup(build) {
-      build.onResolve({ filter: /^[^./].*/ }, async args => {
-        if (!isPackageSpecifier(args.path)) return undefined
-        if (packageNameFromSpecifier(args.path) === entryPackageName) return undefined
+      build.onResolve({ filter: /^(?:\/|[^./]).*/ }, async args => {
+        if (!isVendorModuleSpecifier(args.path)) return undefined
+        if (args.kind === 'entry-point') return undefined
+        const ownRoot = path.isAbsolute(args.path)
+          ? nearestManifestDir(path.dirname(canonicalVendorEntry(args.path)!))
+          : undefined
+        if (ownRoot && ownPackageRoots.has(ownRoot)) return undefined
+        if (sameVendorPackageFile(args.path, args.importer)) return undefined
+        if (entryPackageName && packageNameFromSpecifier(args.path) === entryPackageName) {
+          return undefined
+        }
         if (preplan && args.kind !== 'require-call') {
           const planned = await preplanDependencyDecision(
             config,
@@ -2627,6 +2703,17 @@ function isPackageSpecifier(specifier: string) {
   return Boolean(packageName && !builtinModules.includes(packageName))
 }
 
+function isVendorModuleSpecifier(specifier: string) {
+  return path.isAbsolute(specifier) || isPackageSpecifier(specifier)
+}
+
+function sameVendorPackageFile(specifier: string, importer: string) {
+  if (!path.isAbsolute(specifier) || !path.isAbsolute(importer)) return false
+  const entryRoot = nearestManifestDir(path.dirname(canonicalVendorEntry(specifier)!))
+  const importerRoot = nearestManifestDir(path.dirname(canonicalVendorEntry(importer)!))
+  return entryRoot !== undefined && entryRoot === importerRoot
+}
+
 // Trace copies of nested transitive externals (a version distinct from the
 // hoisted root copy) written alongside the vendor bundle as `.js`, so file
 // tracing / server-bundle scans observe the bundled dependency the way

package/src/runtime/vendor.ts

@@ -1028,14 +1028,14 @@ export async function cjsEntryMayHaveNamedExports(entry: string) {
  * full cache wipe recovers from. A new key sidesteps both: the old facade stays on disk for whoever still
  * imports it, and every new compile names the new one.
  */
-const FACADE_GENERATOR = 'v2'
+const FACADE_GENERATOR = 'v3'
 
 /** Marker written beside a bundle whose export set turned out to be default-only. */
 const NO_FACADE_SUFFIX = `.no-facade-${FACADE_GENERATOR}`
 
 /** The facade this generator writes for `bundleFile`. */
 export function cjsFacadePath(bundleFile: string) {
-  return `${bundleFile.replace(/\.mjs$/, '')}.facade-${FACADE_GENERATOR}.mjs`
+  return path.join(`${bundleFile.replace(/\.mjs$/, '')}.facade-${FACADE_GENERATOR}`, 'index.mjs')
 }
 
 /** Where this generator records "no named exports" for `bundleFile`. */
@@ -1120,11 +1120,15 @@ async function writeCjsNamedExportFacade(bundleFile: string, importHref: string)
   // off it threw at facade eval. Its names live on the bundle's own exports
   // instead — the same precedence `executedExportNames` derived them with.
   const source =
-    `import ${binding}, * as ${namespace} from ${JSON.stringify(`./${path.basename(bundleFile)}`)};\n` +
+    `import ${binding}, * as ${namespace} from ${JSON.stringify(`../${path.basename(bundleFile)}`)};\n` +
     `export default ${binding};\n` +
     `const ${holder} = ${binding} ?? ${namespace};\n` +
     names.map(name => `export const ${name} = ${holder}[${JSON.stringify(name)}];`).join('\n') +
     '\n'
+  // Bun 1.4 caches a resolved directory's module names. The bundle was just
+  // imported above, so a new sibling facade is invisible to a later import;
+  // a content-specific child directory has not been resolved yet.
+  await mkdir(path.dirname(file), { recursive: true })
   const ok = await facadeRebundles(file, source)
   heavyProfRow({
     k: 'facade',

package/src/utils/ansi.ts

@@ -1,5 +1,7 @@
+// NO_COLOR (https://no-color.org): any non-empty value disables all styling.
 function color(open: string, close: string) {
-  return (value: string) => (process.stdout.isTTY ? `${open}${value}${close}` : value)
+  return (value: string) =>
+    process.stdout.isTTY && !process.env.NO_COLOR ? `${open}${value}${close}` : value
 }
 
 /** Mid-gray for subordinate text. Readable on both light and dark terminals. */

package/src/utils/fs.ts

@@ -9,9 +9,23 @@ import { fileURLToPath } from 'node:url'
 // second rename hits ENOENT once the first moved it away. Losing that race is harmless - both wrote the same
 // content-keyed bytes - so a rename whose temp is gone only fails if the destination is missing too.
 let atomicWriteSequence = 0
-export async function writeFileAtomic(file: string, contents: string) {
-  const temp = `${file}.${process.pid.toString(36)}.${(++atomicWriteSequence).toString(36)}.tmp`
-  await writeFile(temp, contents)
+export async function writeFileAtomic(file: string, contents: string, tempDirectory?: string) {
+  const suffix = `${process.pid.toString(36)}.${(++atomicWriteSequence).toString(36)}.tmp`
+  let temp = tempDirectory
+    ? path.join(
+        tempDirectory,
+        `.${path.basename(path.dirname(file))}-${path.basename(file)}.${suffix}`,
+      )
+    : `${file}.${suffix}`
+  try {
+    await writeFile(temp, contents)
+  } catch (error) {
+    // An unwritable tempDirectory (read-only parent of a containerized app root)
+    // must not fail the write: fall back to staging beside the destination.
+    if (!tempDirectory) throw error
+    temp = `${file}.${suffix}`
+    await writeFile(temp, contents)
+  }
   try {
     await rename(temp, file)
   } catch (error) {