@wular/pnext 0.1.5 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wular/pnext",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "A fast little framework for server-first React apps, fully compatible with Next.js",
   "type": "module",
   "bin": {

package/src/cli/build.ts

@@ -91,6 +91,7 @@ import {
 import { interceptionMarkerLevels } from '../routing/slots'
 import { writeTypegen } from './typegen'
 import { lookupBuildCache, writeBuildCache } from './build/cache'
+import { emitServerEntry } from './serve/entry'
 import { createVerboseLogger, type VerboseLogger } from '../utils/verbose'
 import { bold, cyan, dim, green } from '../utils/ansi'
 import type {
@@ -230,15 +231,6 @@ async function runBuild(
     await ensureEmptyDir(config.outPath, [devOutSegment])
     await copyPublicDir(config.publicPath, path.join(config.outPath, 'public'))
   })
-  // Prebundled server entry for `pnext start`: framework-only, independent of the
-  // app build, so it runs in a child process for the whole build — its bundling
-  // heap never stacks on the build's peak RSS and its wall hides under the build.
-  // Best-effort — a failure only costs start time. Awaited before the summary.
-  const serverEntryDone = import('./serve/entry')
-    .then(entry => entry.emitServerEntryChild(config.outPath))
-    .catch((error: Error) => {
-      console.warn(`pnext build: server entry bundling skipped — ${error.message}`)
-    })
   // The document-level stylesheets run their postcss/Tailwind pass on the CSS
   // worker, so they overlap with the route scan below instead of serializing
   // ahead of it. Awaited before prepareRouteCssChunks — route CSS still builds
@@ -938,7 +930,7 @@ async function runBuild(
   }
   await writeBuildManifest(config.outPath, manifest)
   log.log(`wrote manifest.json (${routes.length} route${routes.length === 1 ? '' : 's'})`)
-  await log.step('server entry', () => serverEntryDone)
+  await log.step('server entry', () => emitServerEntry(config.outPath))
   for (const hook of getBuildExtensions().completeHooks) {
     await hook({ config, manifest, log })
   }

package/src/cli/index.ts

@@ -90,14 +90,7 @@ try {
   } else if (command === 'start') {
     warnUnknownFlags(command, args)
     const root = positionalRoot(args)
-    // The build emits src/cli/start.ts prebundled into one file; parsing that
-    // instead of walking the framework's source graph is most of `start`'s
-    // spawn→first-200. Absent (no build yet, custom outDir) → source path.
-    const { prebuiltServerEntry } = await import('./serve/entry')
-    const prebuilt = prebuiltServerEntry(root)
-    const { start } = prebuilt
-      ? ((await import(prebuilt)) as typeof import('./start'))
-      : await import('./start')
+    const { start } = await import('./start')
     await start({
       root,
       port: optionNumber(args, '--port'),

package/src/cli/serve/entry.ts

@@ -1,12 +1,11 @@
 /**
- * Prebundled production server entry: `pnext build` bundles the framework's server graph into one JS
- * file (entry point IS src/cli/start.ts, so the identical `start()` runs) and `pnext start` parses
- * that instead of walking hundreds of source modules - the dominant share of spawn->first-200.
+ * Server entry for hosts that serve a build through `createRequestHandler`: a thin loader that
+ * resolves `@wular/pnext` from the output's own location (as `.next/server` loads `next`), so the
+ * output carries no framework code and no build-machine paths.
  */
-import { existsSync, readFileSync } from 'node:fs'
+import { readFileSync } from 'node:fs'
+import { mkdir, writeFile } from 'node:fs/promises'
 import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-import type { Plugin as EsbuildPlugin } from 'esbuild'
 import { frameworkFingerprint } from '../../runtime/fingerprint'
 
 const frameworkRoot = path.resolve(import.meta.dirname, '..', '..', '..')
@@ -28,163 +27,19 @@ function frameworkVersion(): string {
  * cache-root record so a restart pays one stat per file rather than re-reading the tree.
  */
 export function serverEntryDir(outPath: string): string {
-  // Cache root spelled inline, not imported: this module is parsed before anything else on the
-  // start path, and pulling in the module cache for one path.join would drag its whole graph along.
   const generation = frameworkFingerprint(path.join(outPath, 'cache', 'server'))
   return path.join(outPath, 'server', `bundle-${frameworkVersion()}-${generation}`)
 }
 
-function serverEntryFile(outPath: string): string {
-  return path.join(serverEntryDir(outPath), 'entry.js')
-}
-
-/**
- * The prebuilt entry for a project root, or undefined when there is none to
- * use (no build, a custom `outDir`, a version or source-generation mismatch, or the opt-out). The
- * caller then falls back to importing src/cli/start.ts directly, so a miss only
- * costs speed. Deliberately cheap: one existsSync and one package.json read,
- * because it runs before anything else on the start path.
- */
-export function prebuiltServerEntry(root = process.cwd()): string | undefined {
-  // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (process.env.PNEXT_NO_SERVER_BUNDLE === '1') return undefined
-  const file = serverEntryFile(path.resolve(root, '.pnext'))
-  return existsSync(file) ? pathToFileURL(file).href : undefined
-}
-
-/**
- * Bundle src/cli/start.ts under `<outPath>/server/bundle-<version>-<fingerprint>/`. Bare
- * specifiers stay external (the framework's deps are already plain JS), so only
- * the framework's own source is inlined. Splitting is on so the graph behind a
- * dynamic import (compat, dev, build) stays in its own chunk — folding it into
- * the entry would evaluate eagerly what the source graph never even reads.
- * Returns the emitted entry, or undefined when bundling failed — the build must
- * not fail over a start-time optimization.
- */
-export async function emitServerEntry(outPath: string): Promise<string | undefined> {
-  const { build } = await import('../../utils/esbuild')
-  try {
-    await build({
-      entryPoints: [path.join(import.meta.dirname, '..', 'start.ts')],
-      outdir: serverEntryDir(outPath),
-      entryNames: 'entry',
-      chunkNames: '[name]-[hash]',
-      bundle: true,
-      splitting: true,
-      format: 'esm',
-      platform: 'node',
-      target: 'esnext',
-      sourcemap: false,
-      tsconfig: path.join(frameworkRoot, 'tsconfig.json'),
-      logLevel: 'silent',
-      // esbuild's ESM `require` shim throws for anything it did not bundle; the
-      // framework's lazy `require('esbuild' | 'oxc-*')` facades need a real one,
-      // anchored at the framework so they load ITS copy, not the app's.
-      banner: {
-        js:
-          'import { createRequire as __pnextCreateRequire } from "node:module";\n' +
-          `const require = __pnextCreateRequire(${JSON.stringify(
-            pathToFileURL(path.join(frameworkRoot, 'package.json')).href,
-          )});`,
-      },
-      plugins: [await serverEntryPlugin(outPath)],
-    })
-    return serverEntryFile(outPath)
-  } catch (error) {
-    console.warn(`pnext build: server entry bundling skipped — ${(error as Error).message}`)
-    return undefined
-  }
-}
-
-/**
- * Emit in a short-lived child process: the bundle's source strings and parse
- * allocations land in the child's heap (well under the build's own peak), not
- * on top of it. Falls back to in-process emission if the spawn fails.
- */
-export async function emitServerEntryChild(outPath: string): Promise<void> {
-  try {
-    const child = Bun.spawn([process.execPath, import.meta.filename, outPath], {
-      stdout: 'ignore',
-      stderr: 'inherit',
-    })
-    if ((await child.exited) === 0) return
-  } catch {
-    // fall through to in-process emission
-  }
-  await emitServerEntry(outPath)
-}
-
-async function serverEntryPlugin(outPath: string): Promise<EsbuildPlugin> {
-  const { rewriteFacts } = await import('../../resolve/scan-facts')
-  const { spliceSource } = await import('../../runtime/module-transform')
-  return {
-    name: 'pnext-server-entry',
-    setup(build) {
-      // Bare specifiers (and node builtins) stay out of the bundle. They must
-      // still resolve to the SAME file the framework's own source graph would
-      // reach: keep the specifier bare when the output directory resolves it
-      // identically (portable), otherwise pin the absolute path.
-      build.onResolve({ filter: /^[^./]/ }, args => {
-        if (args.path.startsWith('node:')) return { path: args.path, external: true }
-        const target = resolveFrom(args.path, frameworkRoot)
-        if (!target) return { path: args.path, external: true }
-        const fromOutput = resolveFrom(args.path, serverEntryDir(outPath))
-        return { path: fromOutput === target ? args.path : target, external: true }
-      })
-      // `import.meta` in a bundled module still means the ORIGINAL source file
-      // (the framework locates its own runtime shims that way). oxc's exact
-      // spans keep occurrences in strings and comments untouched.
-      build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, async args => {
-        const source = await Bun.file(args.path).text()
-        if (!source.includes('import.meta')) return undefined
-        const facts = rewriteFacts(args.path, source)
-        if (facts.unreliable) return undefined
-        const edits = facts.importMetas.flatMap(meta => {
-          const value = importMetaValue(source.slice(meta.end, meta.end + 16), args.path)
-          return value
-            ? [{ start: meta.start, end: meta.end + value.length, value: value.code }]
-            : []
-        })
-        if (edits.length === 0) return undefined
-        return { contents: spliceSource(source, edits), loader: loaderFor(args.path) }
-      })
-    },
-  }
-}
-
-const importMetaProperties = ['dirname', 'filename', 'resolve', 'url', 'dir'] as const
-
-/** The literal a bundled `import.meta.<prop>` must become, given the tail after `import.meta`. */
-function importMetaValue(tail: string, file: string): { code: string; length: number } | undefined {
-  const property = importMetaProperties.find(name => new RegExp(`^\\.${name}\\b`).test(tail))
-  if (!property) return undefined
-  const length = property.length + 1
-  const dir = path.dirname(file)
-  if (property === 'dirname' || property === 'dir') return { code: JSON.stringify(dir), length }
-  if (property === 'filename') return { code: JSON.stringify(file), length }
-  if (property === 'url') return { code: JSON.stringify(pathToFileURL(file).href), length }
-  return {
-    code: `(specifier => Bun.pathToFileURL(Bun.resolveSync(specifier, ${JSON.stringify(dir)})).href)`,
-    length,
-  }
-}
-
-function loaderFor(file: string): 'ts' | 'tsx' | 'js' | 'jsx' {
-  if (file.endsWith('.tsx')) return 'tsx'
-  if (file.endsWith('.jsx')) return 'jsx'
-  return /\.[cm]?ts$/.test(file) ? 'ts' : 'js'
-}
-
-function resolveFrom(specifier: string, dir: string): string | undefined {
-  try {
-    return Bun.resolveSync(specifier, dir)
-  } catch {
-    return undefined
-  }
-}
-
-// Child-process entry for emitServerEntryChild; last so every binding above is initialized.
-if (import.meta.main && process.argv[2]) {
-  const emitted = await emitServerEntry(process.argv[2])
-  process.exit(emitted ? 0 : 1)
+/** Write `<outPath>/server/bundle-<version>-<fingerprint>/entry.js`, re-exporting src/cli/start.ts. */
+export async function emitServerEntry(outPath: string): Promise<void> {
+  const start = await Bun.file(path.join(import.meta.dirname, '..', 'start.ts')).text()
+  const names = new Bun.Transpiler({ loader: 'ts' }).scan(start).exports
+  const dir = serverEntryDir(outPath)
+  await mkdir(dir, { recursive: true })
+  await writeFile(
+    path.join(dir, 'entry.js'),
+    `const pnext = await import(new URL('./cli/start.ts', import.meta.resolve('@wular/pnext')).href)\n` +
+      `export const { ${names.join(', ')} } = pnext\n`,
+  )
 }

package/src/cli/start.ts

@@ -2,7 +2,7 @@
  * `pnext start`: the listen path only. Everything a request needs — renderer,
  * routing, server runtime — lives in `./serve/pipeline` and is imported
  * dynamically once the port is bound, so neither the listen syscall nor the
- * ready banner waits on parsing it (it is ~700 KB of the prebundled entry).
+ * ready banner waits on parsing it.
  */
 import { readFile } from 'node:fs/promises'
 import path from 'node:path'