@redue/cli 0.1.0-alpha.3 → 0.1.0-alpha.30

package/src/decision-profile.mjs

@@ -1,15 +1,29 @@
 // Opt-in, bounded local diagnostics. Never include paths, command arguments,
 // environment values, source, or probe output in a timing record.
 import fs from 'node:fs';
+import {AsyncLocalStorage} from 'node:async_hooks';
+import {randomUUID} from 'node:crypto';
 
 const file=process.env.REDUE_DECISION_PROFILE_FILE;
 export const profiling=process.env.REDUE_DECISION_PROFILE==='1'&&!!file;
 
+const traces=new AsyncLocalStorage();
+const safe=value=>typeof value==='string'&&/^[a-zA-Z0-9_-]{1,64}$/.test(value)?value:undefined;
+const clean=value=>Object.fromEntries(['request','generation','work'].map(key=>[key,safe(value?.[key])]).filter(([,v])=>v));
+let base={};
+try{base=clean(JSON.parse(process.env.REDUE_PROFILE_CONTEXT||'{}'));}catch{}
+export const traceContext=()=>profiling?{...base,...traces.getStore()}:{};
+export function traceBase(value){if(profiling)base=clean(value);}
+export const traceId=()=>randomUUID();
+export const traceScope=(value,fn)=>profiling?traces.run({...traceContext(),...clean(value)},fn):fn();
+export const traceEnvironment=()=>profiling?{...process.env,REDUE_PROFILE_CONTEXT:JSON.stringify(traceContext())}:process.env;
+export function mark(phase,fields={}){timing(phase,performance.now(),fields);}
+
 export function timing(phase,started,counts={}) {
   if(!profiling)return;
   const memory=process.memoryUsage();
   try{fs.appendFileSync(file,'REDUE_TIMING '+JSON.stringify({
-      at:Date.now(),pid:process.pid,phase,
+      at:Date.now(),monoNs:process.hrtime.bigint().toString(),pid:process.pid,phase,...traceContext(),
       ms:Math.round((performance.now()-started)*10)/10,
       rssMiB:Math.round(memory.rss/1048576*10)/10,
       ...counts

package/src/decision-validation.mjs

@@ -17,7 +17,8 @@ export function planGuard(bundle) {
     ...bundle.workspaceManifests||[],...bundle.configurationInputs||[],
     ...Object.values(bundle.plans).flatMap(plan=>plan.resolutionTriggers||[])]);
   const patterns=bundle.workspacePatterns?.length?bundle.workspacePatterns:
-    (()=>{const pkg=JSON.parse(fs.readFileSync(path.join(root,'package.json')));
+    (()=>{let pkg;try{pkg=JSON.parse(fs.readFileSync(path.join(root,'package.json')));}
+      catch(e){if(e.code==='ENOENT')return [];throw e;}
       return Array.isArray(pkg.workspaces)?pkg.workspaces:pkg.workspaces?.packages||[];})();
   if(patterns.length){
     const files=execFileSync('git',['ls-files','--cached','--others','--exclude-standard',
@@ -39,3 +40,13 @@ export function planGuard(bundle) {
   const rootStat=fs.statSync(root,{bigint:true});
   return sha(JSON.stringify([String(rootStat.dev),String(rootStat.ino),values]));
 }
+// Identity of the reviewed compiler tree and the probe's Node executable. A full
+// probe verifies their bytes after this is taken, so any later write changes it.
+export function toolchainKey(tsRoot,executable) {
+  const values=[];
+  const visit=file=>{const st=fs.lstatSync(file,{bigint:true});
+    values.push([file,...['dev','ino','mode','nlink','size','mtimeNs','ctimeNs'].map(key=>String(st[key]))]);
+    if(st.isDirectory())for(const name of fs.readdirSync(file).sort())visit(path.join(file,name));};
+  visit(tsRoot);visit(fs.realpathSync(executable));
+  return sha(JSON.stringify(values));
+}

package/src/declared-plan.mjs

@@ -5,8 +5,13 @@ import path from 'node:path';
 import {createHash} from 'node:crypto';
 import {permittedRoots,resolveDeclaredInstalled} from './installed-inputs.mjs';
 import {qualifyTypeScript} from './typescript-qualification.mjs';
+import {directBuildInfo} from './direct-typescript.mjs';
+import {qualifyTests,testWorkspacePatterns,testsQualification} from './test-direct.mjs';
+import {qualifyNodeScript,scriptQualification} from './node-script.mjs';
+import {isSandboxed,qualifySandbox,sandboxInstalledExclusions} from './sandbox.mjs';
 import {yarnWorkspaceTypecheckInputs} from './yarn-workspace-inputs.mjs';
 import {pnpmTypecheckInputs} from './pnpm-inputs.mjs';
+import {checkRun} from './typescript-invocation.mjs';
 import {observedRelative,withinPath,realObservedPath} from './path-identity.mjs';
 import {timing} from './decision-profile.mjs';
 
@@ -16,6 +21,8 @@ const safePattern=value=>{
   const raw=value.startsWith('!')?value.slice(1):value;
   if(!raw||path.isAbsolute(raw)||raw.split(/[\\/]/).includes('..'))
     throw Error(`unsafe repository-relative input pattern: ${value}`);
+  // The observer never watches .git directories; excluding one is fine.
+  if(raw===value&&raw.split(/[\\/]/).includes('.git'))throw Error(`input pattern names a .git directory, which is not observed: ${value}`);
   return value;
 };
 
@@ -60,19 +67,32 @@ export function discoverDeclared(config) {
       catch(e){workspaceIssue=e.message;}
     }
     if(selected.qualification==='pnpm-tsc-v1'){
-      try{workspace=pnpmTypecheckInputs(root,selected.workspace||'.',
-        selected.script||selected.command.at(-1));}
+      try{workspace=pnpmTypecheckInputs(root,selected.workspace||'.',checkRun(selected));}
       catch(e){workspaceIssue=e.message;}
     }
     timing('plan.workspace_inputs',workspaceStarted,{available:workspace?1:0});
+    // An incremental direct check writes its build-info file during each run.
+    // It is compiler state, not an input, so the plan leaves it out. Read when
+    // the plan is built: a later change to it needs an observer restart, and
+    // until then the run reports the unexpected write and is not reusable.
+    let buildInfo=null;
+    if(selected.qualification==='npm-typescript-direct-v1')
+      try{buildInfo=directBuildInfo(root,checkRun(selected));}catch{}
+    const excluded=buildInfo?['!'+buildInfo]:[];
+    // A sandboxed check leaves out the .venv's links that lead out of the
+    // checkout; its qualification names them.
+    const sandboxed=isSandboxed(selected.qualification);
+    if(sandboxed)excluded.push(...sandboxInstalledExclusions(root));
     const installedStarted=performance.now();
     const installed=resolveDeclaredInstalled(root,
-      [...(selected.installedInputs||[]),...(workspace?.installed||[])],allowedRoots);
+      [...(selected.installedInputs||[]),...(workspace?.installed||[]),...excluded],allowedRoots);
     timing('plan.installed_resolution',installedStarted,{mappings:installed.mappings.length});
-    const automatic=qualifyTypeScript(root,selected,
-      {workspace,issue:workspaceIssue});
+    const automatic=selected.qualification===testsQualification?qualifyTests(root,selected):
+      selected.qualification===scriptQualification?qualifyNodeScript(root,selected):
+      sandboxed?qualifySandbox(root,selected):
+      qualifyTypeScript(root,selected,{workspace,issue:workspaceIssue});
     const sourcePatterns=[...new Set([...selected.inputs,...(workspace?.source||[]),
-      ...(workspace?.generated||[])])].sort();
+      ...(workspace?.generated||[]),...excluded])].sort();
     const additivePatterns=[...new Set([...(selected.generatedInputs||[]),
       ...installed.internalPatterns])].sort();
     const unresolved=[...installed.unresolved,...(automatic?.issues||[]),
@@ -80,6 +100,15 @@ export function discoverDeclared(config) {
       ...(workspaceIssue?[workspaceIssue]:[])];
     for(const item of workspace?.configurationInputs||[])configurationInputs.add(item);
     for(const item of workspace?.workspacePatterns||[])workspacePatterns.add(item);
+    // A workspace test check, and a general check in a workspace, is qualified
+    // against the current package list: a package manifest appearing or pnpm's
+    // package list changing re-plans.
+    if(selected.qualification===testsQualification&&selected.workspace||selected.qualification===scriptQualification||
+      sandboxed&&typeof selected.script==='string')try{
+      for(const item of testWorkspacePatterns(root,JSON.parse(fs.readFileSync(path.join(root,'package.json'),'utf8'))))
+        workspacePatterns.add(item);
+      if(fs.existsSync(path.join(root,'pnpm-workspace.yaml')))configurationInputs.add('pnpm-workspace.yaml');
+    }catch{}
     for(const item of workspace?.closure||[])workspaceManifests.add(item.manifest);
     if(!automatic)for(const category of ['source','generated','installedDependencies',
       'environment','toolchain','runtime'])if(!selected.coverage?.[category])
@@ -113,6 +142,9 @@ export function discoverDeclared(config) {
       installedMappings:installed.mappings,effectiveEnvironmentGlobs:{},
       probes:selected.probes||[],environment:selected.environment||{},
       qualification:selected.qualification||null,
+      ...(buildInfo?{buildInfo}:{}),
+      // A sandboxed run's reads are not recorded: git-ignored files are inputs too.
+      ...(sandboxed?{ignoredInputs:true}:{}),
       executionProvenance:'declared-command',
       unresolved:[...new Set(unresolved)].sort()};
     plan.resolutionCandidates=workspace?.resolutionCandidates||[];

package/src/direct-run-certificate.mjs

@@ -0,0 +1,254 @@
+// A caller validates discovery, never an execution outcome. No persistent cache.
+// The direct compiler run records the answers it received (run-recorder.cjs);
+// those answers, not a separate probe, show it consumed the certified inputs.
+import fs from 'node:fs';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+import {inflateSync} from 'node:zlib';
+import {fileURLToPath} from 'node:url';
+import {timing} from './decision-profile.mjs';
+import {directCompiler,directContextHash,directEnvironmentIssue,directProbeOutput,directProbeValue,viteCacheQuestion} from './direct-typescript.mjs';
+import {withinPath} from './path-identity.mjs';
+const hash=value=>createHash('sha256').update(value).digest('hex');
+// Whether a direct run is recorded at all: on macOS and Linux, always, so its
+// run facts are known even when full probes check it.
+export function directRunRecordable(selected) {
+  return ['darwin','linux'].includes(process.platform)&&selected.qualification==='npm-typescript-direct-v1'&&
+    selected.probes?.length===1&&
+    selected.probes[0][1]===fileURLToPath(new URL('direct-typescript-probe.mjs',import.meta.url));
+}
+// Whether a recorded run may replace the probes (tests can force full probes).
+export function directRunCertificateAllowed(selected) {
+  return directRunRecordable(selected)&&
+    !(process.env.VSTATE_TEST_FAULTS==='1'&&process.env.VSTATE_TEST_FULL_RUN_PROBES==='1');
+}
+// The incremental build-info file the plan leaves out of the inputs, if any.
+export const buildInfoPath=plan=>typeof plan?.buildInfo==='string'?path.join(plan.root,plan.buildInfo):null;
+// The start snapshot's discovery certificate, checked without a child process.
+// Returns what a recorded run is compared against, or null for full probes.
+export function directRunCertificate(plan,selected,snapshot,root) {
+  const started=performance.now(),c=snapshot?.discoveryCertificate;
+  const fallback=reason=>{timing('cli.run_certificate',started,{outcome:'fallback',reason});return null;};
+  if(!directRunCertificateAllowed(selected))return fallback('unsupported');
+  if(!snapshot?.observationHealthy||!c||c.schema!==2||c.planId!==plan.id||
+    c.planId!==snapshot.planId||c.cwd!==plan.cwd||
+    c.probeDefinition!==hash(JSON.stringify(selected.probes))||
+    ![c.output,c.context,c.stderrHash].every(s=>typeof s==='string'&&/^[a-f0-9]{64}$/.test(s))||
+    typeof c.queryData!=='string'||c.queryData.length>1024*1024)
+    return fallback('certificate_unavailable');
+  // The compile runs in this process's environment; the daemon's is never substituted.
+  if(directEnvironmentIssue())return fallback('environment_unsupported');
+  try{
+    const argv=selected.probes[0];
+    const value=directProbeValue(argv,c.output,c.stderrHash);
+    if(value!==snapshot.probeHash)return fallback('probe_identity_changed');
+    // Bytes were verified by the daemon's full probe; its toolchain identity
+    // check at the start and end snapshots covers later changes.
+    const compiler=directCompiler(root,{verify:false});
+    if(selected.command[1]!==compiler.entry)return fallback('command_unsupported');
+    const queries=JSON.parse(inflateSync(Buffer.from(c.queryData,'base64'),{maxOutputLength:8*1024*1024}));
+    if(!Array.isArray(queries)||!queries.length)return fallback('certificate_invalid');
+    timing('cli.run_certificate',started,{outcome:'available',queries:queries.length});
+    return {value,queries,context:c.context,compiler,buildInfo:buildInfoPath(plan)};
+  }catch{return fallback('certificate_invalid');}
+}
+// The last probe's questions, sent for a run checked by full probes. They only
+// show which of the run's lookups are run facts; the full probes, not these,
+// establish the result.
+export function probeQuestions(plan,selected,snapshot,root) {
+  const q=snapshot?.probeQuestions;
+  if(!directRunRecordable(selected)||typeof q?.queryData!=='string'||
+    q.queryData.length>1024*1024||typeof q.context!=='string')return null;
+  try{const queries=JSON.parse(inflateSync(Buffer.from(q.queryData,'base64'),{maxOutputLength:8*1024*1024}));
+    if(!Array.isArray(queries)||!queries.length)return null;
+    return {queries,context:q.context,compiler:directCompiler(root,{verify:false}),buildInfo:buildInfoPath(plan)};}
+  catch{return null;}
+}
+// Without a start certificate, the daemon may offer to build one from this run's
+// recording at the end checkpoint. Returns its token, or null for full probes.
+export function directRunRecording(plan,selected,snapshot,root) {
+  const token=snapshot?.recordedCertificate;
+  if(!directRunCertificateAllowed(selected)||!snapshot.observationHealthy||
+    typeof token!=='string'||!/^[0-9a-f-]{36}$/.test(token)||snapshot.planId!==plan.id||directEnvironmentIssue())
+    return null;
+  try{if(selected.command[1]!==directCompiler(root,{verify:false}).entry)return null;}catch{return null;}
+  return token;
+}
+// Answers derived from a recorded raw listing, exactly as queryAnswer computes them.
+function derived(kind,entries,options) {
+  if(entries===null)return null;
+  if(kind==='entries')return entries.map(([name,type])=>[name,type==='d'?'d':type==='l'?'l':'f']).sort();
+  const resolved=entries.flatMap(([name,type,target])=>type!=='l'?[[name,type]]:target?[[name,target]]:[]);
+  if(kind==='directories'){
+    if(entries.some(([,type,target])=>type==='l'&&!target))return null;
+    return resolved.filter(([,type])=>type==='d').map(([name])=>name).sort();
+  }
+  const suffixes=options?.extensions?.map(value=>value.toLowerCase());
+  return resolved.flatMap(([name,type])=>type==='d'?[[name,'d']]:
+    type==='f'&&(!suffixes||suffixes.some(value=>name.toLowerCase().endsWith(value)))?[[name,'f']]:[]).sort();
+}
+// What one certificate fact says about a recorded stat answer: true, false, or
+// null when it says nothing. A parent listing that does not name the path only
+// rules some answers out, so it must agree but does not count as cover.
+function statAgrees([kind,file,answer,options],target,result) {
+  if(file===target){
+    // queryAnswer reports a missing path as null, not false.
+    if(answer===null)return ['fileExists','directoryExists','readFile'].includes(kind)?result===null:null;
+    if(kind==='fileExists')return result!==null&&(result==='f')===answer;
+    if(kind==='directoryExists')return result!==null&&(result==='d')===answer;
+    if(kind==='readFile')return result==='f';
+    return null;
+  }
+  if(file!==path.dirname(target)||!Array.isArray(answer))return null;
+  const name=path.basename(target);
+  if(kind==='directories')return answer.includes(name)?result==='d':result==='d'?false:undefined;
+  if(kind==='entries'){const entry=answer.find(row=>row[0]===name);
+    return !entry?result===null:entry[1]==='l'?null:entry[1]===result;}
+  if(kind==='listing'){const entry=answer.find(row=>row[0]===name);
+    if(entry)return entry[1]===result;
+    const suffixes=options?.extensions?.map(value=>value.toLowerCase());
+    const listed=!suffixes||suffixes.some(value=>name.toLowerCase().endsWith(value));
+    return result==='d'||listed&&result==='f'?false:undefined;}
+  return null;
+}
+const withinCompiler=compiler=>file=>withinPath(file,compiler.tsRoot)||
+  file!==compiler.entry&&file.toLowerCase()===compiler.entry.toLowerCase();
+// The certificate question that asks again what a run's stat, realpath or
+// package.json read answered, in queryAnswer's terms; null when it cannot be asked again.
+export function runFact(kind,file,answer) {
+  if(kind==='stat')return answer===null||answer==='f'?['fileExists',file,answer&&true]:
+    answer==='d'?['directoryExists',file,true]:null;
+  if(kind==='realpath')return answer===null||typeof answer==='string'?['realpath',file,answer]:null;
+  // Declaration checks read the package.json of each dependency they resolve.
+  // Its content hash is asked again like any other run fact; other reads are not.
+  if(kind==='read'&&path.basename(file)==='package.json')
+    return answer===null||typeof answer==='string'?['readFile',file,answer]:null;
+  return null;
+}
+// Null when every answer the run received agrees with the certified state,
+// otherwise why not. The compiler is deterministic given its context and its
+// answers, so a run whose answers all agree computed the certified result.
+// Each answer needs at least one certificate fact about it. Paths inside the
+// compiler tree are covered by the daemon's toolchain identity instead. tsc
+// also stats a case-swapped copy of its own path to detect case sensitivity;
+// only that one stat is exempt.
+// With a `facts` array, a stat or realpath the probe never asked about is
+// added to it instead (declaration diagnostics resolve module paths that
+// building the program does not), as is a read of a package.json. The receipt
+// keeps those run facts, and status asks them again before every CURRENT
+// answer. Any other uncovered read, and any directory listing, is an issue.
+// The record's facts without the build-info file an incremental run reads and
+// writes, or {issue} when the run wrote anything else. That file is compiler
+// state, not an input. A directory tsc created for it was missing when tsc
+// checked it, so that check goes too; every other check stays.
+export function withoutBuildInfo(facts,buildInfo) {
+  const created=new Set(facts.filter(([kind])=>kind==='mkdir').map(([,file])=>file));
+  for(const [kind,file] of facts){
+    if(kind==='write'&&file!==buildInfo)return {issue:`the compiler wrote ${file}`};
+    if(kind==='mkdir'&&!buildInfo?.startsWith(file+path.sep))return {issue:`the compiler created ${file}`};
+  }
+  return {facts:facts.filter(([kind,file])=>kind!=='write'&&kind!=='mkdir'&&file!==buildInfo&&
+    !(kind==='stat'&&created.has(file)))};
+}
+export function runRecordIssue(record,certificate,runFacts=null) {
+  if(record?.schema!==1||!Array.isArray(record.facts))return 'record unavailable';
+  if(record.unsupported)return `unsupported ${record.unsupported}`;
+  if(record.conflict)return `answer changed during the run: ${record.conflict}`;
+  const {compiler,queries}=certificate,kept=withoutBuildInfo(record.facts,certificate.buildInfo||null);
+  if(kept.issue)return kept.issue;
+  if(record.main!==compiler.entry||!Array.isArray(record.node)||
+    directContextHash(compiler,record.node)!==certificate.context)return 'execution context changed';
+  const vite=viteCacheQuestion(compiler.root,kept.facts);
+  if(vite)return `the compiler asked about ${vite}, which Vitest rewrites and REDUE does not observe`;
+  const inCompiler=withinCompiler(compiler);
+  const facts=new Map();
+  for(const query of queries){if(!facts.has(query[1]))facts.set(query[1],[]);facts.get(query[1]).push(query);}
+  for(const [kind,file,answer] of kept.facts){
+    if(inCompiler(file))continue;
+    const known=facts.get(file)||[];
+    let checks=[];
+    if(kind==='read')checks=known.filter(q=>q[0]==='readFile')
+      .map(q=>JSON.stringify(q[2])===JSON.stringify(answer));
+    else if(kind==='realpath')checks=known.filter(q=>q[0]==='realpath')
+      .map(q=>q[2]===answer);
+    else if(kind==='readdir')checks=known.filter(q=>['listing','directories','entries'].includes(q[0]))
+      .map(q=>JSON.stringify(derived(q[0],answer,q[3]))===JSON.stringify(q[2]));
+    else if(kind==='stat')checks=[...known,...(facts.get(path.dirname(file))||[])]
+      .map(q=>statAgrees(q,file,answer)).filter(value=>value!==null);
+    else return `unknown answer ${kind}`;
+    if(!checks.some(value=>value!==undefined)){
+      const fact=runFacts&&runFact(kind,file,answer);
+      if(fact){runFacts.push(fact);continue;}
+      return `${kind} ${file} is not in the discovery certificate`;
+    }
+    if(checks.includes(false))return `${kind} ${file} differs from the discovery certificate`;
+    // Covered only by a listing of its directory: a later probe may keep the
+    // same program while that listing changes, so the run's own lookup stays
+    // a run fact.
+    if(kind==='stat'&&runFacts&&!known.length){const fact=runFact(kind,file,answer);if(fact)runFacts.push(fact);}
+  }
+  return null;
+}
+// Compares the record run-recorder.cjs wrote to fd 3. Run facts go to `facts`.
+export function validateRunRecord(text,certificate,facts=[]) {
+  const started=performance.now();
+  let record=null;
+  try{record=JSON.parse(text);}catch{}
+  let issue;
+  try{issue=runRecordIssue(record,certificate,facts);}catch{issue='record unreadable';}
+  timing('cli.run_recording',started,{outcome:issue?'rejected':'validated',
+    facts:record?.facts?.length||0,runFacts:facts.length,...(issue?{reason:issue}:{})});
+  return issue;
+}
+// A certificate for the current inputs, built from a recorded run and the
+// certificate of the last full probe, or {issue}. The run must read the same
+// files, with the same configuration, and every answer it received must be
+// covered by the old questions or be a run fact; only file contents may differ.
+// Run facts stay out of this certificate: the receipt keeps them, and status
+// asks them again for every answer. The program
+// layout is then the same, so the output is rebuilt as the probe computes it.
+// Limit: a file whose role changes (a package.json newly imported as a module)
+// keeps its old role, so a later full probe can report the check STALE.
+export function recordedCertificate(text,cache,compiler,buildInfo=null) {
+  let record=null;
+  try{record=JSON.parse(text);}catch{}
+  if(record?.schema!==1||!Array.isArray(record.facts))return {issue:'record unavailable'};
+  if(!cache?.layout||!cache.queries?.length)return {issue:'no previous layout'};
+  const kept=withoutBuildInfo(record.facts,buildInfo);
+  if(kept.issue)return {issue:kept.issue};
+  const inCompiler=withinCompiler(compiler),reads=new Map();
+  const before=new Map(cache.queries.filter(q=>q[0]==='readFile'&&!inCompiler(q[1])).map(q=>[q[1],q[2]]));
+  for(const [kind,file,answer] of kept.facts)if(kind==='read'&&!inCompiler(file)){
+    if(answer!==null&&typeof answer!=='string')return {issue:`read ${file} failed`};
+    // A package.json only declaration checks read is a run fact, not a program read.
+    if(!before.has(file)&&path.basename(file)==='package.json')continue;
+    reads.set(file,answer);
+  }
+  if(reads.size!==before.size||[...before.keys()].some(file=>!reads.has(file)))
+    return {issue:'the run read different files'};
+  if(cache.layout.configs.some(([file])=>!reads.has(file)||reads.get(file)!==before.get(file)))
+    return {issue:'configuration changed'};
+  // Lib files are in the compiler tree: their bytes are covered by its identity,
+  // but which of them the program loads must not change.
+  const libs=list=>[...new Set(list.filter(file=>inCompiler(file)&&file.endsWith('.d.ts')))].sort();
+  if(!Array.isArray(record.compilerReads)||JSON.stringify(libs(record.compilerReads))!==
+    JSON.stringify(libs(cache.queries.filter(q=>q[0]==='readFile').map(q=>q[1]))))
+    return {issue:'the run loaded different lib files'};
+  const changed=new Set([...reads].filter(([file,answer])=>before.get(file)!==answer).map(([file])=>file));
+  const queries=cache.queries.map(q=>q[0]==='readFile'&&changed.has(q[1])?[q[0],q[1],reads.get(q[1]),...q.slice(3)]:q);
+  // Run facts belong to the receipt, which the caller builds; they do not
+  // change the program layout.
+  const issue=runRecordIssue({...record,facts:kept.facts},{compiler,queries,context:cache.context},[]);
+  if(issue)return {issue};
+  const files=[];
+  for(const [file,digest] of cache.layout.files){
+    if(!changed.has(file)){files.push([file,digest]);continue;}
+    let bytes;
+    try{bytes=fs.readFileSync(file);}catch{return {issue:`${file} unreadable`};}
+    // The same answer the compiler received (queryAnswer's readFile).
+    if(hash(JSON.stringify(bytes.toString('utf8')))!==reads.get(file))return {issue:`${file} changed after the run`};
+    files.push([file,hash(bytes)]);
+  }
+  const layout={...cache.layout,files};
+  return {queries,layout,output:directProbeOutput(layout),changed};
+}

package/src/direct-typescript-probe.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import {directProject,directInterpretation,directContextHash,directProbeOutput,viteCacheQuestion} from './direct-typescript.mjs';
+import {typeScriptInputFacts} from './typescript-input-facts.mjs';
+import {contextOnly,probeResult} from './probe-result.mjs';
+import {realObservedPath} from './path-identity.mjs';
+import {timing} from './decision-profile.mjs';
+import {runArgv,runFromArgv} from './typescript-invocation.mjs';
+try{
+  const [rootArg,...rest]=process.argv.slice(2).filter(value=>!value.startsWith('--redue-')),root=realObservedPath(rootArg);
+  const run=runFromArgv(rest),script=runArgv(run).join(' ');
+  // Verify all installed implementation bytes before loading compiler API/code,
+  // including the optimized context-only path. A version label is insufficient.
+  const implementationStarted=performance.now();
+  const compiler=directProject(root,run);
+  timing('direct_probe.implementation',implementationStarted,{version:compiler.version});
+  const context={interpretation:directInterpretation,compiler:compiler.digest,
+    entry:compiler.entry,node:[realObservedPath(process.execPath),process.version]};
+  const contextHash=directContextHash(compiler,context.node);
+  if(!contextOnly(contextHash)){
+    const {queries,configs,files,buildInfo}=typeScriptInputFacts(root,compiler.tsRoot,compiler.entry,compiler.config);
+    // Captured questions include every config and program file read.
+    if(viteCacheQuestion(root,queries||[...configs,...files].map(([file])=>['readFile',file])))
+      throw Object.assign(Error('typescript-vite-cache-consumed'),{code:'typescript-vite-cache-consumed'});
+    const layout={root,script,configs,files,context,...(buildInfo?{buildInfo}:{})};
+    probeResult(directProbeOutput(layout),contextHash,queries,layout);
+  }
+}catch(e){console.error(`VSTATE_REASON:${e.code&&/^[a-z-]+$/.test(e.code)?e.code:'typescript-contract-unavailable'}`);process.exitCode=2;}

package/src/direct-typescript.mjs

@@ -0,0 +1,205 @@
+// Versioned, explicit offline compiler recipe. No package manager is executed.
+import fs from 'node:fs';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+import {createRequire} from 'node:module';
+import {normalizedPath,racyUntil,realObservedPath,withinPath} from './path-identity.mjs';
+import {cachedTarball,lockedPackage,matchTarball,npmCacheDir,registryPackage,tarballFiles} from './npm-integrity.mjs';
+import {runConfig,tscRun} from './typescript-invocation.mjs';
+export const directInterpretation='npm-direct-typescript@1';
+export const directQualification='npm-typescript-direct-v1';
+const reviewed={
+  '5.5.2':{entry:'lib/tsc.js',digest:'953b4844b5f6edc745be844b6c367c227b59029b73c4182f508f90cc47e21816'},
+  '5.6.3':{entry:'lib/tsc.js',digest:'e674b5dc4dac50f6e91be30094aeea983a1f340231717e62b0b6199ae3049eb2'},
+  '5.9.3':{entry:'lib/_tsc.js',digest:'d1b32e75475710fdc85102b1365254d84ceb192d3639d962c53fe1355ce274ca'},
+  '6.0.2':{entry:'lib/_tsc.js',digest:'273e16620fe23362e085980d6dd822e1315d81ba792221c9b6008755fdafccdd'},
+  '6.0.3':{entry:'lib/_tsc.js',digest:'e0a6519f0d0a90125b7fd3bdbbcf700e167656beb3baf8aca8ed8bc037494537'},
+};
+export const reviewedTypeScriptVersions=Object.keys(reviewed);
+const fail=code=>{throw Object.assign(Error(code),{code});};
+const hash=bytes=>createHash('sha256').update(bytes).digest('hex');
+export const directEnvironment={variables:['NODE_ENV','NODE_OPTIONS','NODE_PATH','NODE_COMPILE_CACHE','VSCODE_INSPECTOR_OPTIONS'],
+  prefixes:['NODE_','DYLD_','LD_','TSGO_','TSC_','TS_ETW_'],executableIdentity:true};
+// NODE_OPTIONS flags that only size the V8 heap or pick TLS/DNS behavior; the
+// reviewed compilers open no network connections. Anything else, including any
+// code loader (--require, --import, --loader), is unclassified.
+const inertNodeOptions=[/^--max-(?:old|semi)-space-size=\d+$/,/^--use-(?:openssl|bundled|system)-ca$/,
+  /^--dns-result-order=(?:ipv4first|ipv6first|verbatim)$/];
+// One variable's effect on the direct compiler: null when it cannot change what
+// tsc reads or reports. Accepted values stay fingerprinted as NODE_ context.
+export function directVariableIssue(key,value){
+  const unsupported='direct-execution-environment-unsupported';
+  // The 5.5.2 API can require this unreviewed module during probe loading.
+  // Reject even empty/case aliases; do not mutate the caller's environment.
+  if(/^TS_ETW_MODULE_PATH$/i.test(key)||/^VSCODE_INSPECTOR_OPTIONS$/i.test(key)&&value)return unsupported;
+  if(/^NODE_/i.test(key)){
+    // Node 22.13.0 predates env-proxy initialization. This injected flag is
+    // inert there, but remains strictly fingerprinted as NODE_ context.
+    if(key==='NODE_USE_ENV_PROXY'&&value==='1'&&process.version==='v22.13.0'&&
+      !process.allowedNodeEnvironmentFlags.has('--use-env-proxy'))return null;
+    if(key==='NODE_ENV'&&['','production','test'].includes(value))return null;
+    // PEM data for TLS roots, not code.
+    if(key==='NODE_EXTRA_CA_CERTS')return null;
+    // Only bare CommonJS requires consult it; the reviewed compilers make one,
+    // source-map-support, and only under NODE_ENV=development.
+    if(key==='NODE_PATH')return null;
+    // No quotes or escapes, so Node splits the value exactly as this does.
+    if(key==='NODE_OPTIONS'&&/^[A-Za-z0-9=._ -]*$/.test(value)&&
+      value.split(' ').filter(Boolean).every(flag=>inertNodeOptions.some(re=>re.test(flag))))return null;
+    if(value!=='')return unsupported;
+  }
+  if(/^(DYLD_|LD_|TSGO_|TSC_)/i.test(key)&&value!=='')return unsupported;
+  return null;
+}
+export function directEnvironmentIssue(env=process.env){
+  if(![22,24].includes(Number(process.versions.node.split('.')[0])))return 'direct-node-version-unsupported';
+  for(const [key,value] of Object.entries(env)){const issue=directVariableIssue(key,value);if(issue)return issue;}
+  return null;
+}
+export function directCompiler(root,{verify=true}={}){
+  root=realObservedPath(root);
+  const manifest=createRequire(path.join(root,'package.json')).resolve('typescript/package.json');
+  const tsRoot=path.dirname(realObservedPath(manifest));
+  if(!withinPath(tsRoot,root)||tsRoot!==realObservedPath(path.join(root,'node_modules/typescript')))
+    fail('direct-typescript-layout-unsupported');
+  const version=JSON.parse(fs.readFileSync(manifest)).version;
+  if(!reviewed[version])return lockedCompiler(root,tsRoot,version,verify);
+  const spec=reviewed[version];
+  if(verify){
+    const files=[];
+    const walk=(dir,relative='')=>{
+      for(const entry of fs.readdirSync(dir,{withFileTypes:true})){
+        const name=relative?relative+'/'+entry.name:entry.name,full=path.join(dir,entry.name);
+        if(entry.isDirectory())walk(full,name);
+        else if(entry.isFile())files.push([name,full]);
+        else fail('direct-typescript-implementation-unreviewed');
+      }
+    };walk(tsRoot);
+    const digest=createHash('sha256');
+    for(const [name,file] of files.sort(([a],[b])=>a<b?-1:a>b?1:0))digest.update(name+'\0'+hash(fs.readFileSync(file))+'\0');
+    if(digest.digest('hex')!==spec.digest)fail('direct-typescript-implementation-unreviewed');
+  }
+  return {root,tsRoot,version,entry:path.join(tsRoot,spec.entry),digest:spec.digest};
+}
+// A TypeScript 5.x or 6.0 the lockfile records: the installed package must be
+// the registry's `typescript` at that version, holding exactly the files of
+// the tarball npm cached under the lockfile's integrity. Its identity is that
+// integrity. The entry is lib/_tsc.js where the package has one (5.7 and
+// later), as for the reviewed versions, else lib/tsc.js. A verified tree is
+// remembered per process while its files keep their identity.
+const verifiedTrees=new Map();
+function treeIdentity(tsRoot){
+  const parts=[],now=Date.now();
+  const walk=folder=>{for(const entry of fs.readdirSync(folder,{withFileTypes:true})){
+    const full=path.join(folder,entry.name),st=fs.lstatSync(full,{bigint:true});
+    if(racyUntil(st)>now)return null;
+    parts.push([full,st.dev,st.ino,st.size,st.mtimeNs,st.ctimeNs].join(':'));
+    if(entry.isDirectory()&&walk(full)===null)return null;
+  }};
+  try{if(walk(tsRoot)===null)return null;}catch{return null;}
+  return hash(parts.sort().join('\n'));
+}
+function lockedCompiler(root,tsRoot,version,verify){
+  if(!/^(?:5\.\d+|6\.0)\.\d+$/.test(version))fail('direct-typescript-version-unsupported');
+  let locked;try{locked=lockedPackage(root,'typescript');}
+  catch(e){fail(['npm-lockfile-unreadable','npm-shrinkwrap-unsupported'].includes(e.code)?e.code:'direct-typescript-lockfile-integrity-missing');}
+  if(locked.version!==version)fail('direct-typescript-lockfile-version-differs');
+  if(!registryPackage(locked,'typescript',version)||
+    JSON.parse(fs.readFileSync(path.join(tsRoot,'package.json'),'utf8')).name!=='typescript')
+    fail('direct-typescript-lockfile-source-unsupported');
+  if(verify){
+    const tree=treeIdentity(tsRoot);
+    if(!tree||verifiedTrees.get(locked.integrity)!==tree){
+      matchTarball(tsRoot,tarballFiles(cachedTarball(npmCacheDir(root),locked.integrity)));
+      if(tree)verifiedTrees.set(locked.integrity,tree);
+    }
+  }
+  const entry=fs.existsSync(path.join(tsRoot,'lib','_tsc.js'))?'lib/_tsc.js':'lib/tsc.js';
+  return {root,tsRoot,version,entry:path.join(tsRoot,entry),digest:hash('npm-integrity\0'+locked.integrity)};
+}
+// The direct probe's output: root, script, configuration and program files with
+// their byte digests, and the execution context. A recorded run rebuilds it from
+// the same layout (direct-run-certificate.mjs).
+export function directProbeOutput({root,script,configs,files,context,buildInfo}){
+  const named=list=>list.map(([file,digest])=>[hash(file),digest]);
+  return hash(JSON.stringify({root,script,configs:named(configs),files:named(files),...context,
+    ...(buildInfo?{buildInfo}:{})}));
+}
+// The build-info file an incremental root config makes tsc read and write,
+// as {file} relative to the root, {} when not incremental, or {issue}. The
+// probe and the plan both use this rule. It must be inside the checkout, end
+// in .tsbuildinfo (the only write the run recorder allows) and contain no glob
+// characters (the plan excludes it with a pattern). An option that makes the
+// result depend on the build-info history is refused.
+export function buildInfoFor(ts,options,root) {
+  if(!options?.incremental)return {};
+  if(options.assumeChangesOnlyAffectDirectDependencies)return {issue:'typescript-incremental-unsound'};
+  const file=ts.getTsBuildInfoEmitOutputFilePath?.(options);
+  if(!file||!withinPath(path.resolve(file),root))return {issue:'typescript-buildinfo-outside-repository'};
+  const relative=path.relative(root,path.resolve(file)).split(path.sep).join('/');
+  if(!relative.endsWith('.tsbuildinfo')||/[*?[\]{}()!+@,]/.test(relative))return {issue:'typescript-buildinfo-name-unsupported'};
+  return {file:relative};
+}
+// The config a run's arguments name, relative to the root, or null.
+export const directConfig=(root,args)=>runConfig(root,args);
+// The plan's build-info file, or null. The compiler is loaded only when the
+// run's config sets incremental or extends another config.
+export function directBuildInfo(root,run) {
+  const name=directConfig(root,run.args);if(!name)return null;
+  const config=path.join(root,name);
+  let raw;try{raw=fs.readFileSync(config,'utf8');}catch{return null;}
+  if(!/"(?:incremental|extends)"\s*:/.test(raw))return null;
+  const compiler=directProject(root,run,{verify:false}),ts=createRequire(import.meta.url)(compiler.tsRoot);
+  const parsed=ts.getParsedCommandLineOfConfigFile(config,{},{...ts.sys,onUnRecoverableConfigFileDiagnostic(){}});
+  return parsed?.options?.composite?null:buildInfoFor(ts,parsed?.options,root).file??null;
+}
+// The probe value the daemon stores for one direct probe's checkpoint output.
+export function directProbeValue(argv,output,stderrHash){
+  return hash(JSON.stringify([[argv,0,hash(output),stderrHash]]));
+}
+// The execution context a direct probe certifies and a recorded run must match.
+export function directContextHash(compiler,node){
+  return hash(JSON.stringify({interpretation:directInterpretation,compiler:compiler.digest,
+    entry:compiler.entry,node}));
+}
+// Vitest writes its results under node_modules/.vite/vitest at every run. The
+// recipe does not observe them. A compiler that asks about anything under
+// node_modules/.vite, is told a path there (realpath), or lists node_modules,
+// could see them, so its result is UNVERIFIED.
+export const directInstalledInputs=Object.freeze(['node_modules/**','!node_modules/.vite/vitest/**']);
+const listings=new Set(['readdir','listing','directories','entries','readDirectory']);
+// The first path of [kind, file, answer] questions that does, or null. Kinds
+// are a recorded run's (readdir) or a probe's. Compared without case: a
+// case-insensitive mount reaches .vite under any spelling.
+export function viteCacheQuestion(root,questions){
+  const fold=value=>normalizedPath(value).toLowerCase();
+  const modules=fold(path.join(root,'node_modules')),cache=path.join(modules,'.vite');
+  for(const [kind,file,answer] of questions){
+    if(typeof file!=='string')continue;
+    const at=fold(file);
+    if(withinPath(at,cache)||at===modules&&listings.has(kind))return file;
+    if(kind==='realpath'&&typeof answer==='string'&&withinPath(fold(answer),cache))return answer;
+  }
+  return null;
+}
+// The compiler for one check run {script, part, args}: script null for a
+// check init proposed without one. The run must pass --noEmit and name a
+// config inside the root.
+export function directProject(root,run,{verify=true}={}){
+  const pkg=JSON.parse(fs.readFileSync(path.join(root,'package.json')));
+  if(pkg.workspaces||pkg.packageManager&&!/^npm@/.test(pkg.packageManager)||
+    !['package-lock.json','npm-shrinkwrap.json'].some(file=>fs.existsSync(path.join(root,file)))||
+    ['yarn.lock','pnpm-lock.yaml','bun.lock','bun.lockb'].some(file=>fs.existsSync(path.join(root,file))))
+    fail('direct-npm-project-unsupported');
+  const own=tscRun(pkg.scripts,run).run;
+  if(!own?.noEmit)fail('typecheck-script-changed');
+  const config=directConfig(root,run.args);
+  if(!config||!fs.existsSync(path.join(root,config)))fail('typescript-config-unavailable');
+  const issue=directEnvironmentIssue();if(issue)fail(issue);
+  return {...directCompiler(root,{verify}),config};
+}
+// Provenance only: retain a digest, never proxy URLs/credentials or a raw dump.
+// No npm process runs in this recipe; these keys are not compiler applicability.
+export function observedNpmContext(env=process.env){
+  return hash(JSON.stringify(Object.entries(env).filter(([key])=>/^npm_/i.test(key)||/^(?:https?_proxy|all_proxy|no_proxy)$/i.test(key)).sort(([a],[b])=>a<b?-1:a>b?1:0)));
+}

package/src/glob.mjs

@@ -7,3 +7,11 @@ export default {
   matcher(pattern,options){return picomatch(pattern,options);},
   isMatch(file,patterns,options){return picomatch(patterns,options)(file);}
 };
+// A matcher for a pattern list with `!` exclusions: a path matches when a
+// positive pattern does and no excluded one does. A plain list match would
+// take any `!` pattern as matching everything else.
+export function patternMatcher(patterns){
+  const positive=patterns.filter(p=>!p.startsWith('!')).map(p=>picomatch(p,{dot:true}));
+  const negative=patterns.filter(p=>p.startsWith('!')).map(p=>picomatch(p.slice(1),{dot:true}));
+  return file=>positive.some(fn=>fn(file))&&!negative.some(fn=>fn(file));
+}