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

package/build/styles.mjs

@@ -1,6 +1,8 @@
 import { build as bundle } from 'esbuild';
 import { access, readFile, readdir, writeFile, rm } from 'node:fs/promises';
 import { createRequire } from 'node:module';
+import {transform as transformCss, browserslistToTargets} from 'lightningcss';
+import browserslist from 'browserslist';
 import { randomUUID } from 'node:crypto';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import path from 'node:path';
@@ -37,8 +39,20 @@ async function loadConfiguration(root) {
   return /\.(?:js|mjs|cjs)$/.test(filename) ? importConfiguration(filename) : JSON.parse(await readFile(filename, 'utf8'));
 }
 
-async function createProcessor(root) {
+export const resolveStandardBrowserTargets = root => browserslist(undefined,{path:path.resolve(root)});
+
+async function createProcessor(root, engine, browserTargets) {
   const config = await loadConfiguration(root);
+  if (config === undefined && engine !== 'postcss') {
+    const targets=browserslistToTargets(browserTargets ? await browserTargets() : resolveStandardBrowserTargets(root));
+    return {async process(css,options){
+      const result=transformCss({filename:options.from,code:Buffer.from(css),targets,minify:false,sourceMap:!!options.map,
+        ...(options.map?.prev ? {inputSourceMap:JSON.stringify(options.map.prev)} : {}),drafts:{customMedia:true}});
+      // Preserve source origins for Sass URL rebasing and the ICSS extraction
+      // below. Custom PostCSS configurations always retain their own pipeline.
+      return postcss([]).process(result.code,{...options,map:result.map?{prev:JSON.parse(result.map.toString()),inline:false,annotation:false}:false});
+    }};
+  }
   if (config === undefined) return postcss([flexbugs(), presetEnv({ autoprefixer: { flexbox: 'no-2009' }, stage: 3, features: { 'custom-properties': false } })]);
   if (!config || typeof config !== 'object' || Array.isArray(config) || !config.plugins || typeof config.plugins !== 'object') throw new Error('PostCSS configuration must export an object with a plugins object or array; configuration functions are not supported.');
   const entries = Array.isArray(config.plugins)
@@ -122,7 +136,7 @@ function packageImporter(require) {
 }
 
 /** Build-only transformations, shared and deduplicated across all three React graphs. */
-export function createStyleProcessor({ projectRoot, sassOptions = {} }) {
+export function createStyleProcessor({ projectRoot, sassOptions = {}, cssEngine = 'auto', browserTargets }) {
   const root = path.resolve(projectRoot);
   const require = createRequire(path.join(root, 'package.json'));
   const cache = new Map();
@@ -156,7 +170,7 @@ export function createStyleProcessor({ projectRoot, sassOptions = {} }) {
       sourceMap = compiled.sourceMap;
       for (const url of compiled.loadedUrls) if (url.protocol === 'file:') dependencies.add(fileURLToPath(url));
     }
-    processor ??= createProcessor(root);
+    processor ??= createProcessor(root,cssEngine,browserTargets);
     const processed = await (await processor).process(css, { from: file, to: file, map: sourceMap ? { prev: sourceMap, inline: false, annotation: false } : false });
     for (const message of processed.messages) if (message.type === 'dependency' && message.file) dependencies.add(path.resolve(root, message.file));
     rebaseReferences(processed.root, file);

package/build/transform-cache.mjs

@@ -1,23 +1,54 @@
 import { createHash } from 'node:crypto';
 import {sourceMapsEnabled} from './source-maps.mjs';
+import {AsyncLocalStorage} from 'node:async_hooks';
+import {buildCacheIdentity,privateCacheDirectory,readCacheRecord,writeCacheRecord} from './persistent-cache.mjs';
 
 const entries = new Map();
 const byteLimit = 2 * 1024 * 1024, entryLimit = 256, itemLimit = 128 * 1024;
 let bytes = 0, hits = 0, misses = 0;
-export const transformCacheStats = () => ({entries:entries.size,bytes,hits,misses});
+let diskHits=0,diskWrites=0;
+const persistent=new AsyncLocalStorage();
+export const transformCacheStats = () => ({entries:entries.size,bytes,hits,misses,diskHits,diskWrites});
+export async function withPersistentTransforms(root,{enabled=true,dev=false}={},run){
+  if(!enabled||process.env.PRNEXT_BUILD_CACHE==='0')return run();
+  let directory,key,record;
+  try{directory=await privateCacheDirectory(root,dev?'transforms-dev-v1':'transforms-v1');key=directory&&await buildCacheIdentity(root);record=key&&await readCacheRecord(directory,key);}catch{return run();}
+  if(!directory||!key)return run();
+  const scope={key,values:new Map(),bytes:0,dirty:false};
+  for(const item of Array.isArray(record?.entries)?record.entries.slice(-4096):[]){
+    if(!Array.isArray(item)||item.length!==2||!/^[a-f0-9]{64}$/.test(item[0])||typeof item[1]!=='string')continue;
+    const size=Buffer.byteLength(item[1]);if(size>128*1024||scope.bytes+size>8*1024*1024)continue;
+    scope.values.set(item[0],item[1]);scope.bytes+=size;
+  }
+  const result=await persistent.run(scope,run);
+  if(scope.dirty&&await writeCacheRecord(directory,key,{entries:[...scope.values]}))diskWrites++;
+  return result;
+}
+function identity(kind,source,settings){return createHash('sha256').update(persistent.getStore()?.key||'memory').update(JSON.stringify([kind,settings,sourceMapsEnabled()])).update('\0').update(source).digest('hex');}
+function diskValue(key){const scope=persistent.getStore();if(!scope?.values.has(key))return;const value=scope.values.get(key);scope.values.delete(key);scope.values.set(key,value);diskHits++;hits++;return value;}
+function remember(key,output){
+  const scope=persistent.getStore();if(!scope||typeof output!=='string')return;
+  const size=Buffer.byteLength(output);if(size>128*1024)return;
+  const previous=scope.values.get(key);if(previous!==undefined){scope.bytes-=Buffer.byteLength(previous);scope.values.delete(key);}
+  while(scope.values.size&&(scope.values.size>=4096||scope.bytes+size>8*1024*1024)){const [old,value]=scope.values.entries().next().value;scope.values.delete(old);scope.bytes-=Buffer.byteLength(value);}
+  scope.values.set(key,output);scope.bytes+=size;scope.dirty=true;
+}
 
 // Only pure string transformations belong here. No AST, input source, plugin
 // closure or mutable build metadata survives in the cache. Include all options
 // affecting output in settings, including build identity and target mode.
 export function cachedTransform(kind, source, settings, transform) {
-  const key = createHash('sha256').update(JSON.stringify([kind,settings,sourceMapsEnabled()])).update('\0').update(source).digest('hex');
+  const key = identity(kind,source,settings);
   const found = entries.get(key);
   if (found) {
     hits++; entries.delete(key); entries.set(key,found);
+    if(persistent.getStore()&&!persistent.getStore().values.has(key))remember(key,found.output);
     return found.output;
   }
+  const saved=diskValue(key);if(saved!==undefined)return saved;
   misses++;
   const output = transform();
+  remember(key,output);
   // UTF-16 is an upper bound for the retained string payload. Metadata adds
   // engine overhead; the entry count also bounds that overhead.
   const size = output.length * 2 + key.length * 2;
@@ -33,11 +64,13 @@ export function cachedTransform(kind, source, settings, transform) {
 
 /** Async transforms share the same payload and entry budget as synchronous ones. */
 export async function cachedAsyncTransform(kind, source, settings, transform) {
-  const key = createHash('sha256').update(JSON.stringify([kind,settings,sourceMapsEnabled()])).update('\0').update(source).digest('hex');
+  const key = identity(kind,source,settings);
   const found = entries.get(key);
-  if (found) { hits++; entries.delete(key); entries.set(key,found); return found.output; }
+  if (found) { hits++; entries.delete(key); entries.set(key,found); if(persistent.getStore()&&!persistent.getStore().values.has(key))remember(key,found.output);return found.output; }
+  const saved=diskValue(key);if(saved!==undefined)return saved;
   misses++;
   const output = await transform();
+  remember(key,output);
   const size = output.length * 2 + key.length * 2;
   if (size <= itemLimit) {
     if (entries.has(key)) {bytes -= entries.get(key).size;entries.delete(key);}

package/build/transform.mjs

@@ -51,7 +51,7 @@ export async function rewriteServerChunks(file,chunks,publicPath){
 }
 
 function parserOptions(filename) {
-  return { sourceType: 'unambiguous', sourceFilename: filename, plugins: ['jsx', ...( /\.tsx?$/.test(filename) ? ['typescript'] : [])] };
+  return { sourceType: 'unambiguous', sourceFilename: filename, plugins: ['jsx', ...( /\.[cm]?tsx?$/.test(filename) ? ['typescript'] : [])] };
 }
 
 export function assertSupportedSource(source, filename) {

package/build/type-command.mjs

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { loadProjectConfig } from './config.mjs';
+import { scanProject } from './scan.mjs';
+import { writeTypedRoutes } from './typed-routes.mjs';
+import { checkTypeScript, projectTsconfig } from './typescript.mjs';
+import { snapshotEnvConfig } from '../runtime/env.mjs';
+
+/** Generate/check from route discovery only; no bundler, native server or install. */
+export async function runTypeCommand(directory, { check = false } = {}) {
+  const root = path.resolve(directory);
+  const report = { version: 1, root, command: check ? 'typecheck' : 'typegen', ok: false, typedRoutes: false,
+    tsconfig: null, routes: 0, updated: [], configUpdates: [], notes: [], errors: [] };
+  const restore = snapshotEnvConfig();
+  try {
+    const config = await loadProjectConfig(root);
+    const tsconfig = await projectTsconfig(root, config);
+    if (!tsconfig) throw new Error('Type commands require an existing tsconfig.json, or typescript.tsconfigPath pointing to an existing configuration.');
+    const resolve = createRequire(path.join(root, 'package.json'));
+    try { resolve.resolve('typescript'); }
+    catch { throw new Error('Install typescript as a dev dependency in the application before running typegen or typecheck.'); }
+    report.tsconfig = path.relative(root, tsconfig).replaceAll(path.sep, '/');
+    // Explicit type commands opt into route generation unless the application
+    // explicitly disables it. A clean checkout gets fresh declarations first.
+    report.typedRoutes = config.typedRoutes !== false;
+    const project = await scanProject(root, { basePath: config.basePath, pageExtensions: config.pageExtensions, i18n: config.i18n });
+    report.routes = project.routes.filter(route => route.kind === 'page' && !route.internal && !route.errorStatus).length;
+    const updates = await writeTypedRoutes(root, project, { ...config, typedRoutes: report.typedRoutes });
+    report.updated = (updates || []).map(file => path.relative(root, file).replaceAll(path.sep, '/')).sort();
+    report.configUpdates = report.updated.filter(file => file === report.tsconfig || file === 'prnext-env.d.ts');
+    if (report.configUpdates.length) report.notes.push('Updated the selected tsconfig roots/Next type aliases and/or prnext-env.d.ts to include generated declarations. Existing JSONC comments and inherited settings are preserved.');
+    if (!report.typedRoutes) report.notes.push('Route declarations are disabled by typedRoutes: false; application TypeScript is still checked by typecheck.');
+    if (check) {
+      await checkTypeScript(root, config, { tsconfig, force: true });
+      if (config.typescript?.ignoreBuildErrors) report.notes.push('typecheck checks errors even when typescript.ignoreBuildErrors is enabled for builds.');
+    }
+    report.ok = true;
+  } catch (error) { report.errors.push(error.message); }
+  finally { restore(); }
+  return report;
+}

package/build/typed-routes.mjs

@@ -0,0 +1,95 @@
+import {readFile,writeFile,mkdir,rename,lstat} from 'node:fs/promises';
+import {createRequire} from 'node:module';
+import {randomUUID} from 'node:crypto';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {resolveTypeScript} from './typescript-toolchain.mjs';
+import {nativeTypeConfig} from './native-type-config.mjs';
+
+const marker='// Generated by PRNext: typed route registry. Do not edit.';
+async function changed(file,contents,updates){
+  const info=await lstat(file).catch(error=>{if(error.code!=='ENOENT')throw error;});
+  if(info&&(!info.isFile()||info.isSymbolicLink()))throw Error('Typed routes cannot replace a non-regular file: '+file);
+  if(await readFile(file,'utf8').catch(()=>null)===contents)return;
+  const temporary=file+'.'+randomUUID()+'.tmp';try{await writeFile(temporary,contents,{mode:0o600,flag:'wx'});await rename(temporary,file);updates?.add(file);}finally{const {rm}=await import('node:fs/promises');await rm(temporary,{force:true});}
+}
+export function routeDeclarations(project,{enabled=true}={}){
+  const patterns=[...new Set(project.routes.filter(route=>route.kind==='page'&&!route.internal&&!route.errorStatus).map(route=>route.pattern))].sort();
+  if(patterns.length>10000)throw Error('Typed routes supports at most 10,000 page patterns');
+  const fields=patterns.map(pattern=>{
+    const segments=pattern.split('/');if(segments.length>33)throw Error('Typed routes supports at most 32 route segments');
+    const params=segments.flatMap(part=>{
+      const optional=/^\[\[\.\.\.([^\]]+)\]\]$/.exec(part),rest=/^\[\.\.\.([^\]]+)\]$/.exec(part),single=/^\[([^\]]+)\]$/.exec(part);
+      const match=optional||rest||single;return match?[`${JSON.stringify(match[1])}${optional?'?':''}: ${single?'string':'string[]'}`]:[];
+    });
+    return `    ${JSON.stringify(pattern)}: {${params.join('; ')}};`;
+  });
+  return marker+'\nexport {};\ndeclare global {\n  namespace PRNext {\n'+(enabled?'    interface RouteConfig { enabled: true }\n':'')+'    interface RouteMap {\n'+fields.join('\n')+'\n    }\n  }\n}\n';
+}
+// Bind missing Next-style imports to the matching PRNext declarations. Existing
+// aliases remain authoritative; inherited aliases retain their resolved targets.
+async function bindTypes(filename,ts,updates){
+  const source=await readFile(filename,'utf8');
+  const parsed=ts.getParsedCommandLineOfConfigFile(filename,{},{...ts.sys,onUnRecoverableConfigFileDiagnostic:()=>{}});
+  const paths=parsed.options.paths||{},missing=['next','next/*'].filter(name=>!Object.hasOwn(paths,name));if(!missing.length)return;
+  const ast=ts.parseJsonText(filename,source),object=ast.statements[0].expression;
+  const options=object.properties.find(p=>p.name?.text==='compilerOptions')?.initializer;
+  const ownPaths=options?.properties?.find(p=>p.name?.text==='paths')?.initializer;
+  const base=parsed.options.baseUrl||path.dirname(filename),oldBase=parsed.options.baseUrl||parsed.options.pathsBasePath||path.dirname(filename);
+  const relative=file=>{let value=path.relative(base,file).replaceAll(path.sep,'/');return value.startsWith('.')?value:'./'+value;};
+  const compat=fileURLToPath(new URL('../compat/',import.meta.url));
+  const additions=Object.fromEntries(missing.map(name=>[name,[relative(path.join(compat,name==='next'?'index.d.ts':'*.d.cts'))]]));
+  let target,values;
+  if(ownPaths){if(!ts.isObjectLiteralExpression(ownPaths))throw Error('tsconfig.compilerOptions.paths must be an object');target=ownPaths;values=additions;}
+  else{
+    const merged={...Object.fromEntries(Object.entries(paths).map(([name,values])=>[name,values.map(value=>relative(path.resolve(oldBase,value)))])),...additions};
+    if(options){if(!ts.isObjectLiteralExpression(options))throw Error('tsconfig.compilerOptions must be an object');target=options;values={paths:merged};}
+    else{target=object;values={compilerOptions:{paths:merged}};}
+  }
+  const position=target.end-1,separator=target.properties.length&&!target.properties.hasTrailingComma?',':'';
+  const text=Object.entries(values).map(([name,value])=>JSON.stringify(name)+': '+JSON.stringify(value)).join(',\n  ');
+  await changed(filename,source.slice(0,position)+separator+'\n  '+text+'\n'+source.slice(position),updates);
+}
+/** Include one generated root without replacing JSONC comments or inherited include globs. */
+async function includeTypes(root,config,helper,updates){
+  const filename=path.resolve(root,config.typescript?.tsconfigPath||'tsconfig.json');
+  const source=await readFile(filename,'utf8').catch(error=>{if(error.code==='ENOENT')return;throw error;});if(source===undefined)return;
+  const toolchain=await resolveTypeScript(root);
+  if(toolchain.native){await changed(filename,await nativeTypeConfig(filename,helper),updates);return;}
+  let ts;try{ts=createRequire(path.join(root,'package.json'))('typescript');}catch{throw Error('typedRoutes requires TypeScript installed in the application');}
+  const parsed=ts.getParsedCommandLineOfConfigFile(filename,{noEmit:true},{...ts.sys,onUnRecoverableConfigFileDiagnostic:diagnostic=>{throw Error(ts.flattenDiagnosticMessageText(diagnostic.messageText,'\n'));}});
+  if(!parsed||parsed.errors.some(error=>error.code!==18003))throw Error('Cannot configure typed routes: invalid tsconfig');
+  if(parsed.fileNames.some(name=>path.resolve(name)===helper)){await bindTypes(filename,ts,updates);return;}
+  const ast=ts.parseJsonText(filename,source),object=ast.statements[0]?.expression;
+  if(!object||!ts.isObjectLiteralExpression(object))throw Error('Cannot add typed route declarations to tsconfig');
+  const property=object.properties.find(p=>p.name?.text==='files');
+  let edited;
+  if(property){
+    if(!ts.isArrayLiteralExpression(property.initializer))throw Error('tsconfig.files must be an array');
+    const array=property.initializer,position=array.end-1,separator=array.elements.length&&!array.elements.hasTrailingComma?',':'';
+    edited=source.slice(0,position)+separator+JSON.stringify(path.relative(path.dirname(filename),helper).replaceAll(path.sep,'/'))+source.slice(position);
+  }else{
+    // TS resolves inherited files relative to this config in parsed.raw.files.
+    const files=[...(parsed.raw.files||[]),path.relative(path.dirname(filename),helper).replaceAll(path.sep,'/')];
+    const position=object.end-1,separator=object.properties.length&&!object.properties.hasTrailingComma?',':'';
+    edited=source.slice(0,position)+separator+'\n  "files": '+JSON.stringify(files)+'\n'+source.slice(position);
+  }
+  await changed(filename,edited,updates);
+  await bindTypes(filename,ts,updates);
+}
+export async function writeTypedRoutes(root,project,config){
+  const updates=new Set();
+  const directory=path.join(root,'.prnext-types'),file=path.join(directory,'routes.d.ts');
+  const info=await lstat(directory).catch(error=>{if(error.code!=='ENOENT')throw error;});
+  if(info&&(!info.isDirectory()||info.isSymbolicLink())){if(config.typedRoutes)throw Error('.prnext-types must be a real directory');return;}
+  if(!config.typedRoutes){const existing=await readFile(file,'utf8').catch(()=>null);if(existing?.startsWith(marker))await changed(file,routeDeclarations({routes:[]},{enabled:false}),updates);return [...updates];}
+  await mkdir(directory,{recursive:true,mode:0o700});
+  const previous=await readFile(file,'utf8').catch(error=>{if(error.code!=='ENOENT')throw error;});
+  if(previous&&!previous.startsWith(marker))throw Error('Refusing to overwrite a non-generated route registry');
+  await changed(file,routeDeclarations(project),updates);
+  const helper=path.join(root,'prnext-env.d.ts'),reference='/// <reference path="./.prnext-types/routes.d.ts" />';
+  const contents=await readFile(helper,'utf8').catch(error=>{if(error.code==='ENOENT')return '';throw error;});
+  if(!contents.includes(reference))await changed(helper,reference+'\n'+contents,updates);
+  await includeTypes(root,config,helper,updates);
+  return [...updates];
+}

package/build/typescript-dev-worker.mjs

@@ -0,0 +1,18 @@
+import {createRequire} from 'node:module';
+import path from 'node:path';
+import {createTypeScriptWatchSystem} from './typescript-watch.mjs';
+const [compiler,filename,cache]=process.argv.slice(2),ts=createRequire(import.meta.url)(compiler);
+const format={getCanonicalFileName:name=>name,getCurrentDirectory:()=>path.dirname(filename),getNewLine:()=>ts.sys.newLine};
+const send=diagnostics=>{
+  let bytes=0;const errors=[];
+  for(const diagnostic of diagnostics){if(diagnostic.category!==ts.DiagnosticCategory.Error)continue;const text=ts.formatDiagnostics([diagnostic],format);if(bytes+text.length>20000||errors.length>=40)break;bytes+=text.length;errors.push(text);}
+  if(process.connected)process.send({type:'diagnostics',errors});
+};
+const host=ts.createWatchCompilerHost(filename,{noEmit:true,incremental:true,...(cache?{tsBuildInfoFile:cache}:{})},createTypeScriptWatchSystem(ts,process.cwd()),ts.createSemanticDiagnosticsBuilderProgram,diagnostic=>send([diagnostic]),()=>{});
+host.writeFile=(filename,contents)=>{if(cache&&path.resolve(filename)===path.resolve(cache))ts.sys.writeFile(filename,contents);};
+host.afterProgramCreate=builder=>{
+  try{send(ts.getPreEmitDiagnostics(builder.getProgram()));builder.emit(undefined,host.writeFile);}catch(error){send([{category:ts.DiagnosticCategory.Error,code:0,messageText:error.message}]);}
+};
+const watcher=ts.createWatchProgram(host);
+const close=()=>{watcher.close();process.exit(0);};
+process.once('disconnect',close);process.once('SIGTERM',close);process.once('SIGINT',close);

package/build/typescript-dev.mjs

@@ -0,0 +1,49 @@
+import {fork} from 'node:child_process';
+import {access} from 'node:fs/promises';
+import {resolveTypeScript} from './typescript-toolchain.mjs';
+import path from 'node:path';
+import {privateCacheDirectory} from './persistent-cache.mjs';
+export async function startTypeChecker(root,config,notify,{fork:spawnChecker=fork,recheckDelayMs=3000}={}){
+  const noop={inactive:true,async close(){}};
+  if(config.typescript?.devChecks===false)return noop;
+  const filename=path.resolve(root,config.typescript?.tsconfigPath||'tsconfig.json');try{await access(filename);}catch{return noop;}
+  let toolchain;try{toolchain=await resolveTypeScript(root);}catch(error){console.warn('TypeScript diagnostics could not start: '+error.message);return noop;}
+  const directory=await privateCacheDirectory(root,'typescript-dev');
+  let child,closed=false,failures=0,timer,restartTimer,planned,pendingInvalidation;
+  function launch(){
+    if(closed)return;
+    const worker=toolchain.native?'./typescript-native-worker.mjs':'./typescript-dev-worker.mjs';
+    child=spawnChecker(new URL(worker,import.meta.url),[toolchain.compiler,filename,toolchain.native?'watch':directory?path.join(directory,'project.tsbuildinfo'):''],{cwd:root,execArgv:['--max-old-space-size=512'],stdio:['ignore','ignore','pipe','ipc'],windowsHide:true});
+    const current=child;
+    let details='',healthyAt=0;child.stderr.on('data',chunk=>{details=(details+chunk).slice(-2048);});
+    child.on('message',message=>{
+      if(closed||child!==current||planned===current)return;
+      if(message?.type==='diagnostics'&&Array.isArray(message.errors)){
+        // The native watcher normally handles edits incrementally. Its startup
+        // can miss an edit; retain one bounded fallback when no report arrives.
+        if(pendingInvalidation?.worker===current&&!pendingInvalidation.forced){clearTimeout(restartTimer);pendingInvalidation=undefined;}
+        healthyAt ||= Date.now();notify(message.errors.filter(value=>typeof value==='string').slice(0,40));
+      }
+    });
+    child.on('error',error=>{notify(['TypeScript checker: '+error.message]);});
+    child.once('exit',()=>{
+      if(pendingInvalidation?.worker===current){clearTimeout(restartTimer);pendingInvalidation=undefined;}
+      if(closed)return;if(planned===current){planned=undefined;launch();return;}if(healthyAt&&Date.now()-healthyAt>=60000)failures=0;if(++failures>=3){notify(['TypeScript checker stopped after repeated failures. '+details]);return;}timer=setTimeout(launch,1000*failures);
+    });
+  }
+  launch();return {
+    invalidate(file,event){
+      if(!toolchain.native||closed||!child?.connected)return;
+      const extension=path.extname(file);if(extension&&!/^\.(?:[cm]?[jt]sx?|json)$/i.test(extension))return;
+      const forced=event==='rename'||/\.json$/i.test(file);
+      if(!forced&&event!=='change')return;
+      clearTimeout(restartTimer);
+      const pending={worker:child,forced:forced||pendingInvalidation?.forced===true};pendingInvalidation=pending;
+      restartTimer=setTimeout(()=>{
+        if(closed||pendingInvalidation!==pending||child!==pending.worker||!child?.connected)return;
+        pendingInvalidation=undefined;planned=child;child.disconnect();
+      },pending.forced?150:recheckDelayMs);
+    },
+    async close(){closed=true;clearTimeout(timer);clearTimeout(restartTimer);const old=child;if(!old||old.exitCode!==null||old.signalCode)return;await new Promise(resolve=>{const timer=setTimeout(()=>old.kill('SIGKILL'),5000);old.once('exit',()=>{clearTimeout(timer);resolve();});if(old.connected)old.disconnect();else old.kill();});},
+  };
+}

package/build/typescript-native-worker.mjs

@@ -0,0 +1,55 @@
+import {spawn} from 'node:child_process';
+import {StringDecoder} from 'node:string_decoder';
+import {mkdtemp,rm} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import path from 'node:path';
+
+const [compiler,filename,mode]=process.argv.slice(2);
+const watching=mode==='watch';
+let closing=false,buffer='',output='',overflow=false;
+const cache=await mkdtemp(path.join(tmpdir(),'prnext-typescript-native-'));
+const child=spawn(process.execPath,[compiler,'--project',filename,'--noEmit','--incremental','true','--tsBuildInfoFile',path.join(cache,'project.tsbuildinfo'),'--pretty','false','--locale','en',...(watching?['--watch','--preserveWatchOutput']:[])],{
+  cwd:process.cwd(),windowsHide:true,detached:process.platform!=='win32',stdio:['ignore','pipe','pipe'],
+  // Native TS respects explicit project watch options. The polling defaults
+  // also cover editors/filesystems that silently lose native watch events.
+  env:{...process.env,TSC_WATCHFILE:process.env.TSC_WATCHFILE||'DynamicPriorityPolling',TSC_WATCHDIRECTORY:process.env.TSC_WATCHDIRECTORY||'DynamicPriorityPolling'},
+});
+function send(value){if(process.connected)process.send(value);}
+function consume(chunk){
+  const text=chunk.toString('utf8').replace(/\x1b\[[0-9;]*[A-Za-z]/g,'');
+  if(!watching){output+=text;if(output.length>4*1024*1024){overflow=true;void close();}return;}
+  buffer+=text;
+  // Consume complete lines, not arbitrary OS chunks. Start/completion markers
+  // delimit each diagnostic generation; a successful edit clears old errors.
+  let end;
+  while((end=buffer.indexOf('\n'))!==-1){
+    const line=buffer.slice(0,end).replace(/\r$/,'');buffer=buffer.slice(end+1);
+    if(/Starting (?:incremental )?compilation in watch mode|File change detected/.test(line))output='';
+    else if(/Found \d+ errors?\. Watching for file changes\./.test(line)){
+      send({type:'diagnostics',errors:/Found 0 errors/.test(line)?[]:output.trim()?[output.trim()]:['TypeScript reported errors. Run prnext typecheck for details.']});output='';
+    }else if(line.trim()&&output.length<20000)output+=(line+'\n').slice(0,20000-output.length);
+  }
+  if(buffer.length>20000)buffer=buffer.slice(-20000);
+}
+for(const stream of [child.stdout,child.stderr]){
+  const decoder=new StringDecoder('utf8');stream.on('data',chunk=>consume(decoder.write(chunk)));stream.on('end',()=>consume(decoder.end()));
+}
+child.once('error',error=>{send({type:'failure',message:error.message});process.exitCode=1;});
+child.once('close',async(code,signal)=>{
+  // Only the directory returned by mkdtemp above is removed.
+  if(path.dirname(cache)===path.resolve(tmpdir())&&path.basename(cache).startsWith('prnext-typescript-native-'))await rm(cache,{recursive:true,force:true,maxRetries:5,retryDelay:100});
+  send({type:'complete',code:overflow?1:code??1,output:overflow?'TypeScript output exceeded 4 MiB. Run tsc directly for the complete output.':output,signal});
+  if(process.connected)process.disconnect();
+});
+async function close(){
+  if(closing)return;closing=true;
+  if(child.exitCode!==null||child.signalCode)return;
+  if(process.platform==='win32'){
+    // Own exactly this compiler subtree; TypeScript's official Node launcher
+    // starts its native executable as a child on Windows.
+    const killer=spawn('taskkill',['/PID',String(child.pid),'/T','/F'],{windowsHide:true,stdio:'ignore'});
+    killer.on('error',()=>child.kill('SIGKILL'));
+  }else{try{process.kill(-child.pid,'SIGTERM');}catch{child.kill('SIGTERM');}}
+}
+process.once('disconnect',()=>{void close();});
+process.once('SIGTERM',()=>{void close();});process.once('SIGINT',()=>{void close();});

package/build/typescript-native.mjs

@@ -0,0 +1,18 @@
+import {fork} from 'node:child_process';
+
+export function checkNativeTypeScript(compiler,filename,root){
+  return new Promise((resolve,reject)=>{
+    const child=fork(new URL('./typescript-native-worker.mjs',import.meta.url),[compiler,filename,'check'],{cwd:root,windowsHide:true,execArgv:[],stdio:['ignore','ignore','pipe','ipc']});
+    let result,details='',timedOut=false,force;
+    const deadline=setTimeout(()=>{timedOut=true;if(child.connected)child.disconnect();force=setTimeout(()=>child.kill('SIGKILL'),5000);},120000);
+    child.stderr.on('data',chunk=>{details=(details+chunk).slice(-8192);});
+    child.on('message',message=>{if(message?.type==='complete')result=message;else if(message?.type==='failure')details=String(message.message).slice(0,8192);});
+    child.once('error',error=>{clearTimeout(deadline);clearTimeout(force);reject(error);});
+    child.once('exit',()=>{
+      clearTimeout(deadline);clearTimeout(force);
+      if(timedOut)reject(new Error('TypeScript check exceeded 120 seconds. Run tsc directly to inspect the project.'));
+      else if(result?.code===0)resolve();
+      else reject(new Error(result?.output||details||'TypeScript native checker exited before returning diagnostics.'));
+    });
+  });
+}

package/build/typescript-toolchain.mjs

@@ -0,0 +1,19 @@
+import {readFile,stat} from 'node:fs/promises';
+import {createRequire} from 'node:module';
+import path from 'node:path';
+
+// Select from the application's installation, never from the framework's own
+// development dependencies. Native TypeScript deliberately lacks the old API.
+export async function resolveTypeScript(root) {
+  const require=createRequire(path.join(root,'package.json'));
+  const manifest=require.resolve('typescript/package.json');
+  const metadata=JSON.parse(await readFile(manifest,'utf8'));
+  const major=Number(/^([0-9]+)\./.exec(metadata.version)?.[1]);
+  if(!Number.isInteger(major))throw new Error('The installed TypeScript package has no valid version.');
+  if(major<7)return {native:false,compiler:require.resolve('typescript'),version:metadata.version};
+  const entry=typeof metadata.bin==='string'?metadata.bin:metadata.bin?.tsc;
+  if(typeof entry!=='string'||!entry)throw new Error('The installed TypeScript package has no tsc command. Reinstall TypeScript with its optional native dependencies.');
+  const directory=path.dirname(manifest),bin=path.resolve(directory,entry);
+  if(!bin.startsWith(directory+path.sep)||!(await stat(bin)).isFile())throw new Error('The installed TypeScript tsc command is invalid.');
+  return {native:true,compiler:bin,version:metadata.version};
+}

package/build/typescript-watch.mjs

@@ -0,0 +1,22 @@
+import path from 'node:path';
+
+// macOS native file notifications can miss an edit while the watch program is
+// compiling. Use TypeScript's adaptive metadata polling for project inputs;
+// installed dependencies keep native watchers and incur no extra polling.
+export function createTypeScriptWatchSystem(ts,root,{platform=process.platform,env=process.env}={}){
+  const system=ts.sys;
+  if(platform!=='darwin'||env.TSC_WATCHFILE||env.TSC_NONPOLLING_WATCHER)return system;
+  const requestedRoot=path.resolve(root);
+  const physical=filename=>{try{return path.resolve(system.realpath?.(filename)||filename);}catch{return path.resolve(filename);}};
+  const physicalRoot=physical(requestedRoot),normalize=filename=>system.useCaseSensitiveFileNames?filename:filename.toLowerCase();
+  const inside=(base,filename)=>{
+    const relative=path.relative(normalize(base),normalize(filename));
+    return relative&&relative!=='..'&&!relative.startsWith('..'+path.sep)&&!path.isAbsolute(relative)&&!relative.split(path.sep).includes('node_modules');
+  };
+  return {...system,watchFile(filename,callback,interval,options){
+    const absolute=path.resolve(filename);
+    if(options?.watchFile===undefined&&(inside(requestedRoot,absolute)||inside(physicalRoot,absolute))&&inside(physicalRoot,physical(absolute)))
+      options={...options,watchFile:ts.WatchFileKind.DynamicPriorityPolling};
+    return system.watchFile(filename,callback,interval,options);
+  }};
+}

package/build/typescript.mjs

@@ -1,20 +1,22 @@
 import { stat } from 'node:fs/promises';
-import { createRequire } from 'node:module';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
+import {resolveTypeScript} from './typescript-toolchain.mjs';
+import {checkNativeTypeScript} from './typescript-native.mjs';
 
 const execute = promisify(execFile);
 
 export function validateTypeScript(input) {
   if (input === undefined) return undefined;
   if (!input || typeof input !== 'object' || Array.isArray(input)) throw new TypeError('typescript must be an object');
-  for (const key of Object.keys(input)) if (!['ignoreBuildErrors', 'tsconfigPath'].includes(key)) throw new TypeError(`typescript.${key} is not supported`);
+  for (const key of Object.keys(input)) if (!['ignoreBuildErrors', 'tsconfigPath', 'devChecks'].includes(key)) throw new TypeError(`typescript.${key} is not supported`);
   const { ignoreBuildErrors = false, tsconfigPath = 'tsconfig.json' } = input;
   if (typeof ignoreBuildErrors !== 'boolean') throw new TypeError('typescript.ignoreBuildErrors must be a boolean');
   if (typeof tsconfigPath !== 'string' || !tsconfigPath || tsconfigPath.includes('\0') || Buffer.byteLength(tsconfigPath) > 4096) throw new TypeError('typescript.tsconfigPath must be a nonempty filesystem path of at most 4096 bytes');
-  return { ignoreBuildErrors, tsconfigPath };
+  if(input.devChecks!==undefined&&typeof input.devChecks!=='boolean')throw new TypeError('typescript.devChecks must be a boolean');
+  return { ignoreBuildErrors, tsconfigPath, ...(input.devChecks===undefined?{}:{devChecks:input.devChecks}) };
 }
 
 export async function projectTsconfig(root, config) {
@@ -32,15 +34,16 @@ export async function projectTsconfig(root, config) {
 
 /** Run the checker outside the build/dev process so its graph is released on exit.
  * Never emit files, rewrite the user's config, or install packages implicitly. */
-export async function checkTypeScript(root, config, { dev = false, tsconfig } = {}) {
-  if (dev || !config.typescript || config.typescript.ignoreBuildErrors) return;
+export async function checkTypeScript(root, config, { dev = false, tsconfig, force = false } = {}) {
+  if (!force && (dev || !config.typescript || config.typescript.ignoreBuildErrors)) return;
   tsconfig ??= await projectTsconfig(root, config);
   if (!tsconfig) throw new Error('TypeScript checking was explicitly enabled, but tsconfig.json does not exist. Create a TypeScript configuration, set typescript.tsconfigPath to an existing configuration, or explicitly set typescript.ignoreBuildErrors: true if types are checked separately.');
-  let compiler;
-  try { compiler = createRequire(path.join(root, 'package.json')).resolve('typescript'); }
+  let toolchain;
+  try { toolchain = await resolveTypeScript(root); }
   catch (error) { throw new Error('TypeScript checking requires typescript in the project. Install it as a dev dependency, or explicitly set typescript.ignoreBuildErrors: true if a separate process checks types.', { cause: error }); }
   try {
-    await execute(process.execPath, [fileURLToPath(new URL('./typescript-check.mjs', import.meta.url)), compiler, tsconfig], {
+    if(toolchain.native){await checkNativeTypeScript(toolchain.compiler,tsconfig,root);return;}
+    await execute(process.execPath, [fileURLToPath(new URL('./typescript-check.mjs', import.meta.url)), toolchain.compiler, tsconfig], {
       cwd: root, windowsHide: true, maxBuffer: 4 * 1024 * 1024,
     });
   } catch (error) {