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

package/build/webpack-graph.mjs

@@ -1,11 +1,12 @@
 import {build as esbuild, transform} from 'esbuild';
-import {mkdir, mkdtemp, readFile, writeFile, rm, realpath} from 'node:fs/promises';
+import {mkdir, mkdtemp, readFile, writeFile, rm, rmdir, realpath} from 'node:fs/promises';
 import {createHash, randomUUID} from 'node:crypto';
 import {createRequire} from 'node:module';
 import {fileURLToPath} from 'node:url';
 import path from 'node:path';
 import { cachedAsyncTransform } from './transform-cache.mjs';
 import {inlineSourceMap} from './source-maps.mjs';
+import {buildCacheIdentity} from './persistent-cache.mjs';
 
 const require = createRequire(import.meta.url);
 const {active} = require('./webpack-bridge.cjs');
@@ -13,6 +14,107 @@ const loaderPath = fileURLToPath(new URL('./webpack-loader.cjs', import.meta.url
 const hash = value => createHash('sha256').update(value).digest('hex').slice(0, 20);
 const slash = value => value.replaceAll(path.sep, '/');
 const safeAsset = name => { if (path.isAbsolute(name) || /[\\\0?#]/.test(name) || name.split('/').some(part => !part || part === '.' || part === '..')) throw new Error(`Unsafe webpack asset path: ${name}`); };
+async function discardPrivateFile(file,boundary){
+  await rm(file,{force:true});
+  for(let directory=path.dirname(file);directory!==boundary&&directory.startsWith(boundary+path.sep);directory=path.dirname(directory)){
+    try{await rmdir(directory);}catch(error){if(['ENOTEMPTY','EEXIST'].includes(error.code))break;if(error.code!=='ENOENT')throw error;}
+  }
+}
+const sessions=new Map(),sessionLimit=6,sessionBuildLimit=64,objectIds=new WeakMap();
+let nextId=0,created=0,reused=0,graphQueue=Promise.resolve();
+const objectId=value=>{if(!objectIds.has(value))objectIds.set(value,++nextId);return objectIds.get(value);};
+// Arbitrary plugin closures are not interchangeable just because their source
+// text matches. Only known webpack constructors with the same options may be
+// recreated; other plugins must retain their actual instance identity.
+function fingerprint(value,seen=new Set()){
+  if(typeof value==='function')return ['function',objectId(value)];
+  if(value instanceof RegExp)return ['regexp',value.source,value.flags];
+  if(value===undefined)return ['undefined'];
+  if(typeof value==='symbol')throw new Error('Opaque symbol in webpack configuration');
+  if(typeof value==='bigint')return ['bigint',String(value)];
+  if(typeof value==='number'&&(!Number.isFinite(value)||Object.is(value,-0)))return ['number',String(value),Object.is(value,-0)];
+  if(!value||typeof value!=='object')return value;
+  if(seen.has(value))return ['object',objectId(value)];
+  seen.add(value);
+  const properties=(skipIndices=false)=>{
+    const keys=Reflect.ownKeys(value);
+    if(keys.length>10000||keys.some(key=>typeof key==='symbol'))throw new Error('Opaque or excessive webpack configuration');
+    return keys.filter(key=>!skipIndices||!/^(?:0|[1-9]\d*)$/.test(key)).sort().map(key=>{
+      const descriptor=Object.getOwnPropertyDescriptor(value,key);if(descriptor.get||descriptor.set)throw new Error('Accessor in webpack configuration');
+      return[key,descriptor.enumerable,descriptor.configurable,descriptor.writable,fingerprint(descriptor.value,seen)];
+    });
+  };
+  const prototype=Object.getPrototypeOf(value);let result;
+  if(Array.isArray(value))result=['array',properties()];
+  else if(prototype===Map.prototype){
+    const extras=properties();
+    if(value.size>10000)throw new Error('Excessive webpack Map configuration');
+    const key=item=>item&&(typeof item==='object'||typeof item==='function')?['identity',objectId(item),fingerprint(item,seen)]:fingerprint(item,seen);
+    result=['map',[...Map.prototype.entries.call(value)].map(([name,item])=>[key(name),fingerprint(item,seen)]),extras];
+  }else if(prototype===Set.prototype){
+    const extras=properties();
+    if(value.size>10000)throw new Error('Excessive webpack Set configuration');
+    result=['set',[...Set.prototype.values.call(value)].map(item=>item&&(typeof item==='object'||typeof item==='function')?['identity',objectId(item),fingerprint(item,seen)]:fingerprint(item,seen)),extras];
+  }else if(prototype===Date.prototype)result=['date',String(Date.prototype.getTime.call(value)),properties()];
+  else if(prototype===ArrayBuffer.prototype){
+    if(value.byteLength>1024*1024)throw new Error('Excessive webpack binary configuration');
+    result=['array-buffer',Buffer.from(value).toString('base64'),value.resizable,value.maxByteLength,properties()];
+  }else if(ArrayBuffer.isView(value)){
+    if(value.byteLength>10000)throw new Error('Excessive webpack binary view configuration');
+    const types=[Buffer,Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,BigInt64Array,BigUint64Array,DataView];
+    const type=types.find(type=>prototype===type.prototype);
+    if(!type)throw new Error('Opaque webpack binary configuration');
+    result=[type.name,fingerprint(value.buffer,seen),value.byteOffset,value.byteLength,properties(true)];
+  }else if(prototype===Object.prototype||prototype===null)result=['record',prototype===null,properties()];
+  else throw new Error('Opaque webpack configuration instance');
+  seen.delete(value);return result;
+}
+function pluginIdentity(plugin,webpack){
+  const fields={NormalModuleReplacementPlugin:['resourceRegExp','newResource'],IgnorePlugin:['options'],ProvidePlugin:['definitions'],DefinePlugin:['definitions'],BannerPlugin:['options']};
+  for(const[name,keys]of Object.entries(fields))if(plugin.constructor===webpack[name])return[name,fingerprint(Object.fromEntries(keys.map(key=>[key,plugin[key]])))];
+  return ['instance',objectId(plugin),fingerprint(plugin)];
+}
+export const webpackCompilerStats=()=>({contexts:sessions.size,created,reused,limit:sessionLimit,buildLimit:sessionBuildLimit});
+function queued(callback){const task=graphQueue.then(callback);graphQueue=task.catch(()=>{});return task;}
+export function closeWebpackCompiler(root){return queued(async()=>{
+  const closing=[];for(const[key,session]of sessions)if(root===undefined||session.root===root){sessions.delete(key);closing.push(session.dispose());}
+  const results=await Promise.allSettled(closing),errors=results.filter(result=>result.status==='rejected').map(result=>result.reason);
+  if(errors.length)throw new AggregateError(errors,'Unable to dispose webpack compiler sessions');
+});}
+
+async function compileGraph(resolver,loads,options,{state,config,target}){
+  return queued(async()=>{
+    const webpack=(await import('webpack')).default;
+    let reusable=state.dev&&state.incremental,identity;
+    if(reusable){try{identity=await buildCacheIdentity(state.root);}catch{}if(!identity)reusable=false;}
+    let base,key;
+    if(reusable)try{
+      const normalize=value=>typeof value==='string'?value.replaceAll(state.stage,'<stage>'):Array.isArray(value)?value.map(normalize):value&&typeof value==='object'&&[Object.prototype,null].includes(Object.getPrototypeOf(value))?Object.fromEntries(Object.entries(value).map(([key,item])=>[key,normalize(item)])):value;
+      const normalized=normalize({...options,plugins:(options.plugins||[]).map(plugin=>plugin.name),stdin:options.stdin&&{...options.stdin,contents:undefined}});
+      base=hash(JSON.stringify(fingerprint([state.root,target,normalized])));
+      key=hash(JSON.stringify([base,identity,fingerprint({...config,graphPlugins:undefined}),config.graphPlugins.map(plugin=>pluginIdentity(plugin,webpack))]));
+    }catch{reusable=false;}
+    // Unknown data structures, safe mode and unavailable identities all keep
+    // compilation correct through a one-shot compiler. Hidden mutable closure
+    // state cannot be fingerprinted: replace the plugin instance when it changes.
+    if(state.dev&&!reusable)for(const[key,session]of sessions)if(session.root===state.root){sessions.delete(key);await session.dispose();}
+    let session=reusable&&sessions.get(key);
+    if(session&&session.builds>=sessionBuildLimit){sessions.delete(key);await session.dispose();session=undefined;}
+    if(reusable){
+      for(const[old,previous]of sessions)if(previous.root===state.root&&(previous.identity!==identity||previous.base===base&&old!==key)){sessions.delete(old);await previous.dispose();}
+    }
+    if(session){sessions.delete(key);reused++;}
+    else{
+      if(reusable)while(sessions.size>=sessionLimit){const[old,previous]=sessions.entries().next().value;sessions.delete(old);await previous.dispose();}
+      session=await createGraphSession(state.root,{webpack,reusable,stage:state.stage});created++;
+      Object.assign(session,{root:state.root,base,identity,builds:0});
+    }
+    if(reusable)sessions.set(key,session);
+    try{session.builds++;return await session.run(resolver,loads,options,{state,config,target});}
+    catch(error){if(reusable)sessions.delete(key);await session.dispose();throw error;}
+    finally{if(!reusable)await session.dispose();}
+  });
+}
 
 /** Webpack owns the actual module/chunk graph. PRNext's resolve/load transforms
  * remain authoritative for React boundaries and the Node/Edge/browser targets.
@@ -37,27 +139,41 @@ export async function webpackGraph(options, {state, config, target}) {
   finally { for (const dispose of disposes) await dispose(); }
 }
 
-async function compileGraph(resolver, loads, options, {state,config,target}) {
-  const webpack = (await import('webpack')).default;
+async function createGraphSession(root,{webpack,reusable,stage}) {
   const bridgeId = randomUUID();
-  await mkdir(path.join(state.stage,'.entries'),{recursive:true});
-  const virtualDirectory = await realpath(await mkdtemp(path.join(state.stage,'.entries/webpack-')));
-  const temporary = await mkdtemp(path.join(state.stage,'.webpack-output-'));
-  const outdir = options.outdir || (options.outfile ? path.dirname(options.outfile) : temporary);
-  const actualOut = options.write === false ? temporary : outdir;
-  const extension = options.outExtension?.['.js'] || '.js';
-  const modules = new Map();
-  const projectRequire = createRequire(path.join(state.root,'package.json'));
-  let compiler;
-  const entries = options.stdin ? {entry:path.join(virtualDirectory,'entry.js')}
-    : Array.isArray(options.entryPoints) ? Object.fromEntries(options.entryPoints.map(file=>[path.basename(file,path.extname(file)),file])) : options.entryPoints;
+  await mkdir(path.join(stage,'.entries'),{recursive:true});
+  const home=await realpath(await mkdtemp(path.join(reusable?root:path.join(stage,'.entries'),'.prnext-webpack-')));
+  const virtualDirectory=path.join(home,'modules'),virtualStage=path.join(home,'stage'),scratchOut=path.join(home,'output');
+  await mkdir(virtualDirectory,{recursive:true});
+  const projectRequire = createRequire(path.join(root,'package.json'));
+  let compiler,resolver,loads,options,state,config,target,outdir,actualOut,extension,modules,entries,runtime,disposed=false;
+  const virtualFiles=new Set(),loaderFiles=new Set(),previousOutputs=new Set();let usedVirtualFiles;
+  const fromVirtual=value=>typeof value==='string'&&(value===virtualStage||value.startsWith(virtualStage+path.sep))?state.stage+value.slice(virtualStage.length):value;
+  const toVirtual=value=>reusable&&typeof value==='string'&&(value===state.stage||value.startsWith(state.stage+path.sep))?virtualStage+value.slice(state.stage.length):value;
+  const stageFile=async file=>{
+    const mapped=toVirtual(file);if(mapped===file)return file;
+    virtualFiles.add(mapped);usedVirtualFiles.add(mapped);
+    const contents=await readFile(file);await mkdir(path.dirname(mapped),{recursive:true});
+    let previous;try{previous=await readFile(mapped);}catch(error){if(error.code!=='ENOENT')throw error;}
+    if(!previous?.equals(contents))await writeFile(mapped,contents);return mapped;
+  };
+  const run=async(nextResolver,nextLoads,nextOptions,next)=>{
+  resolver=nextResolver;loads=nextLoads;options=nextOptions;({state,config,target}=next);
+  usedVirtualFiles=new Set();
+  outdir=options.outdir||(options.outfile?path.dirname(options.outfile):scratchOut);actualOut=reusable||options.write===false?scratchOut:outdir;extension=options.outExtension?.['.js']||'.js';modules=new Map();
+  // Webpack may retain SizeOnlySource for unchanged assets and assume the last
+  // emitted file still exists. Keep current outputs until the next run finishes.
+  await mkdir(actualOut,{recursive:true});
+  entries=options.stdin?{entry:path.join(virtualDirectory,'entry.js')}:Array.isArray(options.entryPoints)?Object.fromEntries(options.entryPoints.map(file=>[path.basename(file,path.extname(file)),toVirtual(file)])):Object.fromEntries(Object.entries(options.entryPoints).map(([name,file])=>[name,toVirtual(file)]));
+  for(const file of Object.values(entries))if(file.startsWith(virtualStage+path.sep))await stageFile(fromVirtual(file));
   if (options.stdin) {
     const file = entries.entry;
     await writeFile(file,options.stdin.contents);
+    virtualFiles.add(file);usedVirtualFiles.add(file);
     modules.set(file,{path:file,namespace:'file',resolveDir:options.stdin.resolveDir || state.root,stdin:true});
   }
   const identify = record => record.namespace === 'file' ? slash(path.relative(state.root,record.path)) : record.namespace+':'+slash(path.relative(state.root,record.path));
-  const lookup = resource => modules.get(resource) || modules.get(resource?.split('?')[0]) || {path:resource?.split('?')[0],namespace:'file',suffix:resource?.includes('?')?'?'+resource.split('?').slice(1).join('?'):''};
+  const lookup = resource => modules.get(resource) || modules.get(resource?.split('?')[0]) || {path:fromVirtual(resource?.split('?')[0]),namespace:'file',suffix:resource?.includes('?')?'?'+resource.split('?').slice(1).join('?'):''};
   const load = async(record,source,webpackContext,sourceMap) => {
     if (record.stdin) return {contents:source,loader:options.stdin.loader || 'js',resolveDir:record.resolveDir};
     for (const {settings,callback,framework,configuredLoaders} of loads) {
@@ -106,18 +222,18 @@ async function compileGraph(resolver, loads, options, {state,config,target}) {
   // A changed synchronous chunk may leave webpack's runtime bytes unchanged.
   // Give each published build its own module cache; React's dev singletons
   // still retain their identities across the new runtime instance.
-  const runtime = 'webpack-runtime-'+hash(JSON.stringify([state.stage,Object.keys(entries),options.conditions,target]));
+  runtime = 'webpack-runtime-'+hash(JSON.stringify([state.stage,Object.keys(entries),options.conditions,target]));
   try {
-    compiler = webpack({name:target,context:state.root,mode:state.dev?'development':'production',
+    if(!compiler)compiler = webpack({name:target,context:state.root,mode:state.dev?'development':'production',
       ...(config.watchOptions ? {watchOptions:config.watchOptions} : {}),
-      target:target==='node'?'node22':['web','es2022'],entry:entries,cache:false,devtool:options.sourcemap?'source-map':false,
+      target:target==='node'?'node22':['web','es2022'],entry:entries,cache:reusable?{type:'memory',maxGenerations:1}:false,devtool:options.sourcemap?'source-map':false,
       experiments:{outputModule:true,css:true},externalsType:'module',
       output:{path:actualOut,filename:options.outfile?path.basename(options.outfile):naming(options.entryNames)+extension,
         chunkFilename:naming(options.chunkNames || 'chunk-[hash]')+extension,cssFilename:naming(options.entryNames)+'.css',
         cssChunkFilename:'style-[contenthash:16].css',module:true,library:{type:'module'},chunkFormat:'module',chunkLoading:'import',
-        publicPath:target==='node'?'./':state.assetBase+'/',environment:{module:true,dynamicImport:true},clean:false},
+        publicPath:target==='node'?'./':state.assetBase+'/',environment:{module:true,dynamicImport:true},compareBeforeEmit:false,clean:false},
       performance:false,
-      optimization:{minimize:!!options.minify,minimizer:[{apply(compiler){
+      optimization:{minimize:!!options.minify,mangleExports:options.minify?'size':false,minimizer:[{apply(compiler){
         compiler.hooks.compilation.tap('PRNextMinify',compilation=>{
           compilation.hooks.processAssets.tapPromise({name:'PRNextMinify',stage:webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE},async()=>{
             // Sequential native esbuild transforms avoid a Terser worker pool.
@@ -130,10 +246,10 @@ async function compileGraph(resolver, loads, options, {state,config,target}) {
             }
           });
         });
-      }}],runtimeChunk:options.splitting?{name:runtime}:false,
-        splitChunks:options.splitting?{chunks:'all',minSize:0,cacheGroups:{default:false,defaultVendors:false,shared:{minChunks:2,test:module=>!module.type.startsWith('css'),name:false}}}:false},
+      }}],runtimeChunk:options.splitting?{name:()=>runtime}:false,
+        splitChunks:options.splitting?{chunks:'all',minSize:0,cacheGroups:{default:false,defaultVendors:false,shared:{minChunks:2,reuseExistingChunk:true,test:module=>!module.type.startsWith('css'),name:false}}}:false},
       resolve:{alias:config.resolution.resolveAlias || {},conditionNames:[...(options.conditions || []),'...'],extensions:config.resolution.resolveExtensions || ['.tsx','.ts','.jsx','.js','.mjs','.json'],fullySpecified:false},
-      module:{rules:[{test:/./,type:'javascript/auto',enforce:'post',use:[{loader:loaderPath,options:{bridge:bridgeId}}]},
+      module:{unsafeCache:false,rules:[{test:/./,type:'javascript/auto',enforce:'post',use:[{loader:loaderPath,options:{bridge:bridgeId}}]},
         {test:/\.json$/,type:'json'},{test:/\.(?:css|scss|sass)$/,type:'css'},
         {dependency:'url',type:'asset/resource'}]},
       plugins:[...config.graphPlugins,
@@ -143,7 +259,7 @@ async function compileGraph(resolver, loads, options, {state,config,target}) {
         {apply(compiler) {
           if (state.devInputs && config.graphPlugins.some(plugin=>plugin.constructor?.name==='ContentlayerWebpackPlugin')) {
             compiler.hooks.beforeCompile.tapPromise({name:'PRNextGeneratedInputs',stage:Number.MAX_SAFE_INTEGER},()=>
-              state.generatedInputs ||= state.devInputs.captureDirectory('.contentlayer/generated'));
+              state.devInputs&&(state.generatedInputs ||= state.devInputs.captureDirectory('.contentlayer/generated')));
           }
           compiler.hooks.normalModuleFactory.tap('PRNextFramework',factory=>{
             factory.hooks.beforeResolve.tapPromise({name:'PRNextFramework',stage:10000},async data=>{
@@ -151,12 +267,12 @@ async function compileGraph(resolver, loads, options, {state,config,target}) {
               const importer = lookup(data.contextInfo.issuer);
               const dependency = data.dependencies[0];
               const kind = dependency?.type?.includes('url') ? 'url-token' : dependency?.type==='css @import'?'import-rule':data.dependencyType==='commonjs'?'require-call':dependency?.type==='import()'?'dynamic-import':data.contextInfo.issuer?'import-statement':'entry-point';
-              const settings={resolveDir:importer.resolveDir || data.context || state.root,importer:importer.path || '',namespace:importer.namespace || 'file',kind};
+              const settings={resolveDir:fromVirtual(importer.resolveDir || data.context || state.root),importer:importer.path || '',namespace:importer.namespace || 'file',kind};
               // Let webpack resolve/execute the inline loader chain itself. Only
               // its resource passes through framework resolution.
               const bang=data.request.lastIndexOf('!');
               const inline=bang<0?'':data.request.slice(0,bang+1);
-              const request=bang<0?data.request:data.request.slice(bang+1);
+              const request=fromVirtual(bang<0?data.request:data.request.slice(bang+1));
               const resolved = await resolver.resolve(request,settings);
               if (resolved.errors.length) throw new Error(resolved.errors.map(error=>error.text).join('\n'));
               if (resolved.external) {
@@ -174,6 +290,9 @@ async function compileGraph(resolver, loads, options, {state,config,target}) {
               if(record.namespace!=='file'){
                 resource=path.join(virtualDirectory,hash(JSON.stringify([record.namespace,record.path,record.suffix]))+(/css$/.test(record.namespace)?'.css':'.js'));
                 if(!modules.has(resource))await writeFile(resource,'');
+                virtualFiles.add(resource);usedVirtualFiles.add(resource);
+              }else if(toVirtual(record.path)!==record.path){
+                resource=await stageFile(record.path)+(record.suffix||'');
               }
               data.request=inline+resource;
               modules.set(data.request,record);
@@ -206,6 +325,11 @@ async function compileGraph(resolver, loads, options, {state,config,target}) {
           });
         }},
       ]});
+    // Native loader modules live outside webpack's graph cache. Reload tracked
+    // implementations so editing a loader cannot retain its require() closure.
+    const clearLoader=file=>{const loaded=require.cache[file];delete require.cache[file];for(const child of loaded?.children||[])if(child.filename!==loaderPath)clearLoader(child.filename);};
+    for(const file of loaderFiles)clearLoader(file);
+    compiler.inputFileSystem.purge?.();
     const stats=await new Promise((resolve,reject)=>compiler.run((error,stats)=>error?reject(error):resolve(stats)));
     if(stats.hasErrors())throw new Error(stats.toString({all:false,errors:true,errorDetails:true}));
     for(const warning of stats.compilation.warnings){
@@ -218,10 +342,11 @@ async function compileGraph(resolver, loads, options, {state,config,target}) {
     for(const chunk of compilation.chunks)for(const file of chunk.files)chunkFiles.add(file);
     for(const [name,entry] of compilation.entrypoints){
       const file=[...entry.getEntrypointChunk().files].find(file=>file.endsWith(extension));
-      if(file)entryFiles.set(file,entries[name]);
+      if(file)entryFiles.set(file,fromVirtual(entries[name]));
       const css=entry.getFiles().find(file=>file.endsWith('.css'));if(file&&css)styles.set(file,css);
     }
     for(const module of compilation.modules){
+      for(const loader of module.loaders||[])if(loader.loader!==loaderPath)loaderFiles.add(loader.loader);
       if(!module.resource)continue;
       const record=lookup(module.resource), imports=[];
       for(const connection of compilation.moduleGraph.getOutgoingConnections(module)){
@@ -234,6 +359,7 @@ async function compileGraph(resolver, loads, options, {state,config,target}) {
       safeAsset(asset.name);
       const contents=await readFile(path.join(actualOut,asset.name));
       const file=path.join(outdir,asset.name), key=slash(path.relative(state.root,file));
+      if(options.write!==false&&file!==path.join(actualOut,asset.name)){await mkdir(path.dirname(file),{recursive:true});await writeFile(file,contents);}
       outputs[key]={bytes:contents.length,imports:[],exports:[],inputs:inputSizes,
         ...(entryFiles.has(asset.name)?{entryPoint:slash(path.relative(state.root,entryFiles.get(asset.name)))}:{}),
         ...(styles.has(asset.name)?{cssBundle:slash(path.relative(state.root,path.join(outdir,styles.get(asset.name))))}:{})};
@@ -248,9 +374,23 @@ async function compileGraph(resolver, loads, options, {state,config,target}) {
     }
     const rank = file => entryFiles.has(slash(path.relative(outdir,file.path))) ? 0 : file.path.endsWith(extension) ? 1 : 2;
     outputFiles.sort((a,b)=>rank(a)-rank(b));
-    return {errors:[],warnings:[],metafile:{inputs,outputs},...(options.write===false?{outputFiles}:{})};
+    if(reusable){
+      const currentOutputs=new Set(compilation.getAssets().map(asset=>asset.name));
+      for(const name of previousOutputs)if(!currentOutputs.has(name))await discardPrivateFile(path.join(actualOut,name),actualOut);
+      previousOutputs.clear();for(const name of currentOutputs)previousOutputs.add(name);
+    }
+    // This compatibility metafile does not yet encode webpack's runtime and
+    // async chunk-group edges. Consumers must not mistake empty import lists
+    // for a complete initial browser graph.
+    return {errors:[],warnings:[],metafile:{inputs,outputs,initialGraphComplete:false},...(options.write===false?{outputFiles}:{})};
   } finally {
-    try {if(compiler)await new Promise((resolve,reject)=>compiler.close(error=>error?reject(error):resolve()));}
-    finally {active.delete(bridgeId);await rm(temporary,{recursive:true,force:true});await rm(virtualDirectory,{recursive:true,force:true});}
+    active.delete(bridgeId);
+    for(const file of virtualFiles)if(!usedVirtualFiles.has(file)){virtualFiles.delete(file);await discardPrivateFile(file,home);}
   }
+  };
+  return {run,async dispose(){
+    if(disposed)return;disposed=true;
+    try{if(compiler)await new Promise((resolve,reject)=>compiler.close(error=>error?reject(error):resolve()));}
+    finally{active.delete(bridgeId);await rm(home,{recursive:true,force:true});compiler=resolver=state=config=options=modules=undefined;loads=[];virtualFiles.clear();loaderFiles.clear();previousOutputs.clear();}
+  }};
 }

package/build/worker-memory.mjs

@@ -0,0 +1,9 @@
+export function validateWorkerMemory(value) {
+  if (value === undefined || value === false) return undefined;
+  if (!value || typeof value !== 'object' || Array.isArray(value) ||
+      Object.keys(value).some(key => key !== 'maxRssMb') ||
+      !Number.isSafeInteger(value.maxRssMb) || value.maxRssMb < 64 || value.maxRssMb > 65536) {
+    throw new TypeError('workerMemory must be false or { maxRssMb: 64..65536 }');
+  }
+  return { maxRssMb: value.maxRssMb };
+}

package/build/worker-preload.mjs

@@ -0,0 +1,9 @@
+export function validateWorkerPreload(value){
+  if(value===undefined||value===false)return undefined;
+  if(!value||typeof value!=='object'||Array.isArray(value))throw new TypeError('workerPreload must be false or an object');
+  for(const key of Object.keys(value))if(!['routes','maxRssMb','timeoutMs'].includes(key))throw new TypeError(`workerPreload.${key} is not supported`);
+  if(!Array.isArray(value.routes)||!value.routes.length||value.routes.length>16||value.routes.some(route=>typeof route!=='string'||!route.startsWith('/')||route.length>1024||/[?#\x00-\x1f]/.test(route))||new Set(value.routes).size!==value.routes.length)throw new TypeError('workerPreload.routes must contain 1 to 16 distinct route patterns');
+  const options={routes:value.routes,maxRssMb:value.maxRssMb??256,timeoutMs:value.timeoutMs??5000};
+  for(const [key,min,max] of [['maxRssMb',16,2048],['timeoutMs',100,30000]])if(!Number.isInteger(options[key])||options[key]<min||options[key]>max)throw new TypeError(`workerPreload.${key} must be between ${min} and ${max}`);
+  return options;
+}