tsc-ts 0.0.9 → 0.0.10

package/src/compiler/parallel-check.ts

@@ -33,7 +33,14 @@ import {
   type OutputWriter,
   ProgramEmitter,
 } from './compile-program.js';
-import { Diagnostic, DiagnosticFile, RepopulateInfo } from './diagnostics.js';
+import {
+  Diagnostic,
+  DiagnosticFile,
+  type DiagnosticFormatOptions,
+  formatDiagnostic,
+  formattedReports,
+  RepopulateInfo,
+} from './diagnostics.js';
 import { EmitOnly, EmitResult } from './emitter.js';
 import { getEmitDeclarations, isIncremental } from './options.js';
 import { DeclarationSignatureWriter } from './incremental.js';
@@ -144,10 +151,13 @@ export const recycleFiles: number = Math.max(0, Number(process.env.TSC_TS_RECYCL
  * text (index, -1 when the program has the file), pos, end, code, category, message,
  * skippedOnNoEmit, the argument count and indices, its repopulate kind (0 for none) followed by the
  * module reference (index), mode and package name (index) of other kinds, then its message chain and
- * related information as lists. An emit result is emitSkipped, the emitted files, errors and
- * unsupported files as lists of indices, then its diagnostics and its declaration signatures as a list
- * of indices. `files` and `nums` are typed arrays, which postMessage copies as one block of memory
- * each; it copies an array of numbers element by element.
+ * related information as lists. A diagnostic of a reported list (the files' diagnostic and declaration
+ * diagnostic lists, the global diagnostics and an emit result's diagnostics) is followed by its text in
+ * the main thread's report format (`Diagnostic.formatted`, an index, -1 for none). An emit result is
+ * emitSkipped, the emitted files, errors and unsupported files as lists of indices, then its
+ * diagnostics and its declaration signatures as a list of indices. `files` and `nums` are typed
+ * arrays, which postMessage copies as one block of memory each; it copies an array of numbers element
+ * by element.
  */
 export type PackedResult = {
   readonly index: number;
@@ -167,7 +177,11 @@ class ResultPacker {
   readonly strs: string[] = [];
   private readonly indices = new Map<string, number>();
 
-  constructor(private readonly program: Program) {}
+  constructor(
+    private readonly program: Program,
+    /** The main thread's report format, which this thread formats the reported diagnostics in. */
+    private readonly format: DiagnosticFormatOptions | undefined,
+  ) {}
 
   private str(text: string): number {
     let k = this.indices.get(text);
@@ -184,6 +198,21 @@ class ResultPacker {
     for (const d of diagnostics) this.diagnostic(d);
   }
 
+  /** A list the main thread reports: each diagnostic with its text in the report format. */
+  reported(diagnostics: readonly Diagnostic[]): void {
+    const nums = this.nums;
+    const format = this.format;
+    nums.push(diagnostics.length);
+    for (const d of diagnostics) {
+      this.diagnostic(d);
+      if (format === undefined) nums.push(-1);
+      else {
+        nums.push(this.strs.length);
+        this.strs.push(formatDiagnostic(d, format));
+      }
+    }
+  }
+
   private strList(texts: readonly string[]): void {
     this.nums.push(texts.length);
     for (const text of texts) this.nums.push(this.str(text));
@@ -194,7 +223,7 @@ class ResultPacker {
     this.strList(result.emittedFiles);
     this.strList(result.errors);
     this.strList(result.unsupported);
-    this.list(result.diagnostics);
+    this.reported(result.diagnostics);
     this.strList(result.declarationSignatures);
     this.strList(result.heldOutputs);
   }
@@ -226,11 +255,11 @@ class ResultPacker {
 
 /** Packs `result` (on the checker thread) for `postMessage`. */
 export function packResult(result: CheckerResult, program: Program): PackedResult {
-  const packer = new ResultPacker(program);
-  for (const list of result.diagnostics) packer.list(list);
+  const packer = new ResultPacker(program, formattedReports.format);
+  for (const list of result.diagnostics) packer.reported(list);
   packer.nums.push(result.declarations.length);
-  for (const list of result.declarations) packer.list(list);
-  packer.list(result.globals);
+  for (const list of result.declarations) packer.reported(list);
+  packer.reported(result.globals);
   packer.nums.push(result.emits.length);
   for (const emit of result.emits) packer.emit(emit);
   return {
@@ -272,6 +301,19 @@ class ResultUnpacker {
     return result;
   }
 
+  /** A list `ResultPacker.reported` packed. */
+  reported(): Diagnostic[] {
+    const n = this.next();
+    const result: Diagnostic[] = [];
+    for (let k = 0; k < n; k++) {
+      const d = this.diagnostic();
+      const text = this.next();
+      if (text >= 0) d.formatted = this.packed.strs[text]!;
+      result.push(d);
+    }
+    return result;
+  }
+
   private diagnostic(): Diagnostic {
     const strs = this.packed.strs;
     const name = this.next();
@@ -325,7 +367,7 @@ class ResultUnpacker {
     this.strList(result.emittedFiles);
     this.strList(result.errors);
     this.strList(result.unsupported);
-    for (const d of this.list()) result.diagnostics.push(d);
+    for (const d of this.reported()) result.diagnostics.push(d);
     this.strList(result.declarationSignatures);
     this.strList(result.heldOutputs);
     return result;
@@ -339,11 +381,11 @@ export function unpackResult(
 ): CheckerResult {
   const unpacker = new ResultUnpacker(packed, program, files);
   const diagnostics: Diagnostic[][] = [];
-  for (let k = 0; k < packed.files.length; k++) diagnostics.push(unpacker.list());
+  for (let k = 0; k < packed.files.length; k++) diagnostics.push(unpacker.reported());
   const declarations: Diagnostic[][] = [];
   const nd = unpacker.count();
-  for (let k = 0; k < nd; k++) declarations.push(unpacker.list());
-  const globals = unpacker.list();
+  for (let k = 0; k < nd; k++) declarations.push(unpacker.reported());
+  const globals = unpacker.reported();
   const emits: EmitResult[] = [];
   const ne = unpacker.count();
   for (let k = 0; k < ne; k++) emits.push(unpacker.emit());
@@ -650,8 +692,8 @@ class CheckCosts {
     readonly libraries: number[][],
     /** What resolving a library costs a checker the first time (`libraryFirstUseShare` of the text it reaches), by index. */
     readonly libraryCost: number[],
-    /** The program files (indices) each file of `order` imports, by index. */
-    readonly imports: (number[] | undefined)[],
+    /** The program files (indices) each file imports (`ProcessedFiles.addedFiles`), by index. */
+    readonly imports: readonly (readonly number[])[],
   ) {}
 }
 
@@ -696,34 +738,18 @@ function checkCosts(checked: CheckedProgram, order: number[]): CheckCosts {
   }
   const length = textLengths(program);
   for (const i of order) cost[i] = length[i]!;
-  const indexOf = new Map<SourceFile, number>();
-  for (let i = 0; i < files.length; i++) indexOf.set(files[i]!, i);
-  // A file resolved by its own file name is that file (its path is the path of that name).
-  const byFileName = new Map<string, SourceFile>();
-  for (const file of files) byFileName.set(file.fileName, file);
   const checkedFile: boolean[] = [];
   for (let i = 0; i < files.length; i++) checkedFile.push(false);
   for (const i of order) checkedFile[i] = true;
   // Libraries: unchecked modules that are not default libraries (globals every checker has).
   const isLibrary = (i: number): boolean =>
     !checkedFile[i]! && !program.isSourceFileDefaultLibrary(files[i]!.path) && isExternalModuleFile(files[i]!);
-  const edges: (number[] | undefined)[] = [];
-  const edgesOf = (i: number): number[] => {
-    let result = edges[i];
-    if (result === undefined) {
-      result = [];
-      for (const target of program.getResolvedFilesOf(files[i]!, byFileName)) {
-        const k = indexOf.get(target);
-        if (k !== undefined && k !== i) result.push(k);
-      }
-      edges[i] = result;
-    }
-    return result;
-  };
+  // The files each file imports: those it added to the program (`ProcessedFiles.addedFiles`).
+  const edges = program.addedFiles();
   const importers = new Map<number, number>();
   for (const i of order) {
     const libraries: number[] = [];
-    for (const k of edgesOf(i)) if (isLibrary(k) && libraries.indexOf(k) < 0) libraries.push(k);
+    for (const k of edges[i]!) if (isLibrary(k) && libraries.indexOf(k) < 0) libraries.push(k);
     librariesOf[i] = libraries;
     for (const k of libraries) importers.set(k, (importers.get(k) ?? 0) + 1);
   }
@@ -738,7 +764,7 @@ function checkCosts(checked: CheckedProgram, order: number[]): CheckCosts {
     while (stack.length > 0) {
       const k = stack.pop()!;
       total += length[k]!;
-      for (const t of edgesOf(k))
+      for (const t of edges[k]!)
         if (!seen.has(t) && isLibrary(t)) {
           seen.add(t);
           stack.push(t);
@@ -1642,20 +1668,34 @@ export function checkFromQueue(
     } else if (writer !== undefined) {
       const emitStart = timeline ? performance.now() : 0;
       const kind = (emitKinds === undefined ? EmitOnly.All : emitKinds[i]!) as EmitOnly;
+      // Global diagnostics found while emitting are not reported: the program collects them
+      // before it emits.
+      const checker = checked.checker;
       if (kind < 0) emits.push(new EmitResult());
       else if (signatures !== undefined) {
         signatures.file = files[i]!;
-        const result = emitter!.emit([files[i]!], kind, signatures);
+        const result = checker.withoutGlobalDiagnostics(() => emitter!.emit([files[i]!], kind, signatures));
         for (const s of signatures.take()) result.declarationSignatures.push(s);
         if (holding !== undefined) for (const o of holding.take()) result.heldOutputs.push(o);
         emits.push(result);
       } else {
-        const result = emitter!.emit([files[i]!], kind, writer);
+        const result = checker.withoutGlobalDiagnostics(() => emitter!.emit([files[i]!], kind, writer));
         if (holding !== undefined) for (const o of holding.take()) result.heldOutputs.push(o);
         emits.push(result);
       }
       if (timeline) markAt(emitStart, `emit ${(performance.now() - emitStart).toFixed(1)} ${files[i]!.fileName}`);
-    } else if (emitter !== undefined) declarations.push(declarationDiagnosticsOfFile(emitter, files[i]!));
+    } else if (emitter !== undefined)
+      declarations.push(
+        checked.checker.withoutGlobalDiagnostics(() => declarationDiagnosticsOfFile(emitter, files[i]!)),
+      );
+    // What emitting found and forgot can stay cached in this checker (a missing global type, an
+    // instantiation too deep), where checking a later file would report it: a new checker continues
+    // the schedule, as at the file limit.
+    if (checked.checker.forgottenGlobalDiagnostics() > 0) {
+      more = true;
+      left = reservedBy(index).splice(0);
+      break;
+    }
   }
   mark(`checked ${done.length} files, ${unitsDone.length} ranges`);
   // The main thread reports its own global diagnostics (CheckedProgram.getGlobalDiagnostics).
@@ -1828,7 +1868,11 @@ export function shareWithCheckers(checked: CheckedProgram): void {
 /**
  * Checks `checked` on `checkers` threads and calls `done` once they are done. With `emits`, each thread
  * emits the files it checks (`emitKinds` limits what). With `checking` false, the threads only emit:
- * for a program whose report has no semantic diagnostics, so that no file is checked in full.
+ * for a program whose report has no semantic diagnostics, so that no file is checked in full. With
+ * `emitsTo`, the emit results go only there, by file index, and nothing else the threads find reaches
+ * the program: a declaration thread (parallel-emit.ts), while this thread's checker checks. With
+ * `declarationsTo`, the same holds for the declaration errors of a `noEmit` program
+ * (`checkersReportDeclarations`).
  */
 export function startParallelCheck(
   checked: CheckedProgram,
@@ -1837,6 +1881,8 @@ export function startParallelCheck(
   emits: boolean = true,
   emitKinds: number[] | undefined = undefined,
   checking: boolean = true,
+  emitsTo: (EmitResult | undefined)[] | undefined = undefined,
+  declarationsTo: (Diagnostic[] | undefined)[] | undefined = undefined,
 ): void {
   let count = checkers;
   const start = performance.now();
@@ -1899,6 +1945,11 @@ export function startParallelCheck(
   let remaining = count - firstThread;
   let ownDone = false;
   const finish = (): void => {
+    if (emitsTo !== undefined || declarationsTo !== undefined) {
+      mark('emitted on checker threads');
+      done(performance.now() - start);
+      return;
+    }
     if (checking) {
       joinRanges(checked, units, perUnit, perFile);
       // A thread that failed may have taken files it never checked: check them here.
@@ -1929,6 +1980,22 @@ export function startParallelCheck(
     done(performance.now() - start);
   };
   const record = (result: CheckerResult): void => {
+    if (declarationsTo !== undefined) {
+      for (let k = 0; k < result.declarations.length; k++) declarationsTo[result.files[k]!] = result.declarations[k]!;
+      if (trace)
+        process.stderr.write(
+          `checkers: emit-only thread ${result.index} found the declaration errors of ${result.declarations.length} files in ${result.checkTime.toFixed(1)}ms, done at ${(performance.now() - start).toFixed(1)}ms rss ${result.stats[7] ?? '?'}MB\n`,
+        );
+      return;
+    }
+    if (emitsTo !== undefined) {
+      for (let k = 0; k < result.emits.length; k++) emitsTo[result.files[k]!] = result.emits[k]!;
+      if (trace)
+        process.stderr.write(
+          `checkers: emit-only thread ${result.index} emitted ${result.emits.length} files in ${result.checkTime.toFixed(1)}ms, done at ${(performance.now() - start).toFixed(1)}ms rss ${result.stats[7] ?? '?'}MB\n`,
+        );
+      return;
+    }
     for (let k = 0; k < result.files.length; k++) perFile[result.files[k]!] = result.diagnostics[k]!;
     for (let k = 0; k < result.declarations.length; k++)
       perFileDeclarations[result.files[k]!] = result.declarations[k]!;
@@ -1991,10 +2058,28 @@ export function startParallelCheck(
   mark('reporting checker created');
   const emittedHere =
     !mainChecks && emitKinds === undefined ? emitUncheckedFiles(checked, order, emits) : new Map<number, EmitResult>();
-  if (mainChecks)
-    record(
-      checkFromQueue(checked, 0, new Int32Array(counter), order, epoch, true, 0, [], emits, emitKinds, checking, units),
+  if (mainChecks) {
+    const own = checkFromQueue(
+      checked,
+      0,
+      new Int32Array(counter),
+      order,
+      epoch,
+      true,
+      0,
+      [],
+      emits,
+      emitKinds,
+      checking,
+      units,
     );
+    record(own);
+    // A thread continues where this checker stopped (`checkFromQueue`).
+    if (own.more) {
+      remaining++;
+      spawn(0, own.reserved);
+    }
+  }
   ownDone = true;
   if (remaining === 0) finish();
 }

package/src/compiler/parallel-emit.ts

@@ -0,0 +1,320 @@
+/**
+ * Emitting a program's JavaScript on threads while the main thread checks it (`--checkers 1` in
+ * scriptc builds).
+ *
+ * JavaScript emit needs nothing of a checker but how decorator metadata serializes a type: import
+ * elision, export names and const enum values come from syntax, the binder's symbols and the other
+ * files of the program (`SyntacticEmitResolver`, `ReferenceResolver`). So emit threads create no
+ * checker. They receive the published program, emit with a `JavaScriptEmitter` the files the main
+ * thread hands out through a shared counter, write the outputs and send back their emit results.
+ * The main thread checks meanwhile, and so does the declaration thread, a checker thread that only
+ * emits declarations (`startDeclarationThread`): `--checkers` counts the checkers that check. Then the
+ * main thread records how its checker serializes the types of the decorator metadata of the files that
+ * have it (`recordMetadataKinds`), which a second wave of emit threads emits with those answers as plain
+ * data (`startMetadataEmit`). Which thread emits a file doesn't change its output, and the main
+ * thread's checker finds every diagnostic but those of declaration emit.
+ */
+import type { Worker } from 'node:worker_threads';
+import { availableParallelism } from 'node:os';
+import { publish } from '@scriptc/threads';
+import { lastNodeIdValue, type SourceFile } from './ast.js';
+import { JavaScriptEmitter, type OutputWriter } from './compile-program.js';
+import type { Diagnostic, DiagnosticFile } from './diagnostics.js';
+import { EmitOnly, EmitResult, sourceFileMayBeEmitted } from './emitter.js';
+import {
+  CheckerResult,
+  packResult,
+  packsResults,
+  type PackedResult,
+  startParallelCheck,
+  unpackResult,
+} from './parallel-check.js';
+import type { CheckedProgram } from './program-checker.js';
+import type { Program } from './program.js';
+import { lastSymbolIdValue } from './symbol.js';
+import { mark } from './timeline.js';
+import { SubtreeFacts, SyntaxFacts } from './transformers/syntax-facts.js';
+
+/**
+ * Starts emit thread `index` (main.ts owns the worker entry point) on the shared, published
+ * `program`: it emits the files of `files` at the positions it takes from `counter`, with the decorator
+ * metadata `kinds` the main thread recorded (`startMetadataEmit`); ids continue above `nodeIds` and
+ * `symbolIds`.
+ */
+export type EmitSpawn = (
+  program: Program,
+  index: number,
+  counter: SharedArrayBuffer,
+  files: number[],
+  kinds: number[],
+  nodeIds: number,
+  symbolIds: number,
+) => Worker;
+
+export class ParallelEmit {
+  /** Set where emit threads can be started. */
+  spawn: EmitSpawn | undefined = undefined;
+}
+
+export const parallelEmit = new ParallelEmit();
+
+/** The most emit threads: four emitted VS Code's JavaScript as fast as 15 did while one thread checked it. */
+const maxEmitThreads = 4;
+
+/**
+ * The least text of the files to emit, in characters, for emit threads: starting them and sharing
+ * the program takes about as long as emitting this much.
+ */
+const littleEmitText = 50_000;
+
+/**
+ * The number of threads to emit the JavaScript of `program` on, or 0 to emit it on this thread:
+ * where threads can start and the program emits enough, one fewer than the CPUs, at most
+ * `maxEmitThreads`. `emitKinds` are what the emit of each file includes (`emitsJavaScript`).
+ */
+export function emitThreads(
+  program: Program,
+  singleThreaded: boolean | undefined,
+  emitKinds: readonly number[] | undefined = undefined,
+): number {
+  if (parallelEmit.spawn === undefined || singleThreaded === true) return 0;
+  const cpus = availableParallelism();
+  if (cpus < 2) return 0;
+  const files = program.getSourceFiles();
+  let text = 0;
+  for (let i = 0; i < files.length; i++)
+    if (emitsJavaScript(program, emitKinds, i)) {
+      text += files[i]!.end;
+      if (text >= littleEmitText) return Math.min(cpus - 1, maxEmitThreads);
+    }
+  return 0;
+}
+
+/**
+ * Whether the emit of file `index` of `program` includes its JavaScript. `emitKinds` are what the emit of
+ * each file includes, by file index: an `EmitOnly`, or -1 for nothing, as an incremental program's pending
+ * emit selects (`IncrementalProgram.emitKindsOnCheckers`); `undefined` where every file that may be emitted
+ * is emitted in full.
+ */
+function emitsJavaScript(program: Program, emitKinds: readonly number[] | undefined, index: number): boolean {
+  if (emitKinds === undefined) return sourceFileMayBeEmitted(program.getSourceFiles()[index]!, program.options);
+  const kind = emitKinds[index]!;
+  return kind === EmitOnly.All || kind === EmitOnly.Js;
+}
+
+/**
+ * Whether the JavaScript of `file` needs decorator metadata kinds from the checker (`emitDecoratorMetadata`
+ * asks it how the types of decorated declarations serialize): a file with decorators is emitted by the second
+ * wave of emit threads, with the kinds the main thread's checker recorded after checking (`startMetadataEmit`).
+ */
+function needsMetadataKinds(file: SourceFile, program: Program): boolean {
+  return program.options.emitDecoratorMetadata === true && new SyntaxFacts().has(file, SubtreeFacts.ContainsDecorators);
+}
+
+/**
+ * Emits the JavaScript of the files of `checked` whose emit includes it (`emitKinds`) on `threads` threads
+ * and calls `done` once they are emitted; the program must be shared (`shareWithCheckers`). The emit results
+ * go to `checked.emittedInParallel`, which the program's emit (`PlainProgram`, `IncrementalProgram`) completes
+ * on this thread. Returns at once, with the indexes of the files left for `startMetadataEmit`: the results
+ * arrive on this thread's event loop.
+ */
+export function startParallelEmit(
+  checked: CheckedProgram,
+  threads: number,
+  done: () => void,
+  emitKinds: readonly number[] | undefined = undefined,
+): number[] {
+  const program = checked.program;
+  const files = program.getSourceFiles();
+  const order: number[] = [];
+  const metadata: number[] = [];
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i]!;
+    if (!emitsJavaScript(program, emitKinds, i)) continue;
+    if (needsMetadataKinds(file, program)) metadata.push(i);
+    else order.push(i);
+  }
+  const perFileEmits: (EmitResult | undefined)[] = [];
+  for (let i = 0; i < files.length; i++) perFileEmits.push(undefined);
+  checked.emittedInParallel = perFileEmits;
+  checked.javaScriptEmittedOnThreads = true;
+  spawnEmitThreads(checked, threads, order, [], done);
+  return metadata;
+}
+
+/**
+ * Emits the JavaScript of `files` (indexes, from `startParallelEmit`), whose decorator metadata asks the
+ * checker, on `threads` threads with the kinds that this thread's checker gave (`recordMetadataKinds`), and
+ * calls `done` once they are emitted. Called once this thread has checked the program, so that asking for the
+ * kinds doesn't change what checking finds.
+ */
+export function startMetadataEmit(
+  checked: CheckedProgram,
+  threads: number,
+  files: number[],
+  kinds: number[],
+  done: () => void,
+): void {
+  spawnEmitThreads(checked, Math.min(threads, files.length), files, kinds, done);
+}
+
+function spawnEmitThreads(
+  checked: CheckedProgram,
+  threads: number,
+  files: number[],
+  kinds: number[],
+  done: () => void,
+): void {
+  const program = checked.program;
+  const sourceFiles = program.getSourceFiles();
+  const perFileEmits = checked.emittedInParallel!;
+  const order = files.slice();
+  // The longest files first, so that the threads finish together.
+  order.sort((a, b) => sourceFiles[b]!.end - sourceFiles[a]!.end || a - b);
+  publish(order);
+  publish(kinds);
+  mark(`planned ${order.length} files to emit`);
+  const trace = process.env.TSC_TS_CHECKERS_TRACE !== undefined;
+  const start = performance.now();
+  const counter = new SharedArrayBuffer(4);
+  const diagnosticFiles = new Map<string, DiagnosticFile>();
+  let remaining = threads;
+  if (remaining === 0) done();
+  for (let i = 0; i < threads; i++) {
+    const worker = parallelEmit.spawn!(program, i, counter, order, kinds, lastNodeIdValue(), lastSymbolIdValue());
+    let ended = false;
+    const end = (): void => {
+      if (ended) return;
+      ended = true;
+      remaining--;
+      if (remaining === 0) done();
+    };
+    worker.on('message', (message: unknown) => {
+      mark(`result from e${i}`);
+      const result = packsResults
+        ? unpackResult(message as PackedResult, program, diagnosticFiles)
+        : publish((message as { result: CheckerResult }).result);
+      for (let k = 0; k < result.files.length; k++) perFileEmits[result.files[k]!] = result.emits[k]!;
+      if (trace)
+        process.stderr.write(
+          `emit threads: thread ${i} emitted ${result.files.length} files${kinds.length > 0 ? ` with metadata kinds (${result.stats[0] ?? 0} missed a kind)` : ''} in ${result.checkTime.toFixed(1)}ms, done at ${(performance.now() - start).toFixed(1)}ms\n`,
+        );
+      end();
+    });
+    // The files a failed thread took and did not send back are emitted on this thread (`PlainProgram.emit`).
+    worker.on('error', (error: unknown) => {
+      if (trace) process.stderr.write(`emit threads: thread ${i} failed: ${String(error)}\n`);
+      end();
+    });
+  }
+  mark('emit threads spawned');
+}
+
+/** The most checkers that a declaration thread makes faster (`declarationThreadPays`). */
+const maxDeclarationThreadCheckers = 8;
+
+/**
+ * Whether a declaration thread (`startDeclarationThread`) shortens a compile with `checkers` checkers: it
+ * takes the declaration emit off the checkers, but a checker that only emits declarations takes about as long
+ * as the whole check of VS Code or typeorm at 16 checkers. Measured with declarations on both: 6-16% faster
+ * from 1 to 8 checkers, about even at 12, and 32-38% slower at 16. It also needs a CPU of its own.
+ */
+export function declarationThreadPays(checkers: number): boolean {
+  return checkers <= maxDeclarationThreadCheckers && checkers < availableParallelism();
+}
+
+/**
+ * Starts the declaration thread: one checker thread that only emits, while the program is checked on this
+ * thread (`--checkers 1`) or on checker threads that emit only JavaScript, and calls `done` once it is done. It
+ * emits the declarations of every file of `checked` whose emit includes them (`emitKinds`), and also the
+ * JavaScript of `metadata` (file indexes, from `startParallelEmit`), whose decorator metadata asks a checker. Its
+ * checker checks only what emit asks; it reports nothing but the emit results, which it writes and which the
+ * returned array receives by file index (undefined for a file it didn't emit, which the program's emit then
+ * emits here). Declaration files and decorator metadata are the same with any checker that emits them.
+ */
+export function startDeclarationThread(
+  checked: CheckedProgram,
+  metadata: readonly number[],
+  done: () => void,
+  emitKinds: readonly number[] | undefined = undefined,
+): (EmitResult | undefined)[] {
+  const program = checked.program;
+  const options = program.options;
+  const files = program.getSourceFiles();
+  const kinds: number[] = [];
+  const results: (EmitResult | undefined)[] = [];
+  for (let i = 0; i < files.length; i++) {
+    let declarations: boolean;
+    if (emitKinds === undefined) declarations = sourceFileMayBeEmitted(files[i]!, options);
+    else declarations = emitKinds[i] === EmitOnly.All || emitKinds[i] === EmitOnly.Dts;
+    kinds.push(declarations ? EmitOnly.Dts : -1);
+    results.push(undefined);
+  }
+  for (const i of metadata) kinds[i] = emitKinds === undefined ? EmitOnly.All : emitKinds[i]!;
+  startParallelCheck(checked, 1, () => done(), true, kinds, false, results);
+  mark('declaration thread spawned');
+  return results;
+}
+
+/**
+ * Starts the declaration thread of a `noEmit` program that reports the errors of declaration emit
+ * (`checkersReportDeclarations`): one checker thread that finds the declaration errors of every file of
+ * `checked` while the program is checked on this thread, and calls `done` once it is done. Its checker
+ * checks only what declaration emit asks; it reports nothing but the declaration errors, which `done`
+ * receives by file index (undefined for a file it didn't reach, whose errors
+ * `PlainProgram.getDeclarationDiagnostics` then finds here).
+ */
+export function startDeclarationErrorThread(
+  checked: CheckedProgram,
+  done: (declarations: (Diagnostic[] | undefined)[]) => void,
+): void {
+  const results: (Diagnostic[] | undefined)[] = [];
+  for (let i = 0; i < checked.program.getSourceFiles().length; i++) results.push(undefined);
+  startParallelCheck(checked, 1, () => done(results), true, undefined, false, undefined, results);
+  mark('declaration thread spawned');
+}
+
+/**
+ * On emit thread `index`: emits the JavaScript of the files of `order` at the positions it takes
+ * from `counter` until none are left, writing it with `writer`; `kinds` are the decorator metadata kinds
+ * the main thread recorded for them (`recordMetadataKinds`), if any. `stats` has the number of files that
+ * missed a kind.
+ */
+export function emitFromQueue(
+  program: Program,
+  index: number,
+  counter: Int32Array,
+  order: readonly number[],
+  kinds: readonly number[],
+  writer: OutputWriter,
+): CheckerResult {
+  const start = performance.now();
+  const files = program.getSourceFiles();
+  const emitter = new JavaScriptEmitter(program, kinds);
+  mark('emitter ready');
+  const done: number[] = [];
+  const diagnostics: Diagnostic[][] = [];
+  const emits: EmitResult[] = [];
+  let missed = 0;
+  for (;;) {
+    const position = Atomics.add(counter, 0, 1);
+    if (position >= order.length) break;
+    const i = order[position]!;
+    const result = emitter.emit(files[i]!, writer);
+    // A file whose emit missed a kind isn't sent back: the main thread emits it again, with its checker.
+    if (result === undefined) {
+      missed++;
+      continue;
+    }
+    done.push(i);
+    diagnostics.push([]);
+    emits.push(result);
+  }
+  mark(`emitted ${done.length} files`);
+  return new CheckerResult(index, done, diagnostics, [], [], performance.now() - start, [missed], false, [], emits);
+}
+
+/** What an emit thread posts back: `result`, packed for `postMessage` where results are packed. */
+export function postedEmitResult(result: CheckerResult, program: Program): PackedResult | { result: CheckerResult } {
+  return packsResults ? packResult(result, program) : { result: publish(result) };
+}