@thomas.f/prnext 0.1.16-alpha → 0.1.17-alpha

package/build/loader-cache.mjs

@@ -1,27 +1,33 @@
 import { rename } from '../runtime/fs.mjs';
 import { createHash, randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
-import { readFile, writeFile, mkdir, rm, readdir, stat } from 'node:fs/promises';
+import { readFile, open, unlink, readdir, stat, lstat, realpath } from 'node:fs/promises';
 import path from 'node:path';
+import {privateCacheDirectory,readCacheRecord} from './persistent-cache.mjs';
 const require = createRequire(import.meta.url);
 const hash = value => createHash('sha256').update(value).digest('hex');
 const MAX_ENTRY = 16 * 1024 * 1024, MAX_TOTAL = 64 * 1024 * 1024;
+const MAX_DEPENDENCIES=10000;
 async function fileHash(file) {
   try { if ((await stat(file)).size > MAX_ENTRY) return null; return hash(await readFile(file)); }
   catch(error) { if(error.code === 'ENOENT') return 'missing'; throw error; }
 }
 async function directoryHash(root) {
-  const records = []; let count = 0;
+  try{if(!(await stat(root)).isDirectory())return null;}catch(error){if(error.code==='ENOENT')return 'missing';throw error;}
+  const records = [],seen=new Set(); let count = 0;
   async function walk(directory) {
+    const canonical=await realpath(directory);if(seen.has(canonical))throw new Error('Cyclic loader context dependency');seen.add(canonical);
     for (const name of (await readdir(directory)).sort()) {
-      if (++count > 10000) throw new Error('Loader context dependency exceeds 10000 files');
+      if (++count > MAX_DEPENDENCIES) throw new Error('Loader context dependency exceeds 10000 files');
       const file=path.join(directory,name), metadata=await stat(file);
-      records.push([path.relative(root,file),metadata.isDirectory()?'directory':await fileHash(file)]);
+      const digest=metadata.isDirectory()?'directory':await fileHash(file);
+      if(digest===null||digest==='missing')throw new Error('Unstable or excessive loader context dependency');
+      records.push([path.relative(root,file),digest]);
       if(metadata.isDirectory())await walk(file);
     }
+    seen.delete(canonical);
   }
-  try { await walk(root); return hash(JSON.stringify(records)); }
-  catch(error) { if(error.code==='ENOENT')return 'missing'; throw error; }
+  await walk(root);return hash(JSON.stringify(records));
 }
 function loaderModules(loaders) {
   const files=new Set();
@@ -30,41 +36,62 @@ function loaderModules(loaders) {
   return [...files];
 }
 async function snapshot(files,contexts,missing) {
+  if(files.length+contexts.length+missing.length>MAX_DEPENDENCIES)throw new Error('Excessive loader dependencies');
   return {files:await Promise.all([...new Set([...files,...missing])].sort().map(async file=>[file,await fileHash(file)])),
     contexts:await Promise.all([...new Set(contexts)].sort().map(async file=>[file,await directoryHash(file)]))};
 }
 async function valid(snapshot) {
-  if(snapshot.files.some(([,digest])=>digest===null))return false;
+  if(!validSnapshot(snapshot))return false;
   for(const [file,digest] of snapshot.files)if(await fileHash(file)!==digest)return false;
   for(const [file,digest] of snapshot.contexts)if(await directoryHash(file)!==digest)return false;
   return true;
 }
 async function prune(directory) {
-  const entries = await Promise.all((await readdir(directory)).filter(name=>name.endsWith('.json')).map(async name=>({name,...await stat(path.join(directory,name))})));
+  const entries=[];
+  for(const name of await readdir(directory))if(/^[a-f0-9]{64}\.json$/.test(name)){
+    const info=await lstat(path.join(directory,name)).catch(()=>null);
+    if(info?.isFile()&&!info.isSymbolicLink())entries.push({name,size:info.size,mtimeMs:info.mtimeMs});
+  }
   entries.sort((a,b)=>b.mtimeMs-a.mtimeMs);let bytes=0;
-  for(let index=0;index<entries.length;index++){bytes+=entries[index].size;if(index>=256||bytes>MAX_TOTAL)await rm(path.join(directory,entries[index].name),{force:true});}
+  for(let index=0;index<entries.length;index++){bytes+=entries[index].size;if(index>=256||bytes>MAX_TOTAL)await unlink(path.join(directory,entries[index].name)).catch(()=>{});}
+}
+const validFile=value=>typeof value==='string'&&path.isAbsolute(value)&&!value.includes('\0')&&value.length<=32768;
+const validFiles=value=>Array.isArray(value)&&value.length<=MAX_DEPENDENCIES&&value.every(validFile);
+const digest=value=>value==='missing'||typeof value==='string'&&/^[a-f0-9]{64}$/.test(value);
+function validSnapshot(value){return !!value&&typeof value==='object'&&['files','contexts'].every(key=>Array.isArray(value[key])&&value[key].length<=MAX_DEPENDENCIES&&value[key].every(item=>Array.isArray(item)&&item.length===2&&validFile(item[0])&&digest(item[1])));}
+function validResult(value){
+  return !!value&&typeof value==='object'&&typeof value.source==='string'&&value.source.length<=MAX_ENTRY&&
+    ['dependencies','contexts','missing'].every(key=>validFiles(value[key]))&&
+    Array.isArray(value.warnings)&&value.warnings.length<=MAX_DEPENDENCIES&&value.warnings.every(item=>typeof item==='string')&&
+    Array.isArray(value.assets)&&value.assets.length<=4096&&value.assets.every(item=>item&&typeof item.name==='string'&&!path.isAbsolute(item.name)&&!/[\\\0?#]/.test(item.name)&&item.name.split('/').every(part=>part&&part!=='.'&&part!=='..')&&typeof item.data==='string'&&item.data.length<=MAX_ENTRY&&item.data.length%4===0&&/^[A-Za-z0-9+/]*={0,2}$/.test(item.data))&&
+    (value.map===undefined||value.map&&typeof value.map==='object'&&!Array.isArray(value.map)&&value.map.version===3)&&
+    (value.cacheable===undefined||typeof value.cacheable==='boolean');
+}
+async function publish(directory,key,value){
+  const payload=JSON.stringify(value),body=JSON.stringify({version:1,key,checksum:hash(payload),payload});
+  if(Buffer.byteLength(body)>MAX_ENTRY)return;
+  const destination=path.join(directory,key+'.json'),temporary=destination+'.'+randomUUID()+'.tmp';
+  try{const file=await open(temporary,'wx',0o600);try{await file.writeFile(body);}finally{await file.close();}await rename(temporary,destination);await prune(directory);}
+  finally{await unlink(temporary).catch(()=>{});}
 }
 /** Cache only loaders which opt into dependency tracking; no render output enters this cache. */
 export async function cachedLoader(options,run) {
+  const execute=()=>{for(const file of loaderModules(options.loaders))delete require.cache[file];return run();};
+  if(process.env.PRNEXT_BUILD_CACHE==='0')return execute();
   let serializable = true;
   try { JSON.stringify(options,(_key,value)=>{if(typeof value==='function'||typeof value==='symbol'||typeof value==='bigint'||value instanceof RegExp)serializable=false;return value;}); } catch { serializable=false; }
-  if (!serializable) return run();
-  const directory=path.join(options.root,'.prnext-cache','loaders-v1');
-  const key=hash(JSON.stringify({...options,env:hash(JSON.stringify(Object.entries(process.env).sort()))}));
-  const file=path.join(directory,key+'.json');
+  if (!serializable) return execute();
+  let directory,key;
   try {
-    if((await stat(file)).size<=MAX_ENTRY){const cached=JSON.parse(await readFile(file,'utf8'));if(cached.version===1&&await valid(cached.snapshot))return cached.result;}
-  } catch(error) { if(!['ENOENT','ENOTDIR'].includes(error.code) && !(error instanceof SyntaxError)) throw error; }
-  for (const file of loaderModules(options.loaders)) delete require.cache[file];
-  const result=await run();
-  if(result.cacheable===false)return result;
-  const dependencies=[...new Set([options.file,...result.dependencies,...loaderModules(options.loaders),...['package.json','package-lock.json','pnpm-lock.yaml','yarn.lock'].map(name=>path.join(options.root,name))])];
-  const current=await snapshot(dependencies,result.contexts,result.missing);
-  const body=JSON.stringify({version:1,snapshot:current,result:{...result,dependencies}});
-  if(Buffer.byteLength(body)>MAX_ENTRY || current.files.some(([,value])=>value===null))return result;
-  await mkdir(directory,{recursive:true});
-  const temporary=file+'.'+randomUUID()+'.tmp';
-  try {await writeFile(temporary,body);await rename(temporary,file);}finally{await rm(temporary,{force:true});}
-  await prune(directory);
+    directory=await privateCacheDirectory(options.root,'loaders-v2');
+    if(directory){key=hash(JSON.stringify({...options,node:process.version,env:hash(JSON.stringify(Object.entries(process.env).sort()))}));const cached=await readCacheRecord(directory,key,MAX_ENTRY);if(cached?.format===2&&validResult(cached.result)&&await valid(cached.snapshot))return cached.result;}
+  } catch{/* Cache availability and malformed records never prevent a loader run. */}
+  const result=await execute();
+  if(!directory||!key||result?.cacheable===false||!validResult(result))return result;
+  try{
+    const dependencies=[...new Set([options.file,...result.dependencies,...loaderModules(options.loaders),...['package.json','package-lock.json','npm-shrinkwrap.json','pnpm-lock.yaml','yarn.lock','bun.lock','bun.lockb'].map(name=>path.join(options.root,name))])];
+    const current=await snapshot(dependencies,result.contexts,result.missing);
+    if(validSnapshot(current))await publish(directory,key,{format:2,snapshot:current,result:{...result,dependencies}});
+  }catch{/* Successful loader output remains usable when snapshot/publication fails. */}
   return result;
 }

package/build/metadata-routes.mjs

@@ -1,7 +1,7 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
-import { parse } from '@babel/parser';
+import {analyzeSource} from './source-analysis.mjs';
 import { validateAppConfig, mergeAppConfig } from './app-config.mjs';
 import { scanMetadataImages } from './metadata-images.mjs';
 import { pageExtensionPattern, validatePageSource } from './page-extensions.mjs';
@@ -50,8 +50,7 @@ export async function scanMetadataRoutes({ root, appRoot, files, routes, pattern
 }
 
 export function metadataExportNames(source, file) {
-  const ast = parse(source, { sourceType: 'module', plugins: ['jsx', ...(/\.tsx?$/.test(file) ? ['typescript'] : [])] });
-  return ast.program.body.flatMap(node => node.type === 'ExportNamedDeclaration' ? [node.declaration?.id?.name, ...(node.declaration?.declarations || []).map(item => item.id.name), ...node.specifiers.map(item => item.exported?.name)] : []);
+  return analyzeSource(source,file).program.body.flatMap(node => node.type === 'ExportNamedDeclaration' && node.exportKind !== 'type' ? [node.declaration?.id?.name, ...(node.declaration?.declarations || []).map(item => item.id.name), ...node.specifiers.filter(item=>item.exportKind!=='type').map(item => item.exported?.name ?? item.exported?.value)] : []).filter(Boolean);
 }
 
 export async function prepareMetadataRoutes(project, stage) {

package/build/migrate.mjs

@@ -2,23 +2,16 @@ import { rename } from '../runtime/fs.mjs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
-import { spawn } from 'node:child_process';
-import { constants } from 'node:fs';
-import { readFile, writeFile, rm, lstat, realpath, access } from 'node:fs/promises';
+import { readFile, writeFile, rm, lstat, realpath } from 'node:fs/promises';
 import { checkProject } from './check.mjs';
 import { sourceCheckout } from '../native/resolve.mjs';
+import { migrationInstallContext, regularMigrationFile, installWithManager, executeManager } from './package-manager.mjs';
 
 const packageRoot = fileURLToPath(new URL('../', import.meta.url));
 const dependencyFields = ['dependencies', 'devDependencies', 'optionalDependencies'];
-const locks = ['package-lock.json', 'npm-shrinkwrap.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lock', 'bun.lockb'];
 const own = (object, key) => Object.hasOwn(object, key);
 const record = value => value !== null && typeof value === 'object' && !Array.isArray(value);
 
-async function optionalFile(file) {
-  try { return await readFile(file); }
-  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
-}
-
 export function parseMigrationArgs(args) {
   const options = { dryRun: false, install: true, json: false };
   let directory;
@@ -172,31 +165,14 @@ export function migrationPackage(input, framework, spec) {
   return { package: output, changes, notes };
 }
 
-async function installContext(root, pkg) {
-  const present = [];
-  for (const name of locks) if (await optionalFile(path.join(root, name))) present.push(name);
-  const manager = pkg.packageManager?.split('@')[0];
-  if (manager && manager !== 'npm') return { allowed: false, reason: `This project uses ${manager}. Use --no-install, then install with ${manager}.`, locks: present };
-  if (present.some(name => !['package-lock.json', 'npm-shrinkwrap.json'].includes(name))) {
-    return { allowed: false, reason: 'A non-npm lockfile is present. Use --no-install and the existing package manager to preserve its lockfile.', locks: present };
-  }
-  for (let directory = root; ; directory = path.dirname(directory)) {
-    const contents = directory === root ? null : await optionalFile(path.join(directory, 'package.json'));
-    let ancestor;
-    try { ancestor = directory === root ? pkg : contents && JSON.parse(contents); } catch { ancestor = null; }
-    if (ancestor?.workspaces) return { allowed: false, reason: 'A workspace package manager must be run from its workspace root. Use --no-install, then install from that root.', locks: present };
-    if (directory === path.dirname(directory)) break;
-  }
-  return { allowed: true, locks: present };
-}
-
 async function backup(file, contents) {
   for (let index = 0; index < 1000; index++) {
     const destination = `${file}.prnext-backup${index ? '.' + index : ''}`;
     try { await writeFile(destination, contents, { flag: 'wx', mode: 0o600 }); return destination; }
     catch (error) {
       if (error.code !== 'EEXIST') throw error;
-      if ((await readFile(destination)).equals(contents)) return destination;
+      const existing = await regularMigrationFile(destination);
+      if (existing?.contents.equals(contents)) return destination;
     }
   }
   throw new Error(`Too many migration backups for ${file}.`);
@@ -206,34 +182,23 @@ async function replacePackage(file, original, text, mode) {
   const temporary = `${file}.prnext-${randomUUID()}.tmp`;
   try {
     await writeFile(temporary, text, { flag: 'wx', mode });
+    if (!(await lstat(file)).isFile()) throw new Error('package.json is no longer a regular file.');
     if (!(await readFile(file)).equals(original)) throw new Error('package.json changed during migration. Retry after the other edit finishes.');
     await rename(temporary, file);
   } finally { await rm(temporary, { force: true }); }
 }
 
-export async function installMigrationDependencies(root, { json = false, local = false } = {}) {
-  const npm = process.env.npm_execpath;
-  // Never use a shell to interpolate a project path or a package specification.
-  const args = ['install', '--workspaces=false', ...(local ? ['--install-links=false'] : [])];
-  const command = npm && /(?:^|[/\\])npm(?:-cli)?\.(?:c?js)$/.test(npm) ? process.execPath : process.platform === 'win32' ? 'npm.cmd' : 'npm';
-  const argv = command === process.execPath ? [npm, ...args] : args;
-  await new Promise((resolve, reject) => {
-    // Windows .cmd launchers require a shell; argv contains only fixed flags,
-    // never project data. npx/npm invocations use npm-cli.js directly instead.
-    const child = spawn(command, argv, { cwd: root, stdio: json ? ['inherit', 2, 2] : 'inherit', shell: process.platform === 'win32' && command === 'npm.cmd' });
-    child.once('error', reject);
-    child.once('exit', (code, signal) => code === 0 ? resolve() : reject(new Error(`npm install failed (${signal || code}). Backups are available; fix the dependency conflict and retry. No --force or --legacy-peer-deps override was used.`)));
-  });
-  for (const name of ['prn', 'prnext']) {
-    const executable = path.join(root, 'node_modules/.bin', name + (process.platform === 'win32' ? '.cmd' : ''));
-    try { await access(executable, process.platform === 'win32' ? constants.F_OK : constants.X_OK); }
-    catch { throw new Error(`npm did not install the ${name} executable. Check npm's bin-links setting and the local PRNext dependency path, then retry.`); }
-  }
+export async function installMigrationDependencies(root, { json = false, local = false, context } = {}) {
+  context ||= await migrationInstallContext(root, JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8')));
+  if (!context.allowed) throw new Error(context.reason);
+  return installWithManager(context, { json, local });
 }
 
 export async function migrateProject(directory, { dryRun = false, install = true, json = false } = {}, services = {}) {
   const root = path.resolve(directory), file = path.join(root, 'package.json');
   const report = { root, ok: false, status: 'checking', dryRun, changes: [], backups: [], notes: [], preflight: null };
+  const snapshots = new Map();
+  let appliedText, physicalFile, installationStarted = false;
   try {
     const stat = await lstat(file);
     if (!stat.isFile()) throw new Error('Migration requires a regular package.json file, not a symlink or directory.');
@@ -244,15 +209,23 @@ export async function migrateProject(directory, { dryRun = false, install = true
     const framework = JSON.parse(await readFile(path.join(packageRoot, 'package.json'), 'utf8'));
     if ([framework.name, 'prnext', 'prnext-monorepo'].includes(input.name)) throw new Error('Choose the Next.js application directory, not the PRNext framework repository.');
     const local = sourceCheckout() !== null;
+    const context = await migrationInstallContext(root, input);
     // npm resolves file dependencies from the physical working directory. A
     // symlink such as macOS /var -> /private/var otherwise changes ../ depth.
     const relative = path.relative(await realpath(root), await realpath(packageRoot)).split(path.sep).join('/') || '.';
-    const spec = local ? `file:${relative}` : framework.version;
+    // Preserve a live checkout for local candidates: file: is copied into
+    // pnpm/Yarn stores and would lose the repository's native build context.
+    const protocol = context.manager === 'npm' ? 'file' : context.manager === 'yarn' && context.berry ? 'portal' : 'link';
+    const spec = local ? `${protocol}:${relative}` : framework.version;
     const plan = migrationPackage(input, framework, spec);
     report.changes = plan.changes;
     report.notes = plan.notes;
     if (local) report.notes.push(`This unpublished checkout uses a local PRNext dependency (${spec}); keep this checkout available. Rust is required on the first native build.`);
-    const context = await installContext(root, input);
+    physicalFile = path.join(context.target, 'package.json');
+    report.installation = { manager: context.manager, version: context.version, root: context.root, workspace: context.workspace,
+      target: context.workspaceTarget, command: context.command };
+    report.notes.push(...context.notes);
+    for (const stateFile of context.stateFiles) snapshots.set(stateFile, await regularMigrationFile(stateFile));
     if (!context.allowed) {
       report.notes.push(context.reason);
       if (install && !dryRun) throw new Error(context.reason);
@@ -264,11 +237,8 @@ export async function migrateProject(directory, { dryRun = false, install = true
     if (dryRun) { report.ok = true; report.status = 'preview'; return report; }
     if (plan.changes.length || install) {
       report.backups.push(await backup(file, original));
-      for (const name of context.locks) {
-        const lockFile = path.join(root, name);
-        const stat = await lstat(lockFile);
-        if (!stat.isFile()) throw new Error(`Migration requires a regular ${name} file.`);
-        report.backups.push(await backup(lockFile, await readFile(lockFile)));
+      for (const lockFile of context.locks) {
+        report.backups.push(await backup(lockFile, snapshots.get(lockFile).contents));
       }
     }
     if (plan.changes.length) {
@@ -276,23 +246,56 @@ export async function migrateProject(directory, { dryRun = false, install = true
       const newline = source.includes('\r\n') ? '\r\n' : '\n';
       const text = (source.startsWith('\uFEFF') ? '\uFEFF' : '') + JSON.stringify(plan.package, null, indent).replaceAll('\n', newline) + (/\r?\n$/.test(source) ? newline : '');
       await replacePackage(file, original, text, stat.mode & 0o777);
+      appliedText = Buffer.from(text);
     }
     report.status = plan.changes.length ? 'prepared' : 'unchanged';
     if (!install) {
       report.ok = true;
-      report.notes.push('Dependency installation and installed-version validation are pending. Install with your package manager, then run prn check and prn build.');
+      report.notes.push(`Dependency installation and installed-version validation are pending. Run ${context.command.name} ${context.command.args.map(value => /\s/.test(value) ? JSON.stringify(value) : value).join(' ')} from ${context.root}, then run prnext check and prnext build.`);
       return report;
     }
     report.status = 'installing';
-    await (services.install || installMigrationDependencies)(root, { json, local });
-    report.preflight = await check(root);
+    // A concurrent editor must not have its manifest or lockfile silently
+    // replaced by an install planned from an earlier snapshot.
+    for (const [stateFile, snapshot] of snapshots) {
+      const current = await regularMigrationFile(stateFile), expected = stateFile === physicalFile && appliedText ? appliedText : snapshot?.contents;
+      if (expected ? !current?.contents.equals(expected) : current !== null) throw new Error(`Migration file changed before installation: ${stateFile}`);
+    }
+    if (await realpath(context.target) !== context.target || await realpath(context.root) !== context.root) throw new Error('Workspace directories changed during migration.');
+    installationStarted = true;
+    const installed = await (services.install || installMigrationDependencies)(root, { json, local, context });
+    if (installed?.pnp && !services.check) {
+      const result = await executeManager(context, ['node', path.join(packageRoot, 'cli.mjs'), 'check', context.target, '--json'], { cwd: context.target });
+      report.preflight = JSON.parse(result.stdout);
+    } else report.preflight = await check(root);
     if (!report.preflight.ok) throw new Error(`Dependencies were installed, but final preflight failed: ${report.preflight.errors.join(' ')}`);
     report.ok = true;
     report.status = 'migrated';
-    report.notes.push('Migration prepared and dependencies checked. Run npm run build and test your application before deploying.');
+    report.notes.push(`Migration prepared and dependencies checked. Run ${context.manager} run build and test your application before deploying.`);
     return report;
   } catch (error) {
     report.error = error.message;
+    if (appliedText || report.status === 'installing') {
+      report.rollback = { ok: true, restored: [], errors: [] };
+      for (const [stateFile, snapshot] of snapshots) {
+        try {
+          if (await realpath(path.dirname(stateFile)) !== path.dirname(stateFile)) throw new Error('Migration directory became a symbolic link; preserved the current file.');
+          const current = await regularMigrationFile(stateFile);
+          if (stateFile !== physicalFile && !installationStarted) continue;
+          if (stateFile === physicalFile && current && !current.contents.equals(appliedText || snapshot.contents) && !current.contents.equals(snapshot.contents)) throw new Error('package.json was edited after migration; the newer edit was preserved.');
+          if (stateFile !== physicalFile && path.basename(stateFile) === 'package.json' && current && snapshot && !current.contents.equals(snapshot.contents)) throw new Error('Workspace package.json changed outside the selected application; the newer edit was preserved.');
+          if (snapshot) {
+            if (!current?.contents.equals(snapshot.contents)) {
+              const temporary = stateFile + `.prnext-${randomUUID()}.tmp`;
+              try { await writeFile(temporary, snapshot.contents, { flag: 'wx', mode: snapshot.mode }); await rename(temporary, stateFile); }
+              finally { await rm(temporary, { force: true }); }
+              report.rollback.restored.push(stateFile);
+            }
+          } else if (current) { await rm(stateFile); report.rollback.restored.push(stateFile); }
+        } catch (rollbackError) { report.rollback.ok = false; report.rollback.errors.push(`${stateFile}: ${rollbackError.message}`); }
+      }
+      report.notes.push(report.rollback.ok ? 'Restored the selected manifest and lockfiles after the failed migration. Dependency directories/caches may contain partial installation results; retry the same package manager.' : 'Some rollback files changed or became unsafe. Preserved those files; use the exact backups to review recovery.');
+    }
     if (report.status === 'checking') report.status = 'blocked';
     else report.status = 'incomplete';
     return report;

package/build/npm-packages.mjs

@@ -1,8 +1,7 @@
 import path from 'node:path';
 import { readFile } from 'node:fs/promises';
 import { builtinModules, createRequire } from 'node:module';
-import { parse } from '@babel/parser';
-import { VISITOR_KEYS } from '@babel/types';
+import {analyzeSource} from './source-analysis.mjs';
 import { createNativeDiscovery } from './native-discovery.mjs';
 import {frameworkImportPattern} from './framework-imports.mjs';
 
@@ -26,22 +25,8 @@ export function npmPackagesPlugin({ pages = false, projectRoot, transpilePackage
       sourceBytes += Buffer.byteLength(source);
       if (sourceBytes > 64 * 1024 * 1024) throw new Error('npm compilation analysis exceeded 64 MiB of source. Separate large runtime dependencies using serverExternalPackages.');
       if (Buffer.byteLength(source) > 8 * 1024 * 1024) throw new Error(`npm source ${file} exceeds the 8 MiB analysis limit. Configure serverExternalPackages for packages that do not use Next APIs.`);
-      const ast = parse(source, { sourceType: 'unambiguous', sourceFilename: file, allowReturnOutsideFunction: true, plugins: ['jsx', ...(/\.tsx?$/.test(file) ? ['typescript'] : [])] });
-      const result = { imports: [], computedRequire: false, frameworkBoundary: ast.program.directives.some(item => ['use client', 'use server'].includes(item.value.value)) };
-      function visit(node) {
-        if (!node || typeof node !== 'object') return;
-        if (['ImportDeclaration', 'ExportNamedDeclaration', 'ExportAllDeclaration'].includes(node.type) && node.source && node.importKind !== 'type' && node.exportKind !== 'type') result.imports.push({ path: node.source.value, kind: 'import-statement' });
-        if (node.type === 'CallExpression' && (node.callee.type === 'Import' || node.callee.type === 'Identifier' && node.callee.name === 'require')) {
-          const argument = node.arguments[0];
-          if (argument?.type === 'StringLiteral') result.imports.push({ path: argument.value, kind: node.callee.type === 'Import' ? 'dynamic-import' : 'require-call' });
-          else if (node.callee.type !== 'Import') result.computedRequire = true;
-        }
-        for (const key of VISITOR_KEYS[node.type] || []) {
-          if (Array.isArray(node[key])) node[key].forEach(visit); else visit(node[key]);
-        }
-      }
-      visit(ast.program);
-      return result;
+      const {imports,computedRequire,frameworkBoundary}=analyzeSource(source,file);
+      return {imports,computedRequire,frameworkBoundary};
     })());
     return sources.get(file);
   }