tsc-ts 0.0.10 → 0.1.0

package/src/compiler/node-builder.ts

@@ -128,11 +128,13 @@ import {
   getBaseTypeVariableOfClass,
   getNonMissingTypeOfSymbol,
   getOptionalType,
+  getTypeForVariableLikeDeclaration,
   getTypeOfSymbol,
   getWriteTypeOfSymbol,
   isReadonlySymbol,
   removeMissingType,
 } from './checker-symbol-types.js';
+import { isVariableLike } from './checker-declarations.js';
 import {
   getFirstIdentifier,
   getGlobalTypeAliasSymbol,
@@ -143,15 +145,18 @@ import {
 } from './checker-symbols.js';
 import {
   createArrayType,
+  createTypeReference,
   filterType,
   getIntersectionType,
   getTypeArguments,
   getTypeReferenceArity,
   getWidenedLiteralType,
+  isArrayOrTupleType,
   isErrorType,
   isTupleType,
   inDeclarationOrder,
   newAnonymousType,
+  typeListKey,
 } from './checker-type-factory.js';
 import { getTypeFromTypeNode } from './checker-type-nodes.js';
 import {
@@ -180,6 +185,7 @@ import {
   type LiteralType,
   type MappedType,
   ObjectFlags,
+  type ReverseMappedType,
   Signature,
   SignatureFlags,
   SignatureKind,
@@ -199,6 +205,7 @@ import {
   type UnionOrIntersectionType,
   newTypeMapper,
   prependTypeMapping,
+  getNonDistributedTypeParameter,
 } from './checker-types.js';
 import {
   hasLateBindableIndexSignature,
@@ -289,6 +296,20 @@ export class TrackedSymbol {
   }
 }
 
+/**
+ * The caches of tsgo's node builder that outlive one request: an emit resolver keeps one node builder, so the types
+ * serialized for one declaration are reused, as copies without positions, by the next ones in the file.
+ */
+export class NodeBuilderCaches {
+  readonly serializedTypes: Map<number, Map<string, SerializedTypeEntry>>;
+  readonly fakeScopes: Map<Node, string>;
+
+  constructor() {
+    this.serializedTypes = new Map<number, Map<string, SerializedTypeEntry>>();
+    this.fakeScopes = new Map<Node, string>();
+  }
+}
+
 class SerializedTypeEntry {
   readonly node: Node;
   readonly truncating: boolean;
@@ -463,6 +484,8 @@ export class NodeBuilder {
   pseudo: PseudoChecker | undefined = undefined;
   /** Set for declaration emit, which writes unions in an order that doesn't depend on the checker's history. */
   declarationOrder = false;
+  /** When set, the symbol each identifier naming a symbol refers to. */
+  idToSymbol: Map<Node, Symbol> | undefined = undefined;
 
   constructor(
     c: Checker,
@@ -532,6 +555,12 @@ export class NodeBuilder {
     return (this.fakeScopesStore ??= new Map<Node, string>());
   }
 
+  /** Uses `caches` for the types this builder serializes and its fake scopes, sharing them with other builders. */
+  useCaches(caches: NodeBuilderCaches): void {
+    this.serializedTypesStore = caches.serializedTypes;
+    this.fakeScopesStore = caches.fakeScopes;
+  }
+
   /** `result`, or undefined if serialization failed. */
   finish<T>(result: T | undefined): T | undefined {
     if (this.truncating && (this.flags & NodeBuilderFlags.NoTruncation) !== 0) this.tracker.reportTruncationError();
@@ -581,6 +610,13 @@ export class NodeBuilder {
     return this.factory.createIdentifier(text);
   }
 
+  /** An identifier naming `symbol`, recorded in `idToSymbol`. */
+  symbolIdentifier(text: string, symbol: Symbol): Identifier {
+    const identifier = this.factory.createIdentifier(text);
+    this.idToSymbol?.set(identifier, symbol);
+    return identifier;
+  }
+
   stringLiteral(text: string, isSingleQuote: boolean): StringLiteral {
     const flags =
       isSingleQuote || (this.flags & NodeBuilderFlags.UseSingleQuotesForStringLiteralType) !== 0
@@ -868,7 +904,8 @@ export class NodeBuilder {
       this.approximateLength += 3;
       return this.keyword(SyntaxKind.AnyKeyword);
     }
-    let t = type;
+    // A distributed type parameter prints as the type parameter it was made from.
+    let t = getNonDistributedTypeParameter(type);
     if ((this.flags & NodeBuilderFlags.NoTypeReduction) === 0) t = getReducedType(c, t);
     const flags = t.flags;
     if ((flags & TypeFlags.Any) !== 0) {
@@ -1033,7 +1070,9 @@ export class NodeBuilder {
     }
     const objectFlags = t.objectFlags;
     if ((objectFlags & ObjectFlags.Reference) !== 0) {
-      if ((t as TypeReference).node !== undefined) return this.visitAndTransformType(t, TransformKind.TypeReference);
+      // Arrays and tuples are checked for cycles, as their element types can refer back to them.
+      if (isArrayOrTupleType(c, t) || (t as TypeReference).node !== undefined)
+        return this.visitAndTransformType(t, TransformKind.TypeReference);
       return this.typeReferenceToTypeNode(t as TypeReference);
     }
     if ((flags & TypeFlags.TypeParameter) !== 0 || (objectFlags & ObjectFlags.ClassOrInterface) !== 0) {
@@ -1142,19 +1181,31 @@ export class NodeBuilder {
 
   /** Writes `t` with `transform`, eliding its circular references; cached per enclosing declaration. */
   visitAndTransformType(t: Type, transform: TransformKind): Node | undefined {
-    const typeId = t.id;
+    if (this.checkTruncationLength()) return this.createElidedInformationPlaceholder();
+    const c = this.c;
+    let typeId = t.id;
+    const isArrayOrTuple = isArrayOrTupleType(c, t);
+    // A deferred reference and the regular reference to the same array or tuple are one cycle identity.
+    if (isArrayOrTuple) typeId = createTypeReference(c, (t as TypeReference).target!, getTypeArguments(c, t)).id;
+    if (this.visitedTypes.has(typeId)) return this.createCyclicStructurePlaceholder();
     const isConstructorObject =
       (t.objectFlags & ObjectFlags.Anonymous) !== 0 &&
       t.symbol !== undefined &&
       (t.symbol.flags & SymbolFlags.Class) !== 0;
     // Instantiations of one anonymous type share a symbol, so tracking symbols rather than
-    // types catches circular references through them.
+    // types catches circular references through them. Nesting of arrays and tuples, which share the Array
+    // symbol or a tuple target, is not bounded by it. A deferred array or tuple reference is bounded by its
+    // node, which stops a recursive alias whose type arguments grow at each level (`type R<T> = R<T[]>[]`).
     let id: string | undefined = undefined;
-    if ((t.objectFlags & ObjectFlags.Reference) !== 0 && (t as TypeReference).node !== undefined)
+    if (isArrayOrTuple) {
+      const node = (t as TypeReference).node;
+      if (node !== undefined) id = 'n' + getNodeId(node);
+    } else if ((t.objectFlags & ObjectFlags.Reference) !== 0 && (t as TypeReference).node !== undefined)
       id = 'n' + getNodeId((t as TypeReference).node!);
     else if ((t.flags & TypeFlags.Conditional) !== 0) id = 'n' + getNodeId((t as ConditionalType).root.node);
     else if (t.symbol !== undefined) id = (isConstructorObject ? 'c' : 's') + getSymbolId(t.symbol);
-    const key = typeId + ':' + this.flags + ':' + this.internalFlags;
+    let key = typeId + ':' + this.flags + ':' + this.internalFlags;
+    if (this.inferTypeParameters.length !== 0) key += ':' + typeListKey(this.inferTypeParameters);
     if (this.enclosingDeclaration !== undefined) {
       const cached = this.serializedTypes.get(getNodeId(this.enclosingDeclaration))?.get(key);
       if (cached !== undefined) {
@@ -1165,10 +1216,27 @@ export class NodeBuilder {
         return this.deepCloneNode(cached.node);
       }
     }
+    // Growing type arguments can keep a reverse mapped type from repeating, so its expansion is also bounded by
+    // its mapped type's declaration.
+    let origin: string | undefined = undefined;
+    let originDepth = 0;
+    if ((t.objectFlags & ObjectFlags.ReverseMapped) !== 0) {
+      origin = 'n' + getNodeId(((t as ReverseMappedType).mappedType as MappedType).declaration!);
+      originDepth = this.symbolDepth.get(origin) ?? 0;
+      if (originDepth >= 100) {
+        this.truncating = true;
+        return this.createElidedInformationPlaceholder();
+      }
+      this.symbolDepth.set(origin, originDepth + 1);
+    }
     let depth = 0;
     if (id !== undefined) {
       depth = this.symbolDepth.get(id) ?? 0;
-      if (depth > 10) return this.createElidedInformationPlaceholder();
+      if (depth > 10) {
+        this.truncating = true;
+        if (origin !== undefined) this.symbolDepth.set(origin, originDepth);
+        return this.createElidedInformationPlaceholder();
+      }
       this.symbolDepth.set(id, depth + 1);
     }
     this.visitedTypes.add(typeId);
@@ -1207,24 +1275,28 @@ export class NodeBuilder {
     }
     this.visitedTypes.delete(typeId);
     if (id !== undefined) this.symbolDepth.set(id, depth);
+    if (origin !== undefined) this.symbolDepth.set(origin, originDepth);
     this.trackedSymbols = prevTrackedSymbols;
     return result;
   }
 
   private typeToTypeNodeOrCircularityElision(t: Type): Node | undefined {
     if ((t.flags & TypeFlags.Union) !== 0) {
-      if (this.visitedTypes.has(t.id)) {
-        if ((this.flags & NodeBuilderFlags.AllowAnonymousIdentifier) === 0) {
-          this.encounteredError = true;
-          this.tracker.reportCyclicStructureError();
-        }
-        return this.createElidedInformationPlaceholder();
-      }
+      if (this.visitedTypes.has(t.id)) return this.createCyclicStructurePlaceholder();
       return this.visitAndTransformType(t, TransformKind.Type);
     }
     return this.typeToTypeNode(t);
   }
 
+  /** The placeholder for a circular reference; outside of display, it is an error. */
+  private createCyclicStructurePlaceholder(): Node {
+    if ((this.flags & NodeBuilderFlags.AllowAnonymousIdentifier) === 0) {
+      this.encounteredError = true;
+      this.tracker.reportCyclicStructureError();
+    }
+    return this.createElidedInformationPlaceholder();
+  }
+
   private conditionalTypeToTypeNode(t: ConditionalType): Node | undefined {
     const c = this.c;
     if (this.checkTruncationLength()) return this.createElidedInformationPlaceholder();
@@ -1438,7 +1510,8 @@ export class NodeBuilder {
   private shouldWriteTypeOfFunctionSymbol(symbol: Symbol, typeId: number): Symbol | undefined {
     const c = this.c;
     let isStaticMethodSymbol = false;
-    if ((symbol.flags & SymbolFlags.Method) !== 0)
+    // `typeof C.name` can only be written when the member's name is an identifier.
+    if ((symbol.flags & SymbolFlags.Method) !== 0 && isIdentifierText(symbol.name))
       for (const d of getDeclarations(symbol))
         if (isStatic(d) && !hasLateBindableIndexSignature(c, d)) isStaticMethodSymbol = true;
     let isNonLocalFunctionSymbol = false;
@@ -1525,8 +1598,18 @@ export class NodeBuilder {
     const c = this.c;
     const typeId = t.id;
     const symbol = t.symbol;
-    // Anonymous types without a symbol are never circular.
-    if (symbol === undefined) return this.createTypeNodeFromObjectType(t);
+    if (symbol === undefined) {
+      // In declaration emit a reverse mapped type is written out, so it can be circular; for display, its
+      // properties and index signatures use placeholders.
+      if (
+        (t.objectFlags & ObjectFlags.ReverseMapped) !== 0 &&
+        (this.flags & NodeBuilderFlags.AllowAnonymousIdentifier) === 0
+      ) {
+        if (this.visitedTypes.has(typeId)) return this.createCyclicStructurePlaceholder();
+        return this.visitAndTransformType(t, TransformKind.ObjectType);
+      }
+      return this.createTypeNodeFromObjectType(t);
+    }
     if ((t.objectFlags & ObjectFlags.InstantiationExpressionType) !== 0) {
       const existing = (t as InstantiationExpressionType).node;
       // The node is unreliable for members of unions and intersections, so it's checked.
@@ -1535,13 +1618,13 @@ export class NodeBuilder {
         existing.kind === SyntaxKind.TypeQuery &&
         this.getTypeFromTypeNode(existing, false) === t
       ) {
-        if (this.visitedTypes.has(typeId)) return this.createElidedInformationPlaceholder();
+        if (this.visitedTypes.has(typeId)) return this.createCyclicStructurePlaceholder();
         this.visitedTypes.add(typeId);
         const typeNode = this.tryReuseExistingNonParameterTypeNode(existing, t, undefined, undefined);
         this.visitedTypes.delete(typeId);
         if (typeNode !== undefined) return typeNode;
       }
-      if (this.visitedTypes.has(typeId)) return this.createElidedInformationPlaceholder();
+      if (this.visitedTypes.has(typeId)) return this.createCyclicStructurePlaceholder();
       return this.visitAndTransformType(t, TransformKind.ObjectType);
     }
     const isInstanceType = isClassInstanceSide(c, t) ? SymbolFlags.Type : SymbolFlags.Value;
@@ -1557,7 +1640,7 @@ export class NodeBuilder {
       // An anonymous type literal in a type alias is written as the alias.
       const typeAlias = getTypeAliasForTypeLiteral(c, t);
       if (typeAlias !== undefined) return symbolToTypeNode(this, typeAlias, SymbolFlags.Type, undefined);
-      return this.createElidedInformationPlaceholder();
+      return this.createCyclicStructurePlaceholder();
     }
     return this.visitAndTransformType(t, TransformKind.ObjectType);
   }
@@ -1638,9 +1721,11 @@ export class NodeBuilder {
       typeElements.push(this.signatureToSignatureDeclaration(signature, SyntaxKind.ConstructSignature, undefined));
     }
     for (const info of resolved.indexInfos) {
-      // tsgo creates the placeholder for every index signature, and its length counts toward truncation.
-      const placeholder = this.createElidedInformationPlaceholder();
-      const typeNode = (t.objectFlags & ObjectFlags.ReverseMapped) !== 0 ? placeholder : undefined;
+      const typeNode =
+        (t.objectFlags & ObjectFlags.ReverseMapped) !== 0 &&
+        (this.flags & NodeBuilderFlags.AllowAnonymousIdentifier) !== 0
+          ? this.createElidedInformationPlaceholder()
+          : undefined;
       for (const element of this.indexInfoToObjectComputedNamesOrSignatureDeclaration(info, typeNode))
         typeElements.push(element);
     }
@@ -1691,7 +1776,9 @@ export class NodeBuilder {
 
   private shouldUsePlaceholderForProperty(propertySymbol: Symbol): boolean {
     // Placeholders for reverse mapped types (1) already being written, (2) nested in a mapping
-    // over a non-anonymous type, or (3) nested deeply in the same mapped type.
+    // over a non-anonymous type, or (3) nested deeply in the same mapped type. They are for display only:
+    // declaration emit writes the types.
+    if ((this.flags & NodeBuilderFlags.AllowAnonymousIdentifier) === 0) return false;
     if ((propertySymbol.checkFlags & CheckFlags.ReverseMapped) === 0) return false;
     const stack = this.reverseMappedStack;
     if (stack.indexOf(propertySymbol) >= 0) return true;
@@ -1765,7 +1852,7 @@ export class NodeBuilder {
     this.enclosingDeclaration =
       propertySymbol.valueDeclaration ??
       (declarationCount(propertySymbol) > 0 ? propertySymbol.declaration! : saveEnclosingDeclaration);
-    const propertyName = getPropertyNameNodeForSymbol(this, propertySymbol);
+    const propertyName = getPropertyNameNodeForSymbol(this, propertySymbol, saveEnclosingDeclaration);
     this.enclosingDeclaration = saveEnclosingDeclaration;
     this.approximateLength += symbolName(propertySymbol).length + 1;
     if ((propertySymbol.flags & SymbolFlags.Accessor) !== 0) {
@@ -2495,6 +2582,9 @@ export class NodeBuilder {
       declaration = symbol.valueDeclaration ?? (declarationCount(symbol) > 0 ? symbol.declaration! : undefined);
     if (symbol === undefined && declaration !== undefined) symbol = getSymbolOfDeclaration(c, declaration);
     let t = type;
+    // A variable named by a binding pattern has no symbol.
+    if (t === undefined && symbol === undefined && declaration !== undefined && isVariableLike(declaration))
+      t = getTypeForVariableLikeDeclaration(c, declaration, false);
     if (t === undefined && symbol !== undefined) {
       t = this.enclosingSymbolTypes.get(getSymbolId(symbol));
       if (t === undefined) {
@@ -2563,20 +2653,27 @@ export class NodeBuilder {
       tryReuse &&
       this.enclosingDeclaration !== undefined &&
       declaration !== undefined &&
-      symbol !== undefined &&
       (isAccessorKind(declaration) ||
         (hasInferredTypeKind(declaration) &&
           (declaration.flags & NodeFlags.Synthesized) === 0 &&
           (t.objectFlags & ObjectFlags.RequiresWidening) === 0))
     ) {
-      const remove = this.addSymbolTypeToContext(symbol, t);
+      const remove = symbol !== undefined ? this.addSymbolTypeToContext(symbol, t) : undefined;
       let pt: PseudoType = isAccessorKind(declaration)
         ? pseudo.getTypeOfAccessor(declaration)
         : pseudo.getTypeOfDeclaration(declaration);
-      if (pt.kind === PseudoTypeKind.NoResult && declaration.kind === SyntaxKind.BinaryExpression) {
-        // The first annotated assignment declares the type for the rest.
+      if (
+        pt.kind === PseudoTypeKind.NoResult &&
+        declaration.kind === SyntaxKind.BinaryExpression &&
+        symbol !== undefined
+      ) {
+        // The first annotated assignment declares the type for the rest. A type alias's type isn't an annotation.
         for (const d of getDeclarations(symbol))
-          if (getType(d) !== undefined) {
+          if (
+            getType(d) !== undefined &&
+            d.kind !== SyntaxKind.TypeAliasDeclaration &&
+            d.kind !== SyntaxKind.JSTypeAliasDeclaration
+          ) {
             pt = pseudo.getTypeOfDeclaration(d);
             break;
           }
@@ -2617,7 +2714,7 @@ export class NodeBuilder {
           }
         }
       }
-      remove();
+      if (remove !== undefined) remove();
     }
     if (result === undefined) {
       if (reportedInferenceFallback) {
@@ -3283,9 +3380,11 @@ export function typeToTypeNode(
   flags: number,
   internalFlags: NodeBuilderInternalFlags = NodeBuilderInternalFlags.None,
   tracker: SymbolTracker | undefined = undefined,
+  idToSymbol: Map<Node, Symbol> | undefined = undefined,
 ): Node | undefined {
   const b = new NodeBuilder(c, enclosingDeclaration, flags, internalFlags, tracker);
   b.pseudo = newPseudoChecker(c);
+  b.idToSymbol = idToSymbol;
   return b.finish(b.typeToTypeNode(type));
 }
 

package/src/compiler/option-declarations.ts

@@ -9,10 +9,7 @@ import {
   ModuleKind,
   ModuleResolutionKind,
   NewLineKind,
-  PollingKind,
   ScriptTarget,
-  WatchDirectoryKind,
-  WatchFileKind,
 } from './options.js';
 import { Diagnostics, type DiagnosticMessage } from './diagnostics.js';
 
@@ -88,6 +85,7 @@ export const targetValues: EnumValues = new Map<string, number | string>([
   ['es2023', ScriptTarget.ES2023],
   ['es2024', ScriptTarget.ES2024],
   ['es2025', ScriptTarget.ES2025],
+  ['es2026', ScriptTarget.ES2026],
   ['esnext', ScriptTarget.ESNext],
 ]);
 
@@ -124,6 +122,7 @@ export const libMap: EnumValues = new Map<string, number | string>([
   ['es2023', 'lib.es2023.d.ts'],
   ['es2024', 'lib.es2024.d.ts'],
   ['es2025', 'lib.es2025.d.ts'],
+  ['es2026', 'lib.es2026.d.ts'],
   ['esnext', 'lib.esnext.d.ts'],
   ['dom', 'lib.dom.d.ts'],
   ['dom.iterable', 'lib.dom.iterable.d.ts'],
@@ -195,6 +194,13 @@ export const libMap: EnumValues = new Map<string, number | string>([
   ['es2025.iterator', 'lib.es2025.iterator.d.ts'],
   ['es2025.promise', 'lib.es2025.promise.d.ts'],
   ['es2025.regexp', 'lib.es2025.regexp.d.ts'],
+  ['es2026.array', 'lib.es2026.array.d.ts'],
+  ['es2026.collection', 'lib.es2026.collection.d.ts'],
+  ['es2026.error', 'lib.es2026.error.d.ts'],
+  ['es2026.iterator', 'lib.es2026.iterator.d.ts'],
+  ['es2026.json', 'lib.es2026.json.d.ts'],
+  ['es2026.math', 'lib.es2026.math.d.ts'],
+  ['es2026.typedarrays', 'lib.es2026.typedarrays.d.ts'],
   ['esnext.asynciterable', 'lib.es2018.asynciterable.d.ts'],
   ['esnext.symbol', 'lib.es2019.symbol.d.ts'],
   ['esnext.bigint', 'lib.es2020.bigint.d.ts'],
@@ -203,18 +209,19 @@ export const libMap: EnumValues = new Map<string, number | string>([
   ['esnext.regexp', 'lib.es2024.regexp.d.ts'],
   ['esnext.string', 'lib.es2024.string.d.ts'],
   ['esnext.float16', 'lib.es2025.float16.d.ts'],
-  ['esnext.iterator', 'lib.es2025.iterator.d.ts'],
-  ['esnext.promise', 'lib.es2025.promise.d.ts'],
-  ['esnext.array', 'lib.esnext.array.d.ts'],
-  ['esnext.collection', 'lib.esnext.collection.d.ts'],
+  ['esnext.array', 'lib.es2026.array.d.ts'],
+  ['esnext.collection', 'lib.es2026.collection.d.ts'],
+  ['esnext.error', 'lib.es2026.error.d.ts'],
+  ['esnext.typedarrays', 'lib.es2026.typedarrays.d.ts'],
+  ['esnext.iterator', 'lib.esnext.iterator.d.ts'],
+  ['esnext.promise', 'lib.esnext.promise.d.ts'],
   ['esnext.date', 'lib.esnext.date.d.ts'],
   ['esnext.decorators', 'lib.esnext.decorators.d.ts'],
   ['esnext.disposable', 'lib.esnext.disposable.d.ts'],
-  ['esnext.error', 'lib.esnext.error.d.ts'],
   ['esnext.intl', 'lib.esnext.intl.d.ts'],
+  ['esnext.modulesource', 'lib.esnext.modulesource.d.ts'],
   ['esnext.sharedmemory', 'lib.esnext.sharedmemory.d.ts'],
   ['esnext.temporal', 'lib.esnext.temporal.d.ts'],
-  ['esnext.typedarrays', 'lib.esnext.typedarrays.d.ts'],
   ['decorators', 'lib.decorators.d.ts'],
   ['decorators.legacy', 'lib.decorators.legacy.d.ts'],
 ]);
@@ -247,29 +254,6 @@ export const moduleDetectionValues: EnumValues = new Map<string, number | string
   ['force', ModuleDetectionKind.Force],
 ]);
 
-export const watchFileValues: EnumValues = new Map<string, number | string>([
-  ['fixedpollinginterval', WatchFileKind.FixedPollingInterval],
-  ['prioritypollinginterval', WatchFileKind.PriorityPollingInterval],
-  ['dynamicprioritypolling', WatchFileKind.DynamicPriorityPolling],
-  ['fixedchunksizepolling', WatchFileKind.FixedChunkSizePolling],
-  ['usefsevents', WatchFileKind.UseFsEvents],
-  ['usefseventsonparentdirectory', WatchFileKind.UseFsEventsOnParentDirectory],
-]);
-
-export const watchDirectoryValues: EnumValues = new Map<string, number | string>([
-  ['usefsevents', WatchDirectoryKind.UseFsEvents],
-  ['fixedpollinginterval', WatchDirectoryKind.FixedPollingInterval],
-  ['dynamicprioritypolling', WatchDirectoryKind.DynamicPriorityPolling],
-  ['fixedchunksizepolling', WatchDirectoryKind.FixedChunkSizePolling],
-]);
-
-export const fallbackPollingValues: EnumValues = new Map<string, number | string>([
-  ['fixedinterval', PollingKind.FixedInterval],
-  ['priorityinterval', PollingKind.PriorityInterval],
-  ['dynamicpriority', PollingKind.DynamicPriority],
-  ['fixedchunksize', PollingKind.FixedChunkSize],
-]);
-
 /** `--build`, `-b`. Only valid as the first argument. */
 export const buildOption: OptionDeclaration = {
   name: 'build',
@@ -506,6 +490,15 @@ export const commonOptionsWithBuild: readonly OptionDeclaration[] = [
     defaultValueMessage: Diagnostics.X_4_unless_singleThreaded_is_passed,
     minValue: 1,
   },
+  {
+    // Content mappers aren't supported; the option is accepted and has no effect.
+    name: 'runExternalCode',
+    kind: 'boolean',
+    isCommandLineOnly: true,
+    category: Diagnostics.Command_line_Options,
+    description: Diagnostics.Allow_loading_external_content_mapper_plugins_that_execute_code_during_compilation,
+    defaultValueDescription: false,
+  },
 ];
 
 /** Options of `tsc` that `tsc --build` rejects. */
@@ -581,7 +574,7 @@ export const optionsForCompiler: readonly OptionDeclaration[] = [
     category: Diagnostics.Language_and_Environment,
     description:
       Diagnostics.Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declarations,
-    defaultValueDescription: ScriptTarget.ES2025,
+    defaultValueDescription: ScriptTarget.ES2026,
     affects: Affects.BuildInfo | Affects.SourceFile | Affects.ModuleResolution | Affects.Emit,
   },
   {
@@ -1426,75 +1419,6 @@ export const optionsForBuild: readonly OptionDeclaration[] = [
   },
 ];
 
-/** Watch options, accepted on the command line and in `watchOptions`. */
-export const optionsForWatch: readonly OptionDeclaration[] = [
-  {
-    name: 'watchInterval',
-    kind: 'number',
-    category: Diagnostics.Watch_and_Build_Modes,
-  },
-  {
-    name: 'watchFile',
-    kind: 'enum',
-    values: watchFileValues,
-    category: Diagnostics.Watch_and_Build_Modes,
-    description: Diagnostics.Specify_how_the_TypeScript_watch_mode_works,
-    defaultValueDescription: WatchFileKind.UseFsEvents,
-  },
-  {
-    name: 'watchDirectory',
-    kind: 'enum',
-    values: watchDirectoryValues,
-    category: Diagnostics.Watch_and_Build_Modes,
-    description:
-      Diagnostics.Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality,
-    defaultValueDescription: WatchDirectoryKind.UseFsEvents,
-  },
-  {
-    name: 'fallbackPolling',
-    kind: 'enum',
-    values: fallbackPollingValues,
-    category: Diagnostics.Watch_and_Build_Modes,
-    description:
-      Diagnostics.Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers,
-    defaultValueDescription: PollingKind.PriorityInterval,
-  },
-  {
-    name: 'synchronousWatchDirectory',
-    kind: 'boolean',
-    category: Diagnostics.Watch_and_Build_Modes,
-    description:
-      Diagnostics.Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively,
-    defaultValueDescription: false,
-  },
-  {
-    name: 'excludeDirectories',
-    kind: 'list',
-    element: {
-      name: 'excludeDirectory',
-      kind: 'string',
-      isFilePath: true,
-      extraValidation: 'spec',
-    },
-    category: Diagnostics.Watch_and_Build_Modes,
-    description: Diagnostics.Remove_a_list_of_directories_from_the_watch_process,
-    allowConfigDirTemplateSubstitution: true,
-  },
-  {
-    name: 'excludeFiles',
-    kind: 'list',
-    element: {
-      name: 'excludeFile',
-      kind: 'string',
-      isFilePath: true,
-      extraValidation: 'spec',
-    },
-    category: Diagnostics.Watch_and_Build_Modes,
-    description: Diagnostics.Remove_a_list_of_files_from_the_watch_mode_s_processing,
-    allowConfigDirTemplateSubstitution: true,
-  },
-];
-
 /** Keys of `typeAcquisition` in tsconfig.json. */
 export const typeAcquisitionDeclarations: readonly OptionDeclaration[] = [
   {
@@ -1547,6 +1471,13 @@ export class OptionNameMap {
     return this.byName.get(name.toLowerCase());
   }
 
+  /** The declared names, for spelling suggestions. */
+  names(): string[] {
+    const names: string[] = [];
+    for (const declaration of this.byName.values()) names.push(declaration.name);
+    return names;
+  }
+
   /** Looks up `name`, or with `allowShort` the option it abbreviates. */
   find(name: string, allowShort: boolean): OptionDeclaration | undefined {
     const lower = name.toLowerCase();
@@ -1557,4 +1488,3 @@ export class OptionNameMap {
 
 export const compilerOptionsByName = new OptionNameMap(optionDeclarations);
 export const buildOptionsByName = new OptionNameMap(buildOptionDeclarations);
-export const watchOptionsByName = new OptionNameMap(optionsForWatch);