tsc-ts 0.0.8 → 0.0.10

package/README.md

@@ -31,7 +31,7 @@ npx tsc-ts -p tsconfig.json
 npx tsc-ts --noEmit src/index.ts
 ```
 
-`tsc-ts --api` serves the TypeScript API over stdin and stdout, like `tsc --api`. On Windows, `--api --pipe \\.\pipe\<name>` serves it over a named pipe it creates, as `tsc --api --pipe` does, for clients that connect to the pipe (such as scriptc under Node.js); only the native executable supports `--pipe`.
+`tsc-ts --api` serves the TypeScript API over stdin and stdout, like `tsc --api`. On Windows, `--api --pipe \\.\pipe\<name>` serves it over a named pipe it creates, as `tsc --api --pipe` does, for clients that connect to the pipe (such as scriptc under Node.js); only the native executable supports `--pipe`. On macOS and Linux, `--api --listen <path>` serves it on a Unix socket it creates, with mode 0600, to one client of the same user at a time, each until the client closes its end. Each client gets the answers a new `tsc-ts --api` process would give, except that symbol ids continue from earlier clients, and the server reads every file through the client again, but it keeps parsed files between clients and reuses those whose text is unchanged, along with the encoding `getSourceFile` sends for each, so a client that opens the same project again loads it faster. The server exits when no client connects for 60 seconds (`--idle-exit <seconds>` sets the time), or after a client when its resident memory is above 2.5 times what it held after its first client (`TSC_TS_LISTEN_MEMORY` sets the limit in megabytes). To stop, it removes the socket file, serves the clients that had connected, and exits. It replaces a socket file that no server answers on, such as one left by a server that was killed. Only the native executable supports `--listen`. With `--default-libraries-from-disk`, the server reads the files in its default library directory (`TSC_TS_LIB_DIR`, or the executable's directory) from the disk itself, even when the client handles file system calls (`--callbacks`), which saves a round trip to the client for each library file.
 
 `--checkers N` checks the program on N threads. Unless `--checkers` or `--singleThreaded` is given, the native executable uses one checker per CPU it may run on (up to 16), and at least tsgo's four; it uses fewer than the CPUs, but never fewer than four, when the estimated peak memory of more checkers would not fit 85% of the machine's memory (`TSC_TS_CHECKERS=fixed` keeps tsgo's four), and checkers beyond the fourth stop taking files, one at a time, when the process's memory reaches that share; it shares one program between its threads and also parses and binds the program's files on them. Unless `--singleThreaded` is given, the program's files are parsed and bound on threads also with `--checkers 1`, as tsgo does. Files that share costly declarations, such as a large generated schema and the few files importing it, are checked together on one checker. Under Node.js, where every thread builds its own copy of the program, tsc-ts checks on one thread unless `--checkers` is given. `--incremental`, `--watch` and `--build` always check on one thread. The diagnostics are the same as with one checker.
 

package/dist/api/compiler/ast.d.ts

@@ -2281,6 +2281,8 @@ export declare class SourceFile extends Node {
     identifierCount: number;
     nodeCount: number;
     textCount: number;
+    /** The API's binary encoding of this file, when an API server keeps it (`keptEncodingOf`). */
+    apiEncoding: Uint8Array | undefined;
     /** Module specifiers of imports, exports, `require` calls and `import()` types, in source order. */
     imports: Node[];
     /** Names of `declare module "x"` augmentations and `declare global` blocks in modules. */

package/dist/api/compiler/ast.js

@@ -6641,6 +6641,8 @@ export class SourceFile extends Node {
     identifierCount;
     nodeCount;
     textCount;
+    /** The API's binary encoding of this file, when an API server keeps it (`keptEncodingOf`). */
+    apiEncoding;
     /** Module specifiers of imports, exports, `require` calls and `import()` types, in source order. */
     imports;
     /** Names of `declare module "x"` augmentations and `declare global` blocks in modules. */
@@ -6699,6 +6701,7 @@ export class SourceFile extends Node {
         this.identifierCount = 0;
         this.nodeCount = 0;
         this.textCount = 0;
+        this.apiEncoding = undefined;
         this.imports = [];
         this.moduleAugmentations = emptyNodes;
         this.ambientModuleNames = emptyStrings;

package/dist/api/compiler/checker-calls.js

@@ -709,7 +709,11 @@ export function reorderCandidates(c, signatures, callChainFlags) {
             spliceIndex = index;
         if (callChainFlags !== 0)
             signature = getOptionalCallSignature(c, signature, callChainFlags);
-        result.splice(spliceIndex, 0, signature);
+        // Most signatures go at the end, where a push is cheaper than an inserting splice.
+        if (spliceIndex === result.length)
+            result.push(signature);
+        else
+            result.splice(spliceIndex, 0, signature);
     }
     return result;
 }

package/dist/api/compiler/checker-grammar.js

@@ -2255,7 +2255,8 @@ function getEmitSyntaxOfImportOrExport(g) {
     return ModuleKind.None;
 }
 function checkGrammarObjectLiteralExpression(g, node, inDestructuring) {
-    const seen = new Map();
+    // An object literal with one property can't repeat a name, so it needs no table of names.
+    const seen = node.properties.nodes.length > 1 ? new Map() : undefined;
     for (const property of node.properties.nodes) {
         if (property.kind === 305 /* SyntaxKind.SpreadAssignment */) {
             if (inDestructuring) {
@@ -2313,7 +2314,7 @@ function checkGrammarObjectLiteralExpression(g, node, inDestructuring) {
         if (inDestructuring)
             continue;
         const effectiveName = getEffectivePropertyNameForPropertyNameNode(g.c, name);
-        if (effectiveName === undefined)
+        if (effectiveName === undefined || seen === undefined)
             continue;
         const existingKind = seen.get(effectiveName);
         if (existingKind === undefined) {

package/dist/api/compiler/checker-inference.js

@@ -450,8 +450,14 @@ class InferenceState {
                         index = 0;
                         while (index < inference.candidateDepths.length && inference.candidateDepths[index] >= this.depth)
                             index++;
-                        inference.candidates.splice(index, 0, candidate);
-                        inference.candidateDepths.splice(index, 0, this.depth);
+                        if (index === inference.candidates.length) {
+                            inference.candidates.push(candidate);
+                            inference.candidateDepths.push(this.depth);
+                        }
+                        else {
+                            inference.candidates.splice(index, 0, candidate);
+                            inference.candidateDepths.splice(index, 0, this.depth);
+                        }
                         clearCachedInferences(this.inferences);
                     }
                 }

package/dist/api/compiler/checker-members.js

@@ -702,8 +702,12 @@ export function resolveDeclaredMembers(c, t) {
         const members = getMembersOfSymbol(c, t.symbol);
         declared.declaredMembersResolved = true;
         declared.declaredMembers = members;
-        declared.declaredCallSignatures = getSignaturesOfSymbol(c, members.get("\uFFFEcall" /* InternalSymbolName.Call */));
-        declared.declaredConstructSignatures = getSignaturesOfSymbol(c, members.get("\uFFFEnew" /* InternalSymbolName.New */));
+        // Most interfaces declare neither, and share one empty list.
+        const call = members.get("\uFFFEcall" /* InternalSymbolName.Call */);
+        const construct = members.get("\uFFFEnew" /* InternalSymbolName.New */);
+        declared.declaredCallSignatures = call !== undefined ? getSignaturesOfSymbol(c, call) : emptySignatures;
+        declared.declaredConstructSignatures =
+            construct !== undefined ? getSignaturesOfSymbol(c, construct) : emptySignatures;
         declared.declaredIndexInfos = getIndexInfosOfSymbol(c, t.symbol);
     }
     return declared;
@@ -1264,7 +1268,8 @@ export function getPropertyOfTypeEx(c, t, name, skipObjectFunctionPropertyAugmen
     if (!isOwnReducedApparentType(t))
         t = getReducedApparentTypeWorker(c, t);
     if ((t.flags & 1048576 /* TypeFlags.Object */) !== 0) {
-        const resolved = resolveStructuredTypeMembers(c, t);
+        // The first test of resolveStructuredTypeMembers, here where most lookups find the members resolved.
+        const resolved = (t.objectFlags & 2097152 /* ObjectFlags.MembersResolved */) !== 0 ? t : resolveStructuredTypeMembers(c, t);
         const symbol = getResolvedMember(resolved, name);
         if (symbol !== undefined && includeTypeOnlyMembers)
             return symbol;

package/dist/api/compiler/checker-source-file.d.ts

@@ -5,6 +5,18 @@ import type { Checker } from './checker.js';
  * identifiers, which need the whole file checked first.
  */
 export declare function checkSourceFile(c: Checker, file: SourceFile, checkUnused?: boolean): void;
+/**
+ * Checks the statements `start` to `end` of the declaration file `file`, one of the ranges that several
+ * checkers check it in (parallel-check.ts), and returns whether the checker then has diagnostics in the
+ * file. The range ending the file also runs the checks of the whole file. The file is not marked checked.
+ *
+ * When no range finds a diagnostic in the file, checking it whole would find none either: each statement
+ * is checked by the checker of its range. Otherwise the file is checked whole (`startParallelCheck`): the
+ * diagnostics of the ranges can differ from the file's, where they depend on the order the file's
+ * declarations are resolved in. A union type prints its members in the order the checker created them,
+ * and a check that a symbol's first declaration runs reports on all its declarations.
+ */
+export declare function checkSourceFileRange(c: Checker, file: SourceFile, start: number, end: number): boolean;
 /** Checks a statement, declaration, class member or type node. */
 export declare function checkSourceElement(c: Checker, node: Node | undefined): void;
 /** Resolves the `@link` names of a node's JSDoc, which marks what they name referenced. */

package/dist/api/compiler/checker-source-file.js

@@ -81,6 +81,41 @@ function checkSourceFileWorker(c, file) {
     links.typeChecked = true;
     links.deferredNodes = undefined;
 }
+/**
+ * Checks the statements `start` to `end` of the declaration file `file`, one of the ranges that several
+ * checkers check it in (parallel-check.ts), and returns whether the checker then has diagnostics in the
+ * file. The range ending the file also runs the checks of the whole file. The file is not marked checked.
+ *
+ * When no range finds a diagnostic in the file, checking it whole would find none either: each statement
+ * is checked by the checker of its range. Otherwise the file is checked whole (`startParallelCheck`): the
+ * diagnostics of the ranges can differ from the file's, where they depend on the order the file's
+ * declarations are resolved in. A union type prints its members in the order the checker created them,
+ * and a check that a symbol's first declaration runs reports on all its declarations.
+ */
+export function checkSourceFileRange(c, file, start, end) {
+    const statements = getStatements(file).nodes;
+    c.fileBeingChecked = file;
+    c.saveDeferredDiagnostics = true;
+    for (let i = start; i < end; i++)
+        checkSourceElement(c, statements[i]);
+    checkDeferredNodes(c, file);
+    const whole = end === statements.length;
+    if (whole && isExternalOrCommonJSModule(file))
+        checkExternalModuleExports(c, file);
+    c.renamedBindingElementsInTypes.length = 0;
+    if (whole) {
+        checkGrammarSourceFile(c, file);
+        checkDeferredNodes(c, file);
+        checkPendingExternalEmitHelpers(c, file);
+    }
+    c.fileBeingChecked = undefined;
+    c.saveDeferredDiagnostics = false;
+    produceDeferredIterationErrors(c);
+    produceDeferredCollisionChecks(c);
+    // Deferred nodes of a later range are queued again (checkNodeDeferred).
+    c.nodeLinks(file).deferredNodes = undefined;
+    return c.diagnostics.forFile(file.fileName).length > 0;
+}
 /** Checks a statement, declaration, class member or type node. */
 export function checkSourceElement(c, node) {
     if (node === undefined)

package/dist/api/compiler/checker-symbols.js

@@ -697,6 +697,7 @@ function setMergedSymbol(c, id, target) {
         c.mergedSymbolChanges.set(c.mergedSymbols, id, target);
     else
         c.mergedSymbols.set(id, target);
+    c.mergedSymbolIds.add(id);
 }
 /** Merges script locals into globals; ambient modules and augmentations wait for global types. */
 export function initializeGlobals(c) {
@@ -1033,7 +1034,7 @@ function recordMergedSymbol(c, target, source) {
 }
 export function getMergedSymbol(c, symbol) {
     const id = symbol.id;
-    if (id !== 0) {
+    if (id !== 0 && c.mergedSymbolIds.has(id)) {
         const merged = c.mergedSymbols.get(id);
         if (merged !== undefined)
             return merged;

package/dist/api/compiler/checker-type-factory.js

@@ -989,7 +989,10 @@ export function insertType(c, types, t) {
     const index = binarySearchTypes(c, types, t);
     if (index >= 0)
         return false;
-    types.splice(~index, 0, t);
+    if (~index === types.length)
+        types.push(t);
+    else
+        types.splice(~index, 0, t);
     return true;
 }
 // ---- Iterating unions
@@ -1198,7 +1201,10 @@ function insertTypeNearLast(c, set, t) {
         else
             high = middle - 1;
     }
-    types.splice(low, 0, t);
+    if (low === types.length)
+        types.push(t);
+    else
+        types.splice(low, 0, t);
     set.last = low;
 }
 function getUnionTypeWorker(c, types, unionReduction, alias, origin) {

package/dist/api/compiler/checker.d.ts

@@ -1,7 +1,7 @@
 import type { DeferredCollisionCheck } from './checker-generated-code.js';
 import type { EmitHelperFileLinks } from './checker-emit-helpers.js';
 import type { Node, PatternAmbientModule, SourceFile } from './ast.js';
-import { CompactSymbolLinkTable, IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
+import { CompactSymbolLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.js';
 import { Diagnostic, type DiagnosticMessage, Diagnostics } from './diagnostics.js';
 import { type CompilerOptions, ModuleKind, ScriptTarget } from './options.js';
 import { CheckFlags, Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
@@ -71,6 +71,10 @@ declare class DiagnosticCollection {
     /** An already reported diagnostic equal to `diagnostic`, if any. */
     lookup(diagnostic: Diagnostic): Diagnostic | undefined;
     globals(): Diagnostic[];
+    /** The global diagnostics `withoutNewGlobals` removed. */
+    removedGlobals: number;
+    /** Runs `run`, then removes the global diagnostics it added. */
+    withoutNewGlobals<T>(run: () => T): T;
     /** Records the diagnostics added from now on. */
     startLog(): void;
     /** The diagnostics added since `startLog`, in order; stops recording. */
@@ -204,6 +208,11 @@ export declare class Checker implements TypeChecking {
     readonly resolvedSignatures: SparseLinkTable<Signature>;
     /** Merged symbols, indexed by the id of the symbol merged into them. */
     readonly mergedSymbols: Map<number, Symbol>;
+    /**
+     * The ids that `mergedSymbols` has, or had: most symbols are merged into none, and `getMergedSymbol`
+     * finds that here without probing the map.
+     */
+    readonly mergedSymbolIds: PagedIdSet;
     /** Globals merged from the default libraries, shared with other checkers. */
     libGlobals: LibGlobals | undefined;
     /** The program's globals and module augmentations as another checker merged them, shared with it. */
@@ -486,6 +495,13 @@ export declare class Checker implements TypeChecking {
     getSuggestionDiagnostics(file: SourceFile): Diagnostic[];
     /** Diagnostics without a file, such as missing global types. */
     getGlobalDiagnostics(): Diagnostic[];
+    /**
+     * Runs `run` (such as emitting declarations), then forgets the global diagnostics it reported:
+     * the program collects global diagnostics before it emits.
+     */
+    withoutGlobalDiagnostics<T>(run: () => T): T;
+    /** The global diagnostics `withoutGlobalDiagnostics` forgot so far. */
+    forgottenGlobalDiagnostics(): number;
     /** The rarely used links of `symbol`, created on first use. */
     symbolLinks(symbol: Symbol): SymbolLinks;
     /** The links of `symbol` if it has any, without creating them. */

package/dist/api/compiler/checker.js

@@ -1,5 +1,5 @@
 import { sideOf } from './side-state.js';
-import { CompactSymbolLinkTable, IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
+import { CompactSymbolLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.js';
 import { getErrorRangeForNode, getSourceFileOfNode } from './binder-utilities.js';
 import { Diagnostic, compareDiagnostics } from './diagnostics.js';
 import { ModuleKind, ScriptTarget, getEmitScriptTarget, getIsolatedModules, getStrictOptionValue, shouldPreserveConstEnums, } from './options.js';
@@ -137,6 +137,35 @@ class DiagnosticCollection {
         }
         return this.global.slice();
     }
+    /** The global diagnostics `withoutNewGlobals` removed. */
+    removedGlobals = 0;
+    /** Runs `run`, then removes the global diagnostics it added. */
+    withoutNewGlobals(run) {
+        const outer = this.log;
+        const added = [];
+        this.log = added;
+        try {
+            return run();
+        }
+        finally {
+            this.log = outer;
+            if (outer !== undefined)
+                for (const d of added)
+                    outer.push(d);
+            const globals = new Set();
+            for (const d of added)
+                if (d.file === undefined)
+                    globals.add(d);
+            if (globals.size > 0) {
+                this.removedGlobals += globals.size;
+                let kept = 0;
+                for (const d of this.global)
+                    if (!globals.has(d))
+                        this.global[kept++] = d;
+                this.global.length = kept;
+            }
+        }
+    }
     /** Records the diagnostics added from now on. */
     startLog() {
         this.log = [];
@@ -284,6 +313,11 @@ export class Checker {
     resolvedSignatures = new SparseLinkTable();
     /** Merged symbols, indexed by the id of the symbol merged into them. */
     mergedSymbols;
+    /**
+     * The ids that `mergedSymbols` has, or had: most symbols are merged into none, and `getMergedSymbol`
+     * finds that here without probing the map.
+     */
+    mergedSymbolIds = new PagedIdSet();
     /** Globals merged from the default libraries, shared with other checkers. */
     libGlobals;
     /** The program's globals and module augmentations as another checker merged them, shared with it. */
@@ -616,6 +650,8 @@ export class Checker {
             this.globals = libs.copyGlobals();
             this.mergedSymbols = libs.copyMergedSymbols();
         }
+        for (const id of this.mergedSymbols.keys())
+            this.mergedSymbolIds.add(id);
         this.globalThisSymbol = this.newSymbol(1536 /* SymbolFlags.Module */, 'globalThis');
         this.globalThisSymbol.checkFlags = 8 /* CheckFlags.Readonly */;
         this.globalThisSymbol.exports = this.globals;
@@ -773,6 +809,17 @@ export class Checker {
     getGlobalDiagnostics() {
         return this.diagnostics.globals();
     }
+    /**
+     * Runs `run` (such as emitting declarations), then forgets the global diagnostics it reported:
+     * the program collects global diagnostics before it emits.
+     */
+    withoutGlobalDiagnostics(run) {
+        return this.diagnostics.withoutNewGlobals(run);
+    }
+    /** The global diagnostics `withoutGlobalDiagnostics` forgot so far. */
+    forgottenGlobalDiagnostics() {
+        return this.diagnostics.removedGlobals;
+    }
     // ---- Links
     /** The rarely used links of `symbol`, created on first use. */
     symbolLinks(symbol) {
@@ -890,6 +937,7 @@ export function disposeChecker(c) {
         c.mergedSymbols.clear();
         c.globals.clear();
     }
+    c.mergedSymbolIds.clear();
     c.sharedSymbolCopies.clear();
     c.memberPositionsInLists.clear();
     c.memberNamesOfLists.clear();

package/dist/api/compiler/compile-program.d.ts

@@ -61,6 +61,28 @@ export declare class EmitIndexes {
     readonly declarations: DeclarationGlobals | undefined;
     constructor(program: Program);
 }
+/**
+ * The JavaScript emit of a program's files without a checker, for emit threads (parallel-emit.ts).
+ * JavaScript emit asks the checker only how decorator metadata serializes a type
+ * (`CheckerEmitResolver`): with `kinds`, the answers the main thread's checker gave
+ * (`recordMetadataKinds`), else files with decorator metadata are emitted by a `ProgramEmitter`.
+ */
+export declare class JavaScriptEmitter {
+    private readonly host;
+    private readonly recorded;
+    constructor(program: Program, kinds?: readonly number[]);
+    /**
+     * Emits `file`, or returns undefined if its decorator metadata asked for a kind that wasn't recorded: what
+     * was written is then not the file's emit, and it must be emitted with the checker.
+     */
+    emit(file: SourceFile, writer: OutputWriter): EmitResult | undefined;
+}
+/**
+ * The serialization kinds of decorator metadata that the checker of `checked` gives the type references of
+ * `files`, in the order JavaScript emit asks for them: the type name's node id, the location's node id (-1 for
+ * none) and the kind, for each. Only the decorator metadata transform runs, as the first transform of emit.
+ */
+export declare function recordMetadataKinds(checked: CheckedProgram, files: readonly SourceFile[]): number[];
 /** A checked program and the emit of its files. */
 export declare class ProgramEmitter {
     readonly checked: CheckedProgram;
@@ -110,9 +132,11 @@ export declare class PlainProgram extends CompilerProgram {
 export declare function handleNoEmitOnError(program: CompilerProgram): EmitResult | undefined;
 /**
  * Config and syntax errors; without syntax errors, program, global and semantic errors too, and
- * declaration errors under `noEmit` (or `withDeclarationDiagnostics`).
+ * declaration errors under `noEmit` (or `withDeclarationDiagnostics`). With `declarationsLater`, the
+ * declaration errors are left to `program.emit`, which reports them under `noEmit` (without
+ * `noEmitOnError`) whether or not other errors were found.
  */
-export declare function getDiagnosticsOfProgram(program: CompilerProgram, withDeclarationDiagnostics: boolean): Diagnostic[];
+export declare function getDiagnosticsOfProgram(program: CompilerProgram, withDeclarationDiagnostics: boolean, declarationsLater?: boolean): Diagnostic[];
 /** Combines emit results in order. */
 export declare function combineEmitResults(results: readonly EmitResult[]): EmitResult;
 export { CheckedProgram };

package/dist/api/compiler/compile-program.js

@@ -6,6 +6,10 @@ import { CheckerDeclarationEmitResolver, CheckerEmitResolver } from './checker-e
 import { getEmitModuleFormatOfFile } from './program-utilities.js';
 import { DeclarationGlobals, SyntacticDeclarationEmitResolver } from './transformers/declarations-syntactic.js';
 import { mark } from './timeline.js';
+import { DecoratorMetadata } from './transformers/decorator-metadata.js';
+import { SyntaxFacts } from './transformers/syntax-facts.js';
+import { EmitContext } from './printer/emit-context.js';
+import { SyntacticEmitResolver } from './transformers/emit-resolver.js';
 import { ModuleFormatHost } from './transformers/module.js';
 import { ModuleLookup, ReferenceResolver } from './transformers/reference-resolver.js';
 /** Where emit writes files. */
@@ -165,6 +169,82 @@ export class EmitIndexes {
             : undefined;
     }
 }
+/**
+ * The JavaScript emit of a program's files without a checker, for emit threads (parallel-emit.ts).
+ * JavaScript emit asks the checker only how decorator metadata serializes a type
+ * (`CheckerEmitResolver`): with `kinds`, the answers the main thread's checker gave
+ * (`recordMetadataKinds`), else files with decorator metadata are emitted by a `ProgramEmitter`.
+ */
+export class JavaScriptEmitter {
+    host;
+    recorded;
+    constructor(program, kinds = []) {
+        const options = program.options;
+        const indexes = program.emitIndexes;
+        const references = new ReferenceResolver(options, program.getSourceFiles(), new ProgramModules(program), indexes !== undefined ? indexes.globals : undefined);
+        this.recorded = kinds.length > 0 ? new RecordedKindsEmitResolver(options, references, kinds) : undefined;
+        this.host = new ProgramEmitHost(program, this.recorded ?? new SyntacticEmitResolver(options, references));
+    }
+    /**
+     * Emits `file`, or returns undefined if its decorator metadata asked for a kind that wasn't recorded: what
+     * was written is then not the file's emit, and it must be emitted with the checker.
+     */
+    emit(file, writer) {
+        const host = this.host;
+        const recorded = this.recorded;
+        if (recorded !== undefined)
+            recorded.missed = false;
+        host.writer = writer;
+        const result = emitFiles(host, [file], 1 /* EmitOnly.Js */);
+        host.writer = undefined;
+        return recorded !== undefined && recorded.missed ? undefined : result;
+    }
+}
+/**
+ * The serialization kinds of decorator metadata that the checker of `checked` gives the type references of
+ * `files`, in the order JavaScript emit asks for them: the type name's node id, the location's node id (-1 for
+ * none) and the kind, for each. Only the decorator metadata transform runs, as the first transform of emit.
+ */
+export function recordMetadataKinds(checked, files) {
+    const program = checked.program;
+    const options = program.options;
+    const indexes = program.emitIndexes;
+    const references = new ReferenceResolver(options, program.getSourceFiles(), new ProgramModules(program), indexes !== undefined ? indexes.globals : undefined);
+    const resolver = new RecordingEmitResolver(options, references, checked.checker);
+    for (const file of files)
+        new DecoratorMetadata(new EmitContext(), options, resolver, new SyntaxFacts()).transformSourceFile(file);
+    return resolver.kinds;
+}
+/** A `CheckerEmitResolver` that records the serialization kinds it gives (`recordMetadataKinds`). */
+class RecordingEmitResolver extends CheckerEmitResolver {
+    kinds = [];
+    getTypeReferenceSerializationKind(typeName, location) {
+        const kind = super.getTypeReferenceSerializationKind(typeName, location);
+        this.kinds.push(typeName.id, location === undefined ? -1 : location.id, kind);
+        return kind;
+    }
+}
+/** Answers serialization kinds from those recorded on the main thread; `missed` once one wasn't. */
+class RecordedKindsEmitResolver extends SyntacticEmitResolver {
+    kinds;
+    /** The kind and location of each type name, by the type name's node id. */
+    byName = new Map();
+    missed = false;
+    constructor(options, referenceResolver, kinds) {
+        super(options, referenceResolver);
+        this.kinds = kinds;
+        for (let i = 0; i < kinds.length; i += 3)
+            if (!this.byName.has(kinds[i]))
+                this.byName.set(kinds[i], i);
+    }
+    getTypeReferenceSerializationKind(typeName, location) {
+        const at = this.byName.get(typeName.id);
+        if (at !== undefined && this.kinds[at + 1] === (location === undefined ? -1 : location.id))
+            return this.kinds[at + 2];
+        this.missed = true;
+        return super.getTypeReferenceSerializationKind(typeName, location);
+    }
+}
 /** A checked program and the emit of its files. */
 export class ProgramEmitter {
     checked;
@@ -291,14 +371,24 @@ export class PlainProgram extends CompilerProgram {
         const program = this.program;
         const files = program.getSourceFiles();
         const parallel = this.checked.emittedInParallel;
-        // Checker threads emitted the files they checked (parallel-check.ts); the others are emitted here, in order.
+        // Checker threads emitted the files they checked (parallel-check.ts), or emit threads their JavaScript
+        // (parallel-emit.ts); the rest is emitted here, in order.
         const result = parallel === undefined
             ? this.emitter.emit(files, 0 /* EmitOnly.All */, writer)
             : combineEmitResults(files.map((file, i) => {
                 const emitted = parallel[i];
-                return emitted !== undefined
-                    ? writeHeldOutputs(emitted, writer)
-                    : this.emitter.emit([file], 0 /* EmitOnly.All */, writer);
+                // The declaration thread emitted the declarations of the files it could (parallel-emit.ts).
+                const ahead = this.checked.declarationsEmittedAhead;
+                const declarations = () => ahead?.[i] ?? this.emitter.emit([file], 2 /* EmitOnly.Dts */, writer);
+                if (emitted === undefined)
+                    return ahead !== undefined
+                        ? combineEmitResults([this.emitter.emit([file], 1 /* EmitOnly.Js */, writer), declarations()])
+                        : this.emitter.emit([file], 0 /* EmitOnly.All */, writer);
+                const written = writeHeldOutputs(emitted, writer);
+                // Emit threads emit JavaScript only.
+                if (!this.checked.javaScriptEmittedOnThreads || !getEmitDeclarations(options))
+                    return written;
+                return combineEmitResults([written, declarations()]);
             }));
         if (options.noEmit === true) {
             // Emit is skipped only for files that would have been emitted.
@@ -326,9 +416,11 @@ export function handleNoEmitOnError(program) {
 }
 /**
  * Config and syntax errors; without syntax errors, program, global and semantic errors too, and
- * declaration errors under `noEmit` (or `withDeclarationDiagnostics`).
+ * declaration errors under `noEmit` (or `withDeclarationDiagnostics`). With `declarationsLater`, the
+ * declaration errors are left to `program.emit`, which reports them under `noEmit` (without
+ * `noEmitOnError`) whether or not other errors were found.
  */
-export function getDiagnosticsOfProgram(program, withDeclarationDiagnostics) {
+export function getDiagnosticsOfProgram(program, withDeclarationDiagnostics, declarationsLater = false) {
     const result = [...program.getConfigFileParsingDiagnostics()];
     const configCount = result.length;
     for (const d of program.getSyntacticDiagnostics())
@@ -356,7 +448,8 @@ export function getDiagnosticsOfProgram(program, withDeclarationDiagnostics) {
             result.push(d);
         mark('semantic diagnostics');
     }
-    if ((withDeclarationDiagnostics || options.noEmit === true) &&
+    if (!declarationsLater &&
+        (withDeclarationDiagnostics || options.noEmit === true) &&
         getEmitDeclarations(options) &&
         result.length === configCount) {
         for (const d of program.getDeclarationDiagnostics())

package/dist/api/compiler/diagnostics.d.ts

@@ -109,6 +109,11 @@ export declare class Diagnostic {
     readonly reportsDeprecated: boolean;
     skippedOnNoEmit: boolean;
     repopulateInfo: RepopulateInfo | undefined;
+    /**
+     * What `formatDiagnostic` gives for this diagnostic in `formattedReports.format`, where the checker
+     * thread that found it formatted it (`packResult`); `''` otherwise.
+     */
+    formatted: string;
     constructor(file: DiagnosticFile | undefined, pos: number, end: number, message: DiagnosticMessage, args?: readonly string[]);
     localize(locale: Locale): string;
     addMessageChain(chain: Diagnostic | undefined): Diagnostic;
@@ -132,6 +137,14 @@ export declare function chainDiagnostic(chain: Diagnostic | undefined, message:
 export declare function compareCodePoints(a: string, b: string): number;
 /** The order tsc reports diagnostics in: by file, position, code, arguments, then elaboration. */
 export declare function compareDiagnostics(a: Diagnostic, b: Diagnostic): number;
+/**
+ * `diagnostics` in the order of `compareDiagnostics`, equal ones in their order in `diagnostics`. File
+ * names are compared once per pair of files rather than once per pair of diagnostics: the distinct
+ * files are sorted by name, and each diagnostic sorts by its file's place in that order, then by the
+ * rest of `compareDiagnostics`. A program's diagnostics come a file at a time, so the files are found
+ * from the runs of one file.
+ */
+export declare function sortDiagnostics(diagnostics: readonly Diagnostic[]): Diagnostic[];
 /** Whether two diagnostics report the same thing, ignoring related information. */
 export declare function equalDiagnosticsNoRelatedInfo(a: Diagnostic, b: Diagnostic): boolean;
 export declare function equalDiagnostics(a: Diagnostic, b: Diagnostic): boolean;
@@ -145,6 +158,15 @@ export interface DiagnosticFormatOptions {
 export declare function flattenDiagnosticMessage(diagnostic: Diagnostic, newLine: string, locale: Locale): string;
 /** `file(line,col): error TS1005: message`, as tsc prints without `--pretty`. */
 export declare function formatDiagnostic(diagnostic: Diagnostic, options: DiagnosticFormatOptions): string;
+/**
+ * The plain format the main thread reports a compilation's diagnostics in (`DiagnosticReporter.plainFormat`),
+ * which its checker threads receive a copy of and format the diagnostics they send back in
+ * (`Diagnostic.formatted`). Unset where diagnostics are reported with color and context, or not at all.
+ */
+export declare class FormattedReports {
+    format: DiagnosticFormatOptions | undefined;
+}
+export declare const formattedReports: FormattedReports;
 /** `formatDiagnostic` of each diagnostic. */
 export declare function formatDiagnostics(diagnostics: readonly Diagnostic[], options: DiagnosticFormatOptions): string;
 /** The colored form with source snippets, as tsc prints with `--pretty`. */