@wular/pnext 0.0.4 → 0.0.7

package/src/cli/{server-entry.ts → serve/entry.ts}

@@ -3,29 +3,29 @@
  * 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.
  */
-import { existsSync, readFileSync } from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import type { Plugin as EsbuildPlugin } from 'esbuild';
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import type { Plugin as EsbuildPlugin } from 'esbuild'
 
-const frameworkRoot = path.resolve(import.meta.dirname, '..', '..');
+const frameworkRoot = path.resolve(import.meta.dirname, '..', '..', '..')
 
 /** Stamped into the filename so an upgraded framework never runs a stale bundle. */
 function frameworkVersion(): string {
   try {
-    const pkg = readFileSync(path.join(frameworkRoot, 'package.json'), 'utf8');
-    return (JSON.parse(pkg) as { version?: string }).version ?? '0';
+    const pkg = readFileSync(path.join(frameworkRoot, 'package.json'), 'utf8')
+    return (JSON.parse(pkg) as { version?: string }).version ?? '0'
   } catch {
-    return '0';
+    return '0'
   }
 }
 
 function serverEntryDir(outPath: string): string {
-  return path.join(outPath, 'server', `bundle-${frameworkVersion()}`);
+  return path.join(outPath, 'server', `bundle-${frameworkVersion()}`)
 }
 
 function serverEntryFile(outPath: string): string {
-  return path.join(serverEntryDir(outPath), 'entry.js');
+  return path.join(serverEntryDir(outPath), 'entry.js')
 }
 
 /**
@@ -37,9 +37,9 @@ function serverEntryFile(outPath: string): string {
  */
 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;
+  if (process.env.PNEXT_NO_SERVER_BUNDLE === '1') return undefined
+  const file = serverEntryFile(path.resolve(root, '.pnext'))
+  return existsSync(file) ? pathToFileURL(file).href : undefined
 }
 
 /**
@@ -52,10 +52,10 @@ export function prebuiltServerEntry(root = process.cwd()): string | undefined {
  * not fail over a start-time optimization.
  */
 export async function emitServerEntry(outPath: string): Promise<string | undefined> {
-  const { build } = await import('../utils/esbuild');
+  const { build } = await import('../../utils/esbuild')
   try {
     await build({
-      entryPoints: [path.join(import.meta.dirname, 'start.ts')],
+      entryPoints: [path.join(import.meta.dirname, '..', 'start.ts')],
       outdir: serverEntryDir(outPath),
       entryNames: 'entry',
       chunkNames: '[name]-[hash]',
@@ -78,11 +78,11 @@ export async function emitServerEntry(outPath: string): Promise<string | undefin
           )});`,
       },
       plugins: [await serverEntryPlugin(outPath)],
-    });
-    return serverEntryFile(outPath);
+    })
+    return serverEntryFile(outPath)
   } catch (error) {
-    console.warn(`pnext build: server entry bundling skipped — ${(error as Error).message}`);
-    return undefined;
+    console.warn(`pnext build: server entry bundling skipped — ${(error as Error).message}`)
+    return undefined
   }
 }
 
@@ -96,17 +96,17 @@ export async function emitServerEntryChild(outPath: string): Promise<void> {
     const child = Bun.spawn([process.execPath, import.meta.filename, outPath], {
       stdout: 'ignore',
       stderr: 'inherit',
-    });
-    if ((await child.exited) === 0) return;
+    })
+    if ((await child.exited) === 0) return
   } catch {
     // fall through to in-process emission
   }
-  await emitServerEntry(outPath);
+  await emitServerEntry(outPath)
 }
 
 async function serverEntryPlugin(outPath: string): Promise<EsbuildPlugin> {
-  const { rewriteFacts } = await import('../resolve/scan-facts');
-  const { spliceSource } = await import('../dev/module-transform');
+  const { rewriteFacts } = await import('../../resolve/scan-facts')
+  const { spliceSource } = await import('../../runtime/module-transform')
   return {
     name: 'pnext-server-entry',
     setup(build) {
@@ -115,66 +115,66 @@ async function serverEntryPlugin(outPath: string): Promise<EsbuildPlugin> {
       // 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 };
-      });
+        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 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);
+          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) };
-      });
+            : []
+        })
+        if (edits.length === 0) return undefined
+        return { contents: spliceSource(source, edits), loader: loaderFor(args.path) }
+      })
     },
-  };
+  }
 }
 
-const importMetaProperties = ['dirname', 'filename', 'resolve', 'url', 'dir'] as const;
+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 };
+  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';
+  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);
+    return Bun.resolveSync(specifier, dir)
   } catch {
-    return undefined;
+    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);
+  const emitted = await emitServerEntry(process.argv[2])
+  process.exit(emitted ? 0 : 1)
 }