tsc-ts 0.1.0 → 0.1.2

package/src/compiler/thread-entry.ts

@@ -257,7 +257,9 @@ function runParseThread(job: ParseThreadData, drivers: ThreadDrivers): void {
   const port = parentPort!;
   port.on('message', (message: unknown) => {
     const chunk = message as LoadMessage;
-    if (chunk.stop) port.close();
+    if (chunk.stop) {
+      port.close();
+    }
     // The main thread read the project, so this one can too; if not, the program's FileLoader
     // parses the files of the chunk (the main thread sees this thread fail).
     else if (thread === undefined) throw new Error('A parse thread could not read the project');

package/src/compiler/transformers/declarations.ts

@@ -161,6 +161,7 @@ import { ConstantKind } from './reference-resolver.js';
 import { DeclarationTracker } from './declarations-tracker.js';
 import { Transformer } from './transformer.js';
 import { declarationCount, getDeclarations, SymbolFlags } from '../symbol.js';
+import { IdentifierName } from '../identifier-name.js';
 
 export class DeclarationTransformer extends Transformer {
   readonly host: OutputPathsHost;
@@ -1934,7 +1935,7 @@ export class DeclarationTransformer extends Transformer {
         keyword === SyntaxKind.DefaultKeyword
       ) {
         // A parse tree node, so names it uses are resolved where it's written.
-        const identifier = new Identifier(text);
+        const identifier = new Identifier(new IdentifierName(text));
         identifier.parent = name.parent;
         return identifier;
       }

package/src/compiler/tsc-build.ts

@@ -62,12 +62,15 @@ import {
   exitStatusOf,
   rechecksOnThreads,
   reportEmitAndErrors,
+  saveRunRecord,
   Statistics,
   statisticsOf,
   SystemTimeStamps,
 } from './tsc-compile.js';
 import { sharesPublishedGraphs } from '@scriptc/threads';
-import { checkerThreads, parseThreads, shareWithCheckers, startParallelCheck } from './parallel-check.js';
+import { checkerThreads, shareWithCheckers, startParallelCheck } from './parallel-check.js';
+import { preParseConfig, reportRunConfig, type RunConfig } from './run-config.js';
+import { openRecord } from './run-record-read.js';
 import { emitThreads } from './parallel-emit.js';
 import { LoadKind, ParseSession, clearPreparedFiles, parallelParse, reportPreparedFiles } from './parallel-parse.js';
 import { assignSymbolIdsAtCreation } from './symbol.js';
@@ -182,6 +185,8 @@ class BuildTask {
   buildKind = BuildKind.None;
   filesToDelete: string[] = [];
   configTime = 0;
+  /** The project's run configuration (run-config.ts), one per project of the build. */
+  run: RunConfig | undefined = undefined;
 
   constructor(readonly config: string) {}
 }
@@ -726,6 +731,33 @@ export class Orchestrator {
     const host = new BuildCompilerHost(sys, this.fs, this.locale);
     const configOptions = config.options;
     const checkers = threads ? checkerThreads(configOptions.checkers, configOptions.singleThreaded) : 1;
+    // The projects of a build that builds several at once run beside each other, and each one's timings
+    // are the machine's, not its own: none keeps a record (run-records.ts). A watcher's builds measure a
+    // change, not the project: they keep none either, and read none.
+    const builders = this.command.buildOptions.builders ?? (configOptions.singleThreaded === true ? 1 : 4);
+    const learning = builders === 1 && !this.watching;
+    const opened = learning
+      ? openRecord({
+          configFile: configOptions.configFilePath ?? task.config,
+          rootNames: config.fileNames,
+          options: configOptions,
+        })
+      : undefined;
+    // One configuration per project: its parse threads, and the pins of its checker count and sharing.
+    const run = (task.run = preParseConfig(configOptions, checkers, process.env, opened?.record, learning));
+    if (opened !== undefined) {
+      run.recordDirectory = opened.directory;
+      run.recordKey = opened.key;
+      run.recordFile = opened.file;
+    }
+    if (builders > 1) {
+      run.records = false;
+      run.recordsReason = 'concurrent projects';
+    }
+    if (this.watching) {
+      run.records = false;
+      run.recordsReason = 'watch mode';
+    }
     if (threads && configOptions.singleThreaded !== true && parallelParse.spawn !== undefined) {
       // Threads parse and bind the program's files ahead of it (parallel-parse.ts), as for plain
       // compiles. Here also when the program is checked on this thread, with one checker or after a
@@ -735,7 +767,7 @@ export class Orchestrator {
       // and parse threads don't load them again.
       const libraryDirectory = getNormalizedAbsolutePath(sys.defaultLibraryPath, sys.currentDirectory);
       const session = new ParseSession(
-        parseThreads(checkers),
+        run.parseThreads,
         configOptions,
         sys.currentDirectory,
         task.config,
@@ -783,6 +815,15 @@ export class Orchestrator {
     times.bindTime = performance.now() - bindStart;
     const options = program.options;
     const count = mayUseThreads ? checkerThreads(options.checkers, options.singleThreaded, program) : 1;
+    // The run's configuration reports the count that checks: a checker thread run decides again once
+    // the plan is made (`startParallelCheck`, run-config.ts).
+    if (task.run !== undefined) task.run.checkers = count;
+    // A project rebuilt on its old build info checks the files a change affects, not the project: it
+    // keeps no sample, which records only keep full checks of (`run-records.ts`).
+    if (task.run !== undefined && oldSnapshot !== undefined && isIncremental(options)) {
+      task.run.records = false;
+      task.run.recordsReason = 'incremental recheck';
+    }
     if (count > 1 && oldSnapshot !== undefined) {
       if (isIncremental(options)) return this.recheckOnThreads(task, checked, times, oldSnapshot, count, then);
       // Build info of a project that is no longer incremental has no pending emit to give the threads,
@@ -794,10 +835,20 @@ export class Orchestrator {
     if (count > 1) {
       // Checker threads also emit the files they check; the incremental program records their
       // declaration signatures on this thread.
-      startParallelCheck(checked, count, (checkTime) => {
-        this.emitAndReport(task, checked, times, oldSnapshot, checkTime);
-        then();
-      });
+      startParallelCheck(
+        checked,
+        count,
+        (checkTime) => {
+          this.emitAndReport(task, checked, times, oldSnapshot, checkTime);
+          then();
+        },
+        true,
+        undefined,
+        true,
+        undefined,
+        undefined,
+        task.run,
+      );
       return true;
     }
     if (mayUseThreads && this.emitsOnThreads(checked, oldSnapshot))
@@ -899,6 +950,9 @@ export class Orchestrator {
       true,
       incrementalProgram.emitKindsOnCheckers(files),
       incrementalProgram.checksOnCheckers,
+      undefined,
+      undefined,
+      task.run,
     );
     return true;
   }
@@ -945,10 +999,14 @@ export class Orchestrator {
     task.exitStatus = exitStatusOf(result);
     if (parallelCheckTime !== undefined) times.checkTime = parallelCheckTime;
     const options = program.options;
+    // A project's sample is kept whether or not the build reports statistics, and the section reports
+    // where it went (`run-records.ts`).
+    const records = saveRunRecord(sys, incrementalProgram, task.run);
     if (options.diagnostics === true || options.extendedDiagnostics === true) {
       times.totalTime = sys.sinceStart();
       const statistics = statisticsOf(incrementalProgram);
       statistics.report(sys);
+      if (options.extendedDiagnostics === true && task.run !== undefined) reportRunConfig(sys, task.run, records);
       task.statistics = statistics;
     }
     const status = task.status;

package/src/compiler/tsc-cli.ts

@@ -33,8 +33,10 @@ import { Colors, defaultIsPretty, header, printBuildHelp, printHelp, printVersio
 import { generateTSConfig } from './init.js';
 import { isIncremental, type CompilerOptions } from './options.js';
 import { combinePaths, getDirectoryPath, normalizePath } from './path.js';
-import { checkerThreads, parseThreads } from './parallel-check.js';
+import { checkerThreads } from './parallel-check.js';
 import { ParseSession, parallelParse, reportPreparedFiles } from './parallel-parse.js';
+import { preParseConfig, type RunConfig } from './run-config.js';
+import { openRecord } from './run-record-read.js';
 import { showConfig, type ShowConfigInput } from './show-config.js';
 import { assignSymbolIdsAtCreation } from './symbol.js';
 import { sharesPublishedGraphs } from '@scriptc/threads';
@@ -163,6 +165,8 @@ export type CommandLineResult =
       readonly errorSummary: ErrorSummaryReporter;
       /** The build info of an incremental program, read while threads parsed its files; `undefined` if not read yet. */
       readonly buildInfo?: EarlyBuildInfo;
+      /** How the run is configured: parse threads, checker count and sharing (run-config.ts). */
+      readonly config: RunConfig;
     }
   /** Threads are preparing the program's files; `run` calls back with the result once they are done. */
   | { readonly kind: 'deferred'; readonly run: (done: (result: CommandLineResult) => void) => void }
@@ -363,6 +367,31 @@ function executeCompile(sys: System, commandLine: ParsedCommandLine): CommandLin
   const configStart = performance.now();
   mark('config start');
   const errors: Diagnostic[] = [];
+  // The run's configuration, made once the config's options are known: its parse threads are needed
+  // before the first file is parsed.
+  let run: RunConfig | undefined = undefined;
+  const runConfigOf = (projectOptions: CompilerOptions): RunConfig => {
+    if (run === undefined) {
+      const opened = openRecord({
+        configFile: projectOptions.configFilePath ?? (configFileName === '' ? undefined : configFileName),
+        rootNames: fileNames,
+        options: projectOptions,
+      });
+      const made = preParseConfig(
+        projectOptions,
+        checkerThreads(projectOptions.checkers, projectOptions.singleThreaded),
+        process.env,
+        opened?.record,
+      );
+      if (opened !== undefined) {
+        made.recordDirectory = opened.directory;
+        made.recordKey = opened.key;
+        made.recordFile = opened.file;
+      }
+      run = made;
+    }
+    return run;
+  };
   // Where threads parse and bind the program's files ahead of it (parallel-parse.ts), they start with
   // the libraries and the root files found so far while the config's `include` patterns are matched.
   let session: ParseSession | undefined = undefined;
@@ -370,7 +399,7 @@ function executeCompile(sys: System, commandLine: ParsedCommandLine): CommandLin
     if (projectOptions.watch === true || options.showConfig === true || !parsesAhead(projectOptions)) return undefined;
     assignSymbolIdsAtCreation();
     const started = new ParseSession(
-      parseThreads(checkerThreads(projectOptions.checkers, projectOptions.singleThreaded)),
+      runConfigOf(projectOptions).parseThreads,
       projectOptions,
       sys.currentDirectory,
       configFileName,
@@ -424,20 +453,20 @@ function executeCompile(sys: System, commandLine: ParsedCommandLine): CommandLin
       reporter,
       errorSummary,
       buildInfo,
+      config: runConfigOf(config.options),
     };
   };
   if (parsesAhead(config.options)) {
     // Threads parse and bind the files the program is expected to load first (parallel-parse.ts), and
     // share the program it becomes: its symbols get their ids when they are created.
     assignSymbolIdsAtCreation();
-    const threads = checkerThreads(config.options.checkers, config.options.singleThreaded);
     return {
       kind: 'deferred',
       run: (done: (result: CommandLineResult) => void) => {
         const session =
           early ??
           new ParseSession(
-            parseThreads(threads),
+            runConfigOf(config.options).parseThreads,
             config.options,
             sys.currentDirectory,
             configFileName,

package/src/compiler/tsc-compile.ts

@@ -26,7 +26,9 @@ import {
 } from './incremental.js';
 import {
   checkerThreads,
+  memoryLimit,
   parallelCheck,
+  residentMB,
   shareWithCheckers,
   startParallelCheck,
   traceSingleChecker,
@@ -52,6 +54,22 @@ import {
   type System,
   SystemFileSystem,
 } from './tsc-cli.js';
+import { reportRunConfig, Source, type CheckSignals, type RunConfig, type RecordsReport } from './run-config.js';
+import { availableCpus } from './cgroup.js';
+import { doctorReportPath, setDoctorCompile, type DoctorCompile, type DoctorSignals } from './doctor-report.js';
+import {
+  displayPath,
+  recordEnvironment,
+  recordKey,
+  recordsDirectory,
+  writeRecord,
+  type RecordChoice,
+  type RecordSample,
+  type RecordShape,
+} from './run-records.js';
+import { recordOptionsOf } from './run-record-read.js';
+import { version } from './help.js';
+import { loadavg } from 'node:os';
 
 type CompileWork = Extract<CommandLineResult, { kind: 'compile' }>;
 
@@ -93,6 +111,12 @@ export function compile(sys: System, work: CompileWork): ExitStatus {
   let compilerProgram: CompilerProgram;
   if (work.incremental) {
     const old = oldSnapshotOf(sys, work, times);
+    // An incremental recheck on old build info checks the files a change affects, not the program:
+    // a record's samples are full checks (`run-records.ts`).
+    if (old !== undefined && work.config !== undefined) {
+      work.config.records = false;
+      work.config.recordsReason = 'incremental recheck';
+    }
     const changesStart = performance.now();
     compilerProgram = new IncrementalProgram(checked, times, old, new SystemTimeStamps(sys));
     times.changesComputeTime = performance.now() - changesStart;
@@ -106,7 +130,7 @@ export function compile(sys: System, work: CompileWork): ExitStatus {
     outputLocale(program.options),
   );
   traceSingleChecker(checked);
-  return emitStatusAndReportStatistics(sys, compilerProgram, result);
+  return emitStatusAndReportStatistics(sys, compilerProgram, result, work.config);
 }
 
 /** The old state of `work`'s incremental program: read while threads parsed its files, or now. */
@@ -136,7 +160,12 @@ function oldSnapshotOf(sys: System, work: CompileWork, times: CompileTimes): Sna
 export function compileThreads(_sys: System, work: CompileWork): number {
   const options = work.program.options;
   mark('compile threads');
-  return checkerThreads(options.checkers, options.singleThreaded, work.program);
+  // The run's configuration counts the checkers the program allows: one where it checks little, or
+  // where its text doesn't fit the machine's memory as many. A checker thread run decides again once
+  // the plan is made (`startParallelCheck`, run-config.ts).
+  const count = checkerThreads(options.checkers, options.singleThreaded, work.program);
+  work.config.checkers = count;
+  return count;
 }
 
 /** The number of threads to emit JavaScript on while this thread checks (`compileWithEmitThreads`), or 0. */
@@ -186,7 +215,7 @@ export function compileWithEmitThreads(
       outputLocale(program.options),
     );
     traceSingleChecker(checked);
-    done(emitStatusAndReportStatistics(sys, compilerProgram, result));
+    done(emitStatusAndReportStatistics(sys, compilerProgram, result, work.config));
   };
   const emitKinds = emitKindsOf(compilerProgram);
   if (emitKinds !== undefined) threads = emitThreads(program, program.options.singleThreaded, emitKinds);
@@ -333,7 +362,7 @@ export function compileWithDeclarationThread(
       outputLocale(options),
     );
     traceSingleChecker(checked);
-    done(emitStatusAndReportStatistics(sys, compilerProgram, result));
+    done(emitStatusAndReportStatistics(sys, compilerProgram, result, work.config));
   };
   startDeclarationErrorThread(checked, (declarations) => {
     // `PlainProgram.getDeclarationDiagnostics` reads them.
@@ -383,6 +412,11 @@ export function compileInParallel(
     if (sharesPublishedGraphs) shareWithCheckers(checked);
     checking = program.getSyntacticDiagnostics().length === 0 && program.getProgramDiagnostics().length === 0;
   }
+  if (!checking && work.config !== undefined) {
+    // The threads only emit: nothing is checked, so there is no sample to keep.
+    work.config.records = false;
+    work.config.recordsReason = 'nothing checked';
+  }
   const finish = (checkTime: number): void => {
     // An incremental program here has no build info (`compileThreads`).
     let compilerProgram: CompilerProgram;
@@ -402,7 +436,7 @@ export function compileInParallel(
     );
     times.checkTime = checkTime;
     mark(`reported ${result.diagnostics.length} diagnostics`);
-    done(emitStatusAndReportStatistics(sys, compilerProgram, result));
+    done(emitStatusAndReportStatistics(sys, compilerProgram, result, work.config));
   };
   const options = program.options;
   if (!checking && (options.noEmit === true || options.noEmitOnError === true)) return finish(0);
@@ -440,10 +474,13 @@ export function compileInParallel(
       true,
       kinds,
       checking,
+      undefined,
+      undefined,
+      work.config,
     );
     return;
   }
-  startParallelCheck(checked, threads, finish, true, undefined, checking);
+  startParallelCheck(checked, threads, finish, true, undefined, checking, undefined, undefined, work.config);
 }
 
 /**
@@ -463,6 +500,12 @@ function recheckInParallel(
   done: (status: ExitStatus) => void,
 ): void {
   const program = work.program;
+  // An incremental recheck measures a part of the program, which a record's samples are not comparable
+  // with full checks (`run-records.ts`).
+  if (work.config !== undefined) {
+    work.config.records = false;
+    work.config.recordsReason = 'incremental recheck';
+  }
   const old = oldSnapshotOf(sys, work, times);
   // The program is shared before its checker does more than merge the globals; the incremental program
   // compares the references of its files with the old state on as many threads as check.
@@ -487,7 +530,7 @@ function recheckInParallel(
     );
     times.checkTime += threadsCheckTime;
     mark(`reported ${result.diagnostics.length} diagnostics`);
-    done(emitStatusAndReportStatistics(sys, incrementalProgram, result));
+    done(emitStatusAndReportStatistics(sys, incrementalProgram, result, work.config));
   };
   // Reporting checks only programs without syntactic, program and global errors (getDiagnosticsOfProgram).
   // The threads emit the files they check, as the checker that checks a file emits it on this thread: into
@@ -513,6 +556,9 @@ function recheckInParallel(
     true,
     incrementalProgram.emitKindsOnCheckers(files),
     incrementalProgram.checksOnCheckers,
+    undefined,
+    undefined,
+    work.config,
   );
 }
 
@@ -580,20 +626,179 @@ export function reportEmitAndErrors(
   return new CompileResult(all, emitResult);
 }
 
-/** The exit status of a compilation, after printing `--diagnostics` statistics. */
+/**
+ * The exit status of a compilation, after printing `--diagnostics` statistics and, under
+ * `--extendedDiagnostics` only, the run configuration's `Suggestions:` section (run-config.ts).
+ */
 export function emitStatusAndReportStatistics(
   sys: System,
   program: CompilerProgram,
   result: CompileResult,
+  config: RunConfig | undefined = undefined,
 ): ExitStatus {
   const options = program.options;
+  const records = saveRunRecord(sys, program, config);
+  if (doctorReportPath() !== undefined) setDoctorCompile(doctorCompileOf(program, config));
   if (options.diagnostics === true || options.extendedDiagnostics === true) {
     program.times.totalTime = sys.sinceStart();
     statisticsOf(program).report(sys);
+    if (options.extendedDiagnostics === true && config !== undefined) reportRunConfig(sys, config, records);
   }
   return exitStatusOf(result);
 }
 
+/**
+ * Writes this run's sample to its record (`run-records.ts`) and says what the section's `Records:` line
+ * reports. A run keeps no record where it may not write one (watch mode, a build's concurrent projects,
+ * `--singleThreaded`, Node builds, `TSC_TS_AUTO=0` or `static`, `TSC_TS_CACHE=0`), where it checked
+ * nothing, and where it rechecked the files a change affects on old build info (`recheckInParallel`, a
+ * build's projects). The write is best effort: a cache directory that cannot be written reports why and
+ * the run goes on.
+ */
+export function saveRunRecord(
+  sys: System,
+  program: CompilerProgram,
+  config: RunConfig | undefined,
+): RecordsReport | undefined {
+  if (config === undefined) return undefined;
+  if (!config.records) return { off: config.recordsReason ?? 'not measured' };
+  if (!sharesPublishedGraphs) return { off: 'Node.js builds' };
+  if (program.options.singleThreaded === true) return { off: '--singleThreaded' };
+  // A run that stopped before checking (`--noCheck`, syntax errors) has nothing to sample.
+  if (!program.checkedTheProgram) return { off: 'nothing checked' };
+  // A run that read its record before parsing already knows the directory and key (`openRecord`); a
+  // build project that did not computes them now, from the parsed program.
+  const directory = config.recordDirectory ?? recordsDirectory(recordEnvironment());
+  if (directory === undefined) return { off: 'TSC_TS_CACHE=0' };
+  const shape = config.shape ?? recordShapeOf(program, config);
+  const key = config.recordKey ?? recordKeyOf(program);
+  const written = writeRecord(
+    directory,
+    key,
+    recordSampleOf(sys, program, config),
+    shape,
+    chosenOf(config),
+    config.rejected,
+  );
+  if (written.path !== undefined) return { path: displayPath(written.path) };
+  return { unavailable: written.reason };
+}
+
+/** The key this run's record has: the build, the project, the options and the machine (`run-records.ts`). */
+function recordKeyOf(program: CompilerProgram): string {
+  return recordKey({
+    version,
+    executable: process.execPath,
+    configFile: program.options.configFilePath,
+    rootNames: program.program.commandLine.fileNames,
+    options: recordOptionsOf(program.options),
+    cpus: Math.max(1, availableCpus()),
+    memoryBytes: memoryLimit(),
+  });
+}
+
+/** What this compile measured, for a doctor child's report (`doctor-report.ts`). */
+function doctorCompileOf(program: CompilerProgram, config: RunConfig | undefined): DoctorCompile {
+  const times = program.times;
+  const signals = config?.signals;
+  return {
+    version,
+    configFile: program.options.configFilePath,
+    key: recordKeyOf(program),
+    checkers: config?.checkers ?? 1,
+    share: config?.share ?? false,
+    parseThreads: config?.parseThreads ?? 1,
+    times: {
+      parseMs: times.parseTime + times.bindTime,
+      checkMs: times.checkTime,
+      totalMs:
+        times.totalTime !== 0 ? times.totalTime : times.parseTime + times.bindTime + times.checkTime + times.emitTime,
+    },
+    shape: recordShapeOf(program, config),
+    signals: signals === undefined ? undefined : doctorSignalsOf(signals),
+  };
+}
+
+/** The bound program's signals as a doctor report keeps them. */
+function doctorSignalsOf(signals: CheckSignals): DoctorSignals {
+  return {
+    count: signals.count,
+    ranges: signals.ranges,
+    library: signals.library,
+    own: signals.own,
+    redundancy: signals.redundancy,
+    declarationShare: signals.declarationShare,
+    nodeModulesShare: signals.nodeModulesShare,
+    fileShare: signals.fileShare,
+  };
+}
+
+/** The program's size, and the library and redundancy signals where the run computed them. */
+function recordShapeOf(program: CompilerProgram, config: RunConfig | undefined): RecordShape {
+  let files = 0;
+  let chars = 0;
+  let declarationChars = 0;
+  for (const file of program.program.getSourceFiles()) {
+    files++;
+    chars += file.end;
+    if (file.isDeclarationFile) declarationChars += file.end;
+  }
+  const signals = config?.signals;
+  return {
+    files,
+    chars,
+    declarationChars,
+    checkChars: chars - declarationChars,
+    library: signals === undefined ? 0 : Math.round(signals.library),
+    own: signals === undefined ? 0 : Math.round(signals.own),
+    redundancy: signals === undefined ? 0 : signals.redundancy,
+    fileShare: signals === undefined ? 0 : Math.max(signals.declarationShare, signals.nodeModulesShare),
+  };
+}
+
+/** What this run measured, for its record (`RecordSample`, without the number the record gives it). */
+function recordSampleOf(sys: System, program: CompilerProgram, config: RunConfig): Omit<RecordSample, 'run'> {
+  const times = program.times;
+  const usage = process.cpuUsage();
+  const cpus = Math.max(1, availableCpus());
+  return {
+    at: Math.floor(Date.now() / 1000),
+    role: config.role,
+    checkers: config.checkers,
+    share: config.share,
+    bounded: config.bounded,
+    parseThreads: config.parseThreads,
+    parseMs: Math.round(times.parseTime + times.bindTime),
+    checkMs: Math.round(times.checkTime),
+    totalMs: Math.round(sys.sinceStart()),
+    cpuMs: Math.round((usage.user + usage.system) / 1000),
+    peakMB: residentMB()[1] ?? 0,
+    load: Math.round((loadavg()[0]! / cpus) * 100) / 100,
+  };
+}
+
+/**
+ * The configuration this run chose for the next one, as its record keeps it (the record numbers the run
+ * that chose it). The learning rules name it (`config.chosen`); a run without them records the choice it
+ * used, and whether a pin made it.
+ */
+function chosenOf(config: RunConfig): RecordChoice {
+  if (config.chosen !== undefined) return config.chosen;
+  return {
+    checkers: config.checkers,
+    share: config.share,
+    bounded: config.bounded,
+    parseThreads: config.parseThreads,
+    source:
+      config.checkersSource === Source.Pinned ||
+      config.shareSource === Source.Pinned ||
+      config.boundedSource === Source.Pinned
+        ? 'pinned'
+        : 'default',
+    since: 0,
+  };
+}
+
 export function exitStatusOf(result: CompileResult): ExitStatus {
   if (result.diagnostics.length === 0) return ExitStatus.Success;
   return result.emitResult.emitSkipped
@@ -673,6 +878,8 @@ export class Statistics {
     rows.push([prefix + 'Types', String(this.types)]);
     rows.push([prefix + 'Instantiations', String(this.instantiations)]);
     rows.push([prefix + 'Memory used', `${Math.floor(this.memoryUsed / 1024)}K`]);
+    // The table has tsgo's rows. No runtime counter matches its allocation count (runtime.MemStats.Mallocs),
+    // so this one stays 0.
     rows.push([prefix + 'Memory allocs', String(this.memoryAllocs)]);
     const t = this.times;
     if (t.configTime !== 0) rows.push([prefix + 'Config time', formatDuration(t.configTime)]);
@@ -711,7 +918,14 @@ export function statisticsOf(compilerProgram: CompilerProgram): Statistics {
     statistics.identifiers += file.identifierCount;
     statistics.symbols += file.symbolCount;
   }
-  statistics.types = compilerProgram.checked.checker.typeCount;
+  // Every checker's counts, the checker threads' included, as tsgo's statisticsFromProgram reports them.
+  const counts = compilerProgram.checked.checkerCounts();
+  statistics.symbols += counts.symbols;
+  statistics.types = counts.types;
+  statistics.instantiations = counts.instantiations;
+  // tsgo reports the Go heap in use (runtime.MemStats.Alloc); the closest this runtime has is the
+  // process's resident set, which includes the checker threads' heaps.
+  statistics.memoryUsed = process.memoryUsage.rss();
   const t = statistics.times;
   const source = compilerProgram.times;
   t.configTime = source.configTime;

package/src/compiler/tsc-watch.ts

@@ -43,7 +43,8 @@ import {
 } from './tsc-cli.js';
 import { isIncremental } from './options.js';
 import { ParseSession, clearPreparedFiles, parallelParse, takePreparedFile } from './parallel-parse.js';
-import { checkerThreads, parseThreads, shareWithCheckers, startParallelCheck } from './parallel-check.js';
+import { checkerThreads, shareWithCheckers, startParallelCheck } from './parallel-check.js';
+import { preParseConfig, type RunConfig } from './run-config.js';
 import { assignSymbolIdsAtCreation, symbolIdsAtCreation } from './symbol.js';
 import { Orchestrator, StatusReporter, startWatchRebuild } from './tsc-build.js';
 import { mark } from './timeline.js';
@@ -452,6 +453,8 @@ class Watcher {
   /** Whether a rebuild is running (`poll`), and whether a check came during it. */
   private building = false;
   private checkPending = false;
+  /** The first program's run configuration, which its rebuilds use too (run-config.ts). */
+  private run: RunConfig | undefined = undefined;
 
   constructor(
     private readonly sys: System,
@@ -516,8 +519,15 @@ class Watcher {
     const config = copyCommandLine(this.config);
     const options = config.options;
     const incremental = isIncremental(options);
+    // A watch chooses its configuration once, for its first program: parse threads are fixed before
+    // the program is parsed, and its rebuilds check what changed as that program did.
+    const run = (this.run = preParseConfig(options, checkerThreads(options.checkers, options.singleThreaded)));
+    // A watcher's rebuilds measure a change, not the project: it reads records for its first program only
+    // and keeps none (run-records.ts).
+    run.records = false;
+    run.recordsReason = 'watch mode';
     const session = new ParseSession(
-      parseThreads(checkerThreads(options.checkers, options.singleThreaded)),
+      run.parseThreads,
       options,
       sys.currentDirectory,
       config.configName,
@@ -585,7 +595,8 @@ class Watcher {
         this.finishBuild(checked);
         finish();
       };
-      if (this.snapshot === undefined && threads > 1) startParallelCheck(checked, threads, report);
+      if (this.snapshot === undefined && threads > 1)
+        startParallelCheck(checked, threads, report, true, undefined, true, undefined, undefined, run);
       else report();
     });
     if (incremental && sys.fileExists(config.buildInfoFileName())) session.queueAhead();
@@ -802,7 +813,17 @@ class Watcher {
           this.report(incremental, changedFiles);
           done();
         };
-        startParallelCheck(checked, threads, finish, true, incremental.emitKindsOnCheckers(files));
+        startParallelCheck(
+          checked,
+          threads,
+          finish,
+          true,
+          incremental.emitKindsOnCheckers(files),
+          true,
+          undefined,
+          undefined,
+          this.run,
+        );
         return;
       }
     }