@redue/cli 0.0.0-stage → 0.1.0-alpha.11

package/src/decision-profile.mjs

@@ -0,0 +1,32 @@
+// 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(),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
+    })+'\n');}
+  catch{/* Diagnostics must never change probe or verification behavior. */}
+}

package/src/decision-validation.mjs

@@ -0,0 +1,51 @@
+// Deterministic reuse keys for already-resolved plans. These are not receipts
+// or a second content cache: the existing InputIndex still reads current bytes
+// and membership. A changed key falls back to provider discovery.
+import fs from 'node:fs';
+import path from 'node:path';
+import {execFileSync} from 'node:child_process';
+import micromatch from './glob.mjs';
+import {sha} from './plan.mjs';
+
+export function inputKey(row) {
+  return sha(JSON.stringify([row.plan.id,row.files.size,row.sum.toString('hex')]));
+}
+export function planGuard(bundle) {
+  const root=bundle.root;
+  const paths=new Set(['package.json','package-lock.json','.npmrc','.yarnrc.yml',
+    'pnpm-workspace.yaml','.pnpmfile.cjs','.pnpmfile.mjs',
+    ...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')));
+      return Array.isArray(pkg.workspaces)?pkg.workspaces:pkg.workspaces?.packages||[];})();
+  if(patterns.length){
+    const files=execFileSync('git',['ls-files','--cached','--others','--exclude-standard',
+      '-z','--',':(glob)**/package.json'],{cwd:root,
+      env:{...process.env,GIT_OPTIONAL_LOCKS:'0'},timeout:5000,maxBuffer:32*1024*1024})
+      .toString().split('\0').filter(Boolean);
+    for(const file of files)if(micromatch.isMatch(path.posix.dirname(file),patterns,{dot:true}))
+      paths.add(file);
+  }
+  const values=[...paths].sort().map(rel=>{
+    const file=path.isAbsolute(rel)?rel:path.join(root,rel);
+    try{const st=fs.lstatSync(file,{bigint:true});
+      if(st.isSymbolicLink())return [rel,'link',fs.readlinkSync(file)];
+      if(st.isDirectory())return [rel,'directory',String(st.dev),String(st.ino)];
+      if(!st.isFile())throw Error('unobservable plan dependency');
+      return [rel,sha(fs.readFileSync(file))];
+    }catch(e){if(e.code==='ENOENT')return [rel,'missing'];throw e;}
+  });
+  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

@@ -0,0 +1,125 @@
+// A single-project plan. Declarations are explicit;
+// this provider does not infer complete coverage from a successful command.
+import fs from 'node:fs';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+import {permittedRoots,resolveDeclaredInstalled} from './installed-inputs.mjs';
+import {qualifyTypeScript} from './typescript-qualification.mjs';
+import {yarnWorkspaceTypecheckInputs} from './yarn-workspace-inputs.mjs';
+import {pnpmTypecheckInputs} from './pnpm-inputs.mjs';
+import {observedRelative,withinPath,realObservedPath} from './path-identity.mjs';
+import {timing} from './decision-profile.mjs';
+
+const identity=value=>createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const safePattern=value=>{
+  if(typeof value!=='string'||!value)throw Error('input pattern must be nonempty');
+  const raw=value.startsWith('!')?value.slice(1):value;
+  if(!raw||path.isAbsolute(raw)||raw.split(/[\\/]/).includes('..'))
+    throw Error(`unsafe repository-relative input pattern: ${value}`);
+  return value;
+};
+
+export function discoverDeclared(config) {
+  const root=realObservedPath(config.root),plans={},configurationInputs=new Set(),
+    workspaceManifests=new Set(),workspacePatterns=new Set();
+  if(!Array.isArray(config.checks)||!config.checks.length)throw Error('selected checks required');
+  for(const selected of config.checks){
+    if(typeof selected.name!=='string'||!selected.name||plans[selected.name])
+      throw Error('check names must be unique nonempty strings');
+    if(!Array.isArray(selected.command)||!selected.command.length||
+      !selected.command.every(item=>typeof item==='string'&&item))
+      throw Error(`exact command required for ${selected.name}`);
+    const cwd=path.resolve(root,selected.cwd||'.');
+    if(!withinPath(cwd,root))throw Error('check cwd escapes checkout');
+    for(const key of ['inputs','generatedInputs','installedInputs']){
+      if(!Array.isArray(selected[key]||[]))throw Error(`${key} must be a path-pattern array`);
+      for(const value of selected[key]||[])safePattern(value);
+    }
+    if(!selected.inputs?.some(value=>!value.startsWith('!')))
+      throw Error(`positive source inputs required for ${selected.name}`);
+    for(const argv of selected.probes||[])if(!Array.isArray(argv)||!argv.length||
+      !argv.every(value=>typeof value==='string'&&value))
+      throw Error('state probes must be exact nonempty argv arrays');
+    if(!Array.isArray(selected.environment?.variables||[])||
+      !(selected.environment?.variables||[]).every(value=>typeof value==='string'&&value))
+      throw Error('environment variables must be a string array');
+    if(!Array.isArray(selected.environment?.prefixes||[])||
+      !(selected.environment?.prefixes||[]).every(value=>
+        typeof value==='string'&&/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)))
+      throw Error('environment prefixes must be simple nonempty names');
+    if(!Array.isArray(selected.environment?.pathExecutables||[])||
+      !(selected.environment?.pathExecutables||[]).every(value=>
+        typeof value==='string'&&/^[A-Za-z_][A-Za-z0-9_-]*$/.test(value)))
+      throw Error('PATH executables must be simple command names');
+    const allowedRoots=permittedRoots(root,selected.allowedExternalRoots||[]);
+    let workspace=null,workspaceIssue=null;
+    const workspaceStarted=performance.now();
+    if(selected.qualification==='yarn-workspace-tsc-v1'){
+      try{workspace=yarnWorkspaceTypecheckInputs(root,selected.workspace,
+        selected.command[4]);}
+      catch(e){workspaceIssue=e.message;}
+    }
+    if(selected.qualification==='pnpm-tsc-v1'){
+      try{workspace=pnpmTypecheckInputs(root,selected.workspace||'.',
+        selected.script||selected.command.at(-1));}
+      catch(e){workspaceIssue=e.message;}
+    }
+    timing('plan.workspace_inputs',workspaceStarted,{available:workspace?1:0});
+    const installedStarted=performance.now();
+    const installed=resolveDeclaredInstalled(root,
+      [...(selected.installedInputs||[]),...(workspace?.installed||[])],allowedRoots);
+    timing('plan.installed_resolution',installedStarted,{mappings:installed.mappings.length});
+    const automatic=qualifyTypeScript(root,selected,
+      {workspace,issue:workspaceIssue});
+    const sourcePatterns=[...new Set([...selected.inputs,...(workspace?.source||[]),
+      ...(workspace?.generated||[])])].sort();
+    const additivePatterns=[...new Set([...(selected.generatedInputs||[]),
+      ...installed.internalPatterns])].sort();
+    const unresolved=[...installed.unresolved,...(automatic?.issues||[]),
+      ...(workspace?.limitations||[]),
+      ...(workspaceIssue?[workspaceIssue]:[])];
+    for(const item of workspace?.configurationInputs||[])configurationInputs.add(item);
+    for(const item of workspace?.workspacePatterns||[])workspacePatterns.add(item);
+    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])
+      unresolved.push(selected.coverageReasons?.[category]||
+        `${category} coverage not reviewed for this command`);
+    if((selected.probes||[]).length&&!automatic&&!selected.coverage?.probeContinuity)
+      unresolved.push('probe state continuity during execution not established');
+    const installedPhysicalRoots=[...new Set(installed.physicalRoots
+      .filter(file=>withinPath(file,root)&&observedRelative(root,file)!=='')
+      .map(file=>observedRelative(root,file)))].sort();
+    const externalPatterns=installed.externalPatterns;
+    const plan={name:selected.name,provider:'declared-project@1',inputResolutionVersion:1,
+      root,cwd,selectedConfigHash:identity(selected),command:selected.command,
+      target:selected.name,taskCommand:null,taskGraph:[],
+      patterns:[...new Set([...sourcePatterns,...additivePatterns])].sort(),
+      sourcePatterns,additivePatterns,generated:[],
+      declaredGeneratedInputs:[...new Set([...(selected.generatedInputs||[]),
+        ...(workspace?.generated||[])])].sort(),
+      declaredInstalledInputs:[...new Set([...(selected.installedInputs||[]),
+        ...(workspace?.installed||[])])].sort(),
+      installation:workspace?.installation||null,
+      ...(workspace?.synchronizedInstalledRead?{synchronizedInstalledRead:true}:{}),
+      installedInstances:workspace?.installedInstances||[],
+      resolutionCandidates:[],resolutionFindings:workspace?.absences||[],
+      installedPhysicalRoots,externalPatterns,
+      externalObservationRoots:Object.keys(externalPatterns).sort(),
+      resolutionLinks:installed.links,
+      resolutionTriggers:[...new Set([...installed.triggers,
+        ...(workspace?.linkTriggers||[]),
+        ...(workspace?.resolutionCandidates||[]).map(row=>row.path)])],
+      installedMappings:installed.mappings,effectiveEnvironmentGlobs:{},
+      probes:selected.probes||[],environment:selected.environment||{},
+      qualification:selected.qualification||null,
+      executionProvenance:'declared-command',
+      unresolved:[...new Set(unresolved)].sort()};
+    plan.resolutionCandidates=workspace?.resolutionCandidates||[];
+    plan.id=identity(plan);plans[selected.name]=plan;
+  }
+  return {schema:1,provider:'declared-project@1',root,plans,discoveredAt:Date.now(),
+    workspaceCount:1,workspacePatterns:[...workspacePatterns],
+    configurationInputs:[...configurationInputs].sort(),
+    workspaceManifests:[...workspaceManifests].sort()};
+}

package/src/direct-run-certificate.mjs

@@ -0,0 +1,185 @@
+// 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} from './direct-typescript.mjs';
+import {withinPath} from './path-identity.mjs';
+const hash=value=>createHash('sha256').update(value).digest('hex');
+export function directRunCertificateAllowed(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))&&
+    !(process.env.VSTATE_TEST_FAULTS==='1'&&process.env.VSTATE_TEST_FULL_RUN_PROBES==='1');
+}
+// 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>512*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};
+  }catch{return fallback('certificate_invalid');}
+}
+// 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();
+// 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.
+export function runRecordIssue(record,certificate) {
+  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;
+  if(record.main!==compiler.entry||!Array.isArray(record.node)||
+    directContextHash(compiler,record.node)!==certificate.context)return 'execution context changed';
+  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 record.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))return `${kind} ${file} is not in the discovery certificate`;
+    if(checks.includes(false))return `${kind} ${file} differs from the discovery certificate`;
+  }
+  return null;
+}
+// Compares the record run-recorder.cjs wrote to fd 3.
+export function validateRunRecord(text,certificate) {
+  const started=performance.now();
+  let record=null;
+  try{record=JSON.parse(text);}catch{}
+  let issue;
+  try{issue=runRecordIssue(record,certificate);}catch{issue='record unreadable';}
+  timing('cli.run_recording',started,{outcome:issue?'rejected':'validated',
+    facts:record?.facts?.length||0,...(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; only file contents may differ. 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) {
+  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 inCompiler=withinCompiler(compiler),reads=new Map();
+  for(const [kind,file,answer] of record.facts)if(kind==='read'&&!inCompiler(file)){
+    if(answer!==null&&typeof answer!=='string')return {issue:`read ${file} failed`};
+    reads.set(file,answer);
+  }
+  const before=new Map(cache.queries.filter(q=>q[0]==='readFile'&&!inCompiler(q[1])).map(q=>[q[1],q[2]]));
+  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);
+  const issue=runRecordIssue(record,{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,22 @@
+#!/usr/bin/env node
+import {directProject,directInterpretation,directContextHash,directProbeOutput} 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';
+try{
+  const [rootArg,script]=process.argv.slice(2),root=realObservedPath(rootArg);
+  // 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,script);
+  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}=typeScriptInputFacts(root,compiler.tsRoot,compiler.entry);
+    const layout={root,script,configs,files,context};
+    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,109 @@
+// 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 {realObservedPath,withinPath} from './path-identity.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'},
+};
+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,spec=reviewed[version];
+  if(!spec)fail('direct-typescript-version-unsupported');
+  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 {tsRoot,version,entry:path.join(tsRoot,spec.entry),digest:spec.digest};
+}
+// 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}){
+  const named=list=>list.map(([file,digest])=>[hash(file),digest]);
+  return hash(JSON.stringify({root,script,configs:named(configs),files:named(files),...context}));
+}
+// 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}));
+}
+export function directProject(root,script,{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');
+  if(pkg.scripts?.[script]?.trim()!=='tsc --noEmit'||pkg.scripts?.['pre'+script]||pkg.scripts?.['post'+script])
+    fail('typecheck-script-changed');
+  const issue=directEnvironmentIssue();if(issue)fail(issue);
+  return directCompiler(root,{verify});
+}
+// 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/executable-lookup.mjs

@@ -0,0 +1,18 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+// Resolve the same project-local PATH that will be used for execution. Windows
+// command shims have no extension in package scripts but normally end in .cmd.
+export function findExecutable(name,{platform=process.platform,env=process.env,
+  cwd=process.cwd(),paths=path,access=fs.accessSync,realpath=fs.realpathSync}={}) {
+  if(!name||paths.basename(name)!==name)return null;
+  // An extensionless POSIX shell shim can coexist with npm.cmd on Windows.
+  // CreateProcess cannot run the shell shim, so prefer native PATHEXT files.
+  const suffixes=platform==='win32'&&!paths.extname(name)?
+    [...(env.PATHEXT||'.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean),'']:[''];
+  for(const folder of (env.PATH||'').split(paths.delimiter))for(const suffix of suffixes) {
+    const candidate=paths.join(folder||cwd,name+suffix);
+    try{access(candidate,fs.constants.X_OK);return realpath(candidate);}catch{}
+  }
+  return null;
+}

package/src/glob.mjs

@@ -0,0 +1,9 @@
+import picomatch from 'picomatch';
+
+// These are the exact delegates used by micromatch 4.0.8 matcher/isMatch,
+// with the same pinned picomatch 2.3.2. REDUE does not use brace expansion;
+// importing the smaller dependency avoids shipping its unused vulnerable parser.
+export default {
+  matcher(pattern,options){return picomatch(pattern,options);},
+  isMatch(file,patterns,options){return picomatch(patterns,options)(file);}
+};

package/src/history-worker.mjs

@@ -0,0 +1,26 @@
+// Native history is an optional acceleration. Keep its operations off the
+// control thread so a wedged native call cannot block status or shutdown.
+// Each helper serves one query; the observer starts it ahead of that query.
+import fs from 'node:fs';
+import {mark} from './decision-profile.mjs';
+mark('history.worker_loaded');
+import watcher from '@parcel/watcher';
+
+process.on('disconnect',()=>process.exit(0));
+process.once('message',async({root,previous,next,backend,faultFile})=>{
+  try {
+    let fault;
+    try {fault=faultFile&&fs.readFileSync(faultFile,'utf8').trim();}
+    catch(e){if(e.code!=='ENOENT')throw e;}
+    if(fault==='hang')Atomics.wait(new Int32Array(new SharedArrayBuffer(4)),0,0);
+    if(fault==='fail')throw Error('injected history failure');
+    mark('history.snapshot_start');
+    await watcher.writeSnapshot(root,next,{backend});
+    mark('history.snapshot_complete');
+    const changes=previous?await watcher.getEventsSince(root,previous,{backend}):[];
+    mark('history.events_complete',{events:changes.length});
+    process.send({ok:true,changes});
+  } catch(error) {
+    process.send({ok:false,error:error.message,code:error.code||error.name});
+  }
+});