`AbstractKeyword`, a token type the schema names as an instantiation.

The schema's `AccessExpression` alias, over 2 kinds.

The schema's `AccessorDeclaration` alias, over 2 kinds.

`AccessorKeyword`, a token type the schema names as an instantiation.

Typed child and data access, one module per node type. These are the `AstNode` accessors with the argument and the result typed, which is the whole difference: `AstNode.IfStatement.thenStatement` will read slot 1 of anything you hand it, and `IfStatement.thenStatement` will not compile unless you hand it one.

The schema's `AnyImportSyntax` alias, over 3 kinds.

A typed view over the binary AST: `Node<'Tag>` instead of a bare `int`. Three things are generated here, all from `ast.json`: - **Tags**, one per node type, per node alias and per token instantiation. A tag is an interface that nothing ever implements; it exists so that `Node` and `Node` are different types over the same two fields. Tag inheritance is kind-set inclusion, so `'Tag :> Expression` is the compile-time form of the runtime claim `AstKind.isExpression`. - **Accessors**, one module per node type, returning `Node<'Tag>` at the type the schema declares for the slot. Unlike `AstNode`, these cannot be pointed at the wrong kind of node, because the argument is typed. - **Views**, in `Patterns`, narrowing any node to a tag by testing its kind. They are `[]` partial active patterns rather than a union, so a match costs a kind read and a two-word copy and allocates nothing. Widening is `.ofNode`, one function per alias: F# rejects a constraint whose right-hand side is a type variable, so a single generic `widen` is not expressible. The tag every other tag inherits, and the type of a slot the schema does not narrow - a member declared as a bare `Node` or as an inline union. Narrow it with a view.

One function per server method, each taking the channel and the method's parameter record. Naming follows the wire: `getSymbolAtPosition` is `Api.getSymbolAtPosition`. Results the schema permits to be null are `voption`; the rest raise if the server sends nothing, since a missing field on a request is otherwise indistinguishable from a legitimate empty answer.

The schema's `ArrayBindingElement` alias, over 2 kinds.

The schema's `ArrayDestructuringAssignment` alias, over 1 kind.

The node type `ArrayLiteralExpression`.

The node type `ArrayTypeNode`.

The node type `ArrowFunction`.

The node type `AsExpression`.

The schema's `AssertionExpression` alias, over 2 kinds.

`AssertKeyword`, a token type the schema names as an instantiation.

`AssertsKeyword`, a token type the schema names as an instantiation.

`AssignmentOperatorToken`, a token type the schema names as an instantiation.

The version-5 binary AST returned by `getSourceFile`: one blob per file, from which every node is readable with no further round-trips. All integers here are **little-endian**, unlike the msgpack envelope that carried them.

`AsteriskToken`, a token type the schema names as an instantiation.

One function per server method, each taking the mailbox and the method's parameter record. The mirror of `Api` over `TscMailbox` rather than `TscChannel`: same names, same parameter and result types, each wrapped in `Async`. Calls that overlap in time are collected into a single round trip, so concurrency here is worth taking even though the channel underneath admits one request at a time. `batchRequests` has no counterpart: the mailbox is the batcher, and a batch nested inside one would return a result this layer cannot attribute to a caller.

`AsyncKeyword`, a token type the schema names as an instantiation.

The mirror of `SessionExtensions` over `TscMailbox`: same names, same arguments, each result wrapped in `Async`. Calls that overlap in time are collected into a single round trip.

The snapshot-free half of `AsyncApi`. `batchRequests` is absent for the reason `AsyncApi` omits it: the mailbox is already the batcher.

The node type `AwaitExpression`.

`AwaitKeyword`, a token type the schema names as an instantiation.

The node type `BigIntLiteral`.

The node type `BinaryExpression`.

`BinaryOperatorToken`, a token type the schema names as an instantiation.

The node type `BindingElement`.

The schema's `BindingName` alias, over 3 kinds.

The node type `BindingPattern`.

The node type `Block`.

The schema's `BlockOrExpression` alias, over 56 kinds.

The schema's `BooleanLiteral` alias, over 2 kinds.

The schema's `BreakOrContinueStatement` alias, over 2 kinds.

The node type `BreakStatement`.

The node type `CallExpression`.

The schema's `CallLikeExpression` alias, over 7 kinds.

The schema's `CallOrNewExpression` alias, over 2 kinds.

The node type `CallSignatureDeclaration`.

The node type `CaseBlock`.

`CaseKeyword`, a token type the schema names as an instantiation.

The node type `CaseOrDefaultClause`.

The node type `CatchClause`.

Composite `CheckFlags` values, computed from the cases above rather than written out.

`CheckFlags`, from `tsc/internal/ast/checkflags.go` upstream.

The node type `ClassDeclaration`.

The schema's `ClassElement` alias, over 8 kinds.

The node type `ClassExpression`.

The schema's `ClassLikeDeclaration` alias, over 2 kinds.

The node type `ClassStaticBlockDeclaration`.

`ColonToken`, a token type the schema names as an instantiation.

`CommentDirectiveType`, from `unrecorded` upstream.

The node type `ComputedPropertyName`.

The schema's `ConciseBody` alias, over 56 kinds.

The node type `ConditionalExpression`.

The node type `ConditionalTypeNode`.

`ConstKeyword`, a token type the schema names as an instantiation.

The node type `ConstructorDeclaration`.

The node type `ConstructorTypeNode`.

The node type `ConstructSignatureDeclaration`.

The node type `ContinueStatement`.

The node type `DebuggerStatement`.

The schema's `Declaration` alias, over 56 kinds.

The schema's `DeclarationName` alias, over 10 kinds.

`DeclareKeyword`, a token type the schema names as an instantiation.

The node type `Decorator`.

`DefaultKeyword`, a token type the schema names as an instantiation.

The node type `DeleteExpression`.

The schema's `DestructuringAssignment` alias, over 1 kind.

`DiagnosticDirectivePolicy`, from `tsc/internal/ast/ast.go` upstream.

`DocumentIdentifier` is `string | { uri: string }` on the wire - the schema's one structural union - so neither arm can be inferred from the F# union's shape.

The node type `DoStatement`.

`DotDotDotToken`, a token type the schema names as an instantiation.

`DotToken`, a token type the schema names as an instantiation.

The node type `ElementAccessExpression`.

Composite `ElementFlags` values, computed from the cases above rather than written out.

`ElementFlags`, from `tsc/internal/checker/types.go` upstream.

The node type `EmptyStatement`.

`EndOfFile`, a token type the schema names as an instantiation.

The schema's `EntityName` alias, over 2 kinds.

The node type `EnumDeclaration`.

The node type `EnumMember`.

`EqualsGreaterThanToken`, a token type the schema names as an instantiation.

`EqualsToken`, a token type the schema names as an instantiation.

`ExclamationToken`, a token type the schema names as an instantiation.

The node type `ExportAssignment`.

The node type `ExportDeclaration`.

`ExportKeyword`, a token type the schema names as an instantiation.

The node type `ExportSpecifier`.

The schema's `Expression` alias, over 55 kinds.

The node type `ExpressionStatement`.

The node type `ExpressionWithTypeArguments`.

The node type `ExternalModuleReference`.

`FalseLiteral`, a token type the schema names as an instantiation.

What `readFile` found. The server distinguishes all three, and the distinction is the reason the reply is an object rather than a bare string: `Missing` stops resolution at this path, where `FallBack` sends it on to the real filesystem. Getting the two the wrong way round silently changes module resolution.

The entries of one directory, as `getAccessibleEntries` answers them: names, not paths.

The schema's `ForInitializer` alias, over 57 kinds.

The node type `ForInOrOfStatement`.

The node type `ForStatement`.

The schema's `FunctionBody` alias, over 1 kind.

The node type `FunctionDeclaration`.

The node type `FunctionExpression`.

The schema's `FunctionLikeDeclaration` alias, over 7 kinds.

The node type `FunctionTypeNode`.

The node type `GetAccessorDeclaration`.

The node type `HeritageClause`.

The schema's `HeritageClauseElement` alias, over 2 kinds.

The node type `Identifier`.

The node type `IfStatement`.

The node type `ImportAttribute`.

The schema's `ImportAttributeName` alias, over 2 kinds.

The node type `ImportAttributes`.

The node type `ImportClause`.

The schema's `ImportClauseOrBindingPattern` alias, over 3 kinds.

The node type `ImportDeclaration`.

The node type `ImportEqualsDeclaration`.

`ImportExpression`, a token type the schema names as an instantiation.

The node type `ImportSpecifier`.

The node type `ImportTypeNode`.

The schema's `IncrementExpression` alias, over 27 kinds.

The node type `IndexedAccessTypeNode`.

The node type `IndexSignatureDeclaration`.

The node type `InferTypeNode`.

`InKeyword`, a token type the schema names as an instantiation.

The node type `InterfaceDeclaration`.

`InternalSymbolName`, from `tsc/internal/ast/symbol.go` upstream.

The node type `IntersectionTypeNode`.

The node type `JSDoc`.

The node type `JSDocAllType`.

The node type `JSDocAugmentsTag`.

The node type `JSDocCallbackTag`.

The schema's `JSDocComment` alias, over 4 kinds.

The node type `JSDocDeprecatedTag`.

The schema's `JSDocFullName` alias, over 2 kinds.

The node type `JSDocImplementsTag`.

The node type `JSDocImportTag`.

The node type `JSDocLink`.

The node type `JSDocLinkCode`.

The node type `JSDocLinkPlain`.

The node type `JSDocNameReference`.

The node type `JSDocNonNullableType`.

The node type `JSDocNullableType`.

The node type `JSDocOptionalType`.

The node type `JSDocOverloadTag`.

The node type `JSDocOverrideTag`.

The node type `JSDocParameterOrPropertyTag`.

The node type `JSDocPrivateTag`.

The node type `JSDocProtectedTag`.

The node type `JSDocPublicTag`.

The node type `JSDocReadonlyTag`.

The node type `JSDocReturnTag`.

The node type `JSDocSatisfiesTag`.

The node type `JSDocSeeTag`.

The node type `JSDocSignature`.

The schema's `JSDocTag` alias, over 22 kinds.

The node type `JSDocTemplateTag`.

The node type `JSDocText`.

The node type `JSDocThisTag`.

The node type `JSDocThrowsTag`.

The node type `JSDocTypedefTag`.

The node type `JSDocTypeExpression`.

The node type `JSDocTypeLiteral`.

The node type `JSDocTypeTag`.

The node type `JSDocUnknownTag`.

The node type `JSDocVariadicType`.

The node type `JsxAttribute`.

The schema's `JsxAttributeLike` alias, over 2 kinds.

The schema's `JsxAttributeName` alias, over 2 kinds.

The node type `JsxAttributes`.

The schema's `JsxAttributeValue` alias, over 5 kinds.

The schema's `JsxChild` alias, over 5 kinds.

The node type `JsxClosingElement`.

The node type `JsxClosingFragment`.

The node type `JsxElement`.

The node type `JsxExpression`.

The node type `JsxFragment`.

The node type `JsxNamespacedName`.

The node type `JsxOpeningElement`.

The node type `JsxOpeningFragment`.

The schema's `JsxOpeningLikeElement` alias, over 2 kinds.

The node type `JsxSelfClosingElement`.

The node type `JsxSpreadAttribute`.

The schema's `JsxTagNameExpression` alias, over 4 kinds.

The node type `JsxText`.

The node type `KeywordExpression`.

The node type `KeywordTypeNode`.

The node type `LabeledStatement`.

`LanguageVariant`, from `unrecorded` upstream.

The schema's `LeftHandSideExpression` alias, over 25 kinds.

The schema's `LiteralExpression` alias, over 5 kinds.

The schema's `LiteralLikeNode` alias, over 8 kinds.

The schema's `LiteralToken` alias, over 6 kinds.

The node type `LiteralTypeNode`.

The node type `MappedTypeNode`.

Roles for the integers the decoder passes around. The blob is full of `int`s and `uint32`s that mean entirely different things - a node index, a string index, a byte offset into one section or another, a bitmap, a shift distance - and nothing but the parameter name distinguishes them. These measures make the wrong one a compile error, and erase completely, so the decoder pays nothing for them. The bitwise operators are not defined for measured integers: `mask &&& mask` does not compile, let alone `field &&& mask`. That is the point rather than an obstacle - it forces the operations to be spelled out here, with the roles in the signature, so a mask cannot be used where a shift belongs and masking cannot silently change what a value is.

The schema's `MemberName` alias, over 2 kinds.

The node type `MetaProperty`.

The node type `MethodDeclaration`.

The node type `MethodSignatureDeclaration`.

`MinusToken`, a token type the schema names as an instantiation.

The node type `MissingDeclaration`.

The schema's `Modifier` alias, over 15 kinds.

Composite `ModifierFlags` values, computed from the cases above rather than written out.

`ModifierFlags`, from `tsc/internal/ast/modifierflags.go` upstream.

The schema's `ModifierLike` alias, over 16 kinds.

The node type `ModuleBlock`.

The schema's `ModuleBody` alias, over 2 kinds.

The node type `ModuleDeclaration`.

The schema's `ModuleExportName` alias, over 2 kinds.

The schema's `ModuleName` alias, over 2 kinds.

The schema's `ModuleReference` alias, over 3 kinds.

The schema's `NamedExportBindings` alias, over 2 kinds.

The node type `NamedExports`.

The schema's `NamedImportBindings` alias, over 2 kinds.

The node type `NamedImports`.

The schema's `NamedImportsOrExports` alias, over 2 kinds.

The node type `NamedTupleMember`.

The node type `NamespaceExport`.

The node type `NamespaceExportDeclaration`.

The node type `NamespaceImport`.

The node type `NewExpression`.

The escape hatch, and the operations that hold for every node whatever its tag.

A node in a decoded source file, tagged with what the schema says it is. A struct over the blob and an index, so it is the same two words a raw `int` walk carries plus the blob it was already holding. The tag is erased at runtime.

The schema's `NodeBody` alias, over 58 kinds.

Composite `NodeBuilderFlags` values, computed from the cases above rather than written out.

`NodeBuilderFlags`, from `tsc/internal/nodebuilder/types.go` upstream.

Composite `NodeFlags` values, computed from the cases above rather than written out.

`NodeFlags`, from `tsc/internal/ast/nodeflags.go` upstream.

The node type `NonNullExpression`.

The node type `NoSubstitutionTemplateLiteral`.

The node type `NotEmittedStatement`.

The node type `NotEmittedTypeElement`.

`NullLiteral`, a token type the schema names as an instantiation.

The node type `NumericLiteral`.

The schema's `NumericOrStringLikeLiteral` alias, over 3 kinds.

The schema's `ObjectDestructuringAssignment` alias, over 1 kind.

Composite `ObjectFlags` values, computed from the cases above rather than written out.

`ObjectFlags`, from `tsc/internal/checker/types.go` upstream.

The schema's `ObjectLiteralElement` alias, over 7 kinds.

The schema's `ObjectLiteralElementLike` alias, over 6 kinds.

The node type `ObjectLiteralExpression`.

The schema's `ObjectLiteralLikeNode` alias, over 2 kinds.

The schema's `ObjectTypeDeclaration` alias, over 4 kinds.

The node type `OmittedExpression`.

The node type `OptionalTypeNode`.

`OutKeyword`, a token type the schema names as an instantiation.

`OverrideKeyword`, a token type the schema names as an instantiation.

The node type `ParameterDeclaration`.

The node type `ParenthesizedExpression`.

The node type `ParenthesizedTypeNode`.

The node type `PartiallyEmittedExpression`.

Views: narrowing a node of any tag to a narrower one, by testing its kind. Not auto-opened, because a few hundred active patterns in scope by default would shadow more than they are worth. `open Xantham.TypeScript.Wire.Patterns` where you match. `[]` is what makes these free: a total union view would allocate a `Choice` per match, and these allocate nothing at all.

`PlusToken`, a token type the schema names as an instantiation.

The node type `PostfixUnaryExpression`.

The node type `PrefixUnaryExpression`.

The node type `PrivateIdentifier`.

`PrivateKeyword`, a token type the schema names as an instantiation.

The node type `PropertyAccessExpression`.

The node type `PropertyAssignment`.

The node type `PropertyDeclaration`.

The schema's `PropertyName` alias, over 7 kinds.

The schema's `PropertyNameLiteral` alias, over 3 kinds.

The node type `PropertySignatureDeclaration`.

`ProtectedKeyword`, a token type the schema names as an instantiation.

The schema is not ordered by dependency - `UpdateSnapshotParams` refers to `APIFileChanges`, which is declared far below it - so the module is recursive rather than reordered here. Reordering would diverge from the schema and break the next diff.

Enums the wire schema refers to, transcribed from the compiler's own `dist/enums`. Aliases that repeat a value are kept as declared (`ScriptTarget.Latest` beside `ESNext`); F# permits duplicate enum cases, and dropping one would diverge from the compiler's own names.

Serialisation for the generated wire types, and the typed request helpers built on it.

The schema's `PseudoLiteralToken` alias, over 3 kinds.

`PublicKeyword`, a token type the schema names as an instantiation.

The node type `QualifiedName`.

`QuestionDotToken`, a token type the schema names as an instantiation.

`QuestionToken`, a token type the schema names as an instantiation.

For serialized/decode passthrough of bytes for batch requests without any DOM parsing.

`ReadonlyKeyword`, a token type the schema names as an instantiation.

The node type `RegularExpressionLiteral`.

The node type `RestTypeNode`.

The node type `ReturnStatement`.

The node type `SatisfiesExpression`.

`ScriptKind`, from `tsc/internal/core/scriptkind.go` upstream.

The node type `SemicolonClassElement`.

A snapshot and a project, bound once. Of the wire's methods, most take `snapshot` and `project` as their first two arguments. They say which program is being asked, not what is being asked of it, and they do not vary across the calls a caller makes against one program - so `Session` holds them and the members below take only what is left. It is the same move `Node<'Tag>` makes for a source file and an index. The type parameter is the transport. `Session` answers synchronously and `Session` in `Async`; the member names and argument lists are identical, so the two differ only in what they return. Build one with `channel.Session(...)` or `mailbox.Session(...)`. Handles mean something only within the program that produced them, so a session is also the scope in which a symbol or type id is valid. A response that names a different project - `SymbolResponse.Project`, which the schema documents as the default for follow-up lookups - is followed with `ForSymbol`, not by passing a project argument.

Ways to get a session. The snapshot and project always come from a response that already pairs them, so the overloads below take those responses rather than leaving a caller to unpack the pair and risk crossing a snapshot with another snapshot's project.

`Api` as members of a session, with the snapshot and project it holds supplied on the caller's behalf: `session.getSymbolAtPosition(file, position)` rather than `channel.getSymbolAtPosition(snapshot, project, file, position)`. Fields the schema marks optional are `[]` optional arguments, so they arrive as the `voption` the record field already holds and pass straight through. F# requires optional arguments to come last, so where a required field follows an optional one the argument order is not the record's own; named arguments sidestep that, and are worth using regardless, since several methods take three or more arguments of the same type.

The methods that identify nothing - they open a snapshot rather than read one - reached through `session.Sessionless` so that they stay explorable without diluting the session's own surface with calls that ignore it.

The snapshot-free half of `Api`, reached through `session.Sessionless`.

The node type `SetAccessorDeclaration`.

The node type `ShorthandPropertyAssignment`.

The schema's `SignatureDeclaration` alias, over 13 kinds.

Composite `SignatureFlags` values, computed from the cases above rather than written out.

`SignatureFlags`, from `tsc/internal/checker/types.go` upstream.

`SignatureKind`, from `tsc/internal/checker/types.go` upstream.

The node type `SourceFile`.

Byte offsets into the `SourceFile` node's extended-data record. Unlike everything else here, this layout is not in `ast.json`. The record is written by a hand-written Go function and read by hand-written TypeScript, so the only statement of its shape is the format documentation in `encoder.go`, which the generator parses. Every field is a `uint32`; `Ast` in `Library.fs` is what gives them meaning.

`SpanMapFeature`, from `tsc/internal/spanmap/spanmap.go` upstream.

`SpanMapFidelity`, from `tsc/internal/spanmap/spanmap.go` upstream.

`SpanMapKind`, from `tsc/internal/spanmap/spanmap.go` upstream.

The node type `SpreadAssignment`.

The node type `SpreadElement`.

The schema's `Statement` alias, over 35 kinds.

`StaticKeyword`, a token type the schema names as an instantiation.

The node type `StringLiteral`.

The schema's `StringLiteralLikeNode` alias, over 2 kinds.

`SuperExpression`, a token type the schema names as an instantiation.

The node type `SwitchStatement`.

Composite `SymbolFlags` values, computed from the cases above rather than written out.

`SymbolFlags`, from `tsc/internal/ast/symbolflags.go` upstream.

A node's kind, as encoded in the `kind` word of a binary AST blob. Values are positional in the schema, so they move whenever the compiler inserts a kind. They are not the values the JavaScript compiler API uses. The backing type is `uint32` so that the enum maps onto the blob's `kind` word without a conversion, and so that `Ast.KindNodeList` (`0xFFFFFFFF`) is representable.

The node type `SyntaxList`.

The node type `SyntheticExpression`.

The node type `SyntheticReferenceExpression`.

The node type `TaggedTemplateExpression`.

The node type `TemplateExpression`.

The node type `TemplateHead`.

The schema's `TemplateLiteral` alias, over 2 kinds.

The schema's `TemplateLiteralLikeNode` alias, over 3 kinds.

The schema's `TemplateLiteralToken` alias, over 4 kinds.

The node type `TemplateLiteralTypeNode`.

The node type `TemplateLiteralTypeSpan`.

The node type `TemplateMiddle`.

The schema's `TemplateMiddleOrTail` alias, over 2 kinds.

The node type `TemplateSpan`.

The node type `TemplateTail`.

`ThisExpression`, a token type the schema names as an instantiation.

The node type `ThisTypeNode`.

The node type `ThrowStatement`.

The node type `Token`.

Composite `TokenFlags` values, computed from the cases above rather than written out.

`TokenFlags`, from `tsc/internal/ast/tokenflags.go` upstream.

`TrueLiteral`, a token type the schema names as an instantiation.

The node type `TryStatement`.

SYNC TypeScript compiler speaking the sync MessagePack protocol over redirected stdio.

`Api` as members, so the channel is not threaded through every call: `channel.getSymbolAtPosition parameters` rather than `Api.getSymbolAtPosition channel`. Each method that takes a parameter record gets a second, inlined overload accepting that record's fields directly and building it on the caller's behalf. Fields the schema marks optional are `[]` optional arguments, so they arrive as the `voption` the record field already holds and pass straight through. F# requires optional arguments to come last, so where a required field follows an optional one the argument order is not the record's own. Named arguments sidestep that, and are worth using here regardless: several methods take four or more arguments of the same type.

Asynchronous wrapper for the serial channel. Avoids the async-api overhead of the tsc encoding.

If there is a backlog of requests after the first, then the mailbox will batch them together.

`AsyncApi` as members, so the mailbox is not threaded through every call: `mailbox.getSymbolAtPosition parameters` rather than `AsyncApi.getSymbolAtPosition mailbox`. Each method that takes a parameter record gets a second, inlined overload accepting that record's fields directly and building it on the caller's behalf. Fields the schema marks optional are `[]` optional arguments, so they arrive as the `voption` the record field already holds and pass straight through. F# requires optional arguments to come last, so where a required field follows an optional one the argument order is not the record's own. Named arguments sidestep that, and are worth using here regardless: several methods take four or more arguments of the same type.

A filesystem callback the server may invoke on us (`--callbacks=...`). The argument arrives **JSON-encoded** - a path is `"C:/..."` with the quotes - so it must be parsed, not used raw. The result is JSON too, and `null` is not the same as absent: an explicit null changes module resolution semantics.

A method call failed server-side. a bare message with no code, so there is nothing structured to match on.

The node type `TupleTypeNode`.

The node type `TypeAliasDeclaration`.

The node type `TypeAssertion`.

The schema's `TypeElement` alias, over 8 kinds.

Composite `TypeFlags` values, computed from the cases above rather than written out.

`TypeFlags`, from `tsc/internal/checker/types.go` upstream.

The node type `TypeLiteralNode`.

The schema's `TypeNode` alias, over 45 kinds.

The node type `TypeOfExpression`.

The node type `TypeOperatorNode`.

The node type `TypeParameterDeclaration`.

`TypePredicateKind`, from `tsc/internal/checker/types.go` upstream.

The node type `TypePredicateNode`.

The schema's `TypePredicateParameterName` alias, over 2 kinds.

The node type `TypeQueryNode`.

The node type `TypeReferenceNode`.

The schema's `UnionOrIntersectionTypeNode` alias, over 2 kinds.

The node type `UnionTypeNode`.

`System.Text.Json` has no native understanding of `voption`, and the generated records use it for every field the schema marks optional. Reading is the easy half; the writing half matters more, because the server distinguishes an absent field from an explicit null - `ValueNone` must vanish from the payload rather than serialise as `null`. That omission is what the generated `JsonIgnoreCondition.WhenWritingDefault` attributes buy: `ValueNone` is the default value of the struct, so the property is skipped before this converter is ever asked to write it.

The node type `VariableDeclaration`.

The node type `VariableDeclarationList`.

The schema's `VariableOrParameterDeclaration` alias, over 2 kinds.

The schema's `VariableOrPropertyDeclaration` alias, over 2 kinds.

The node type `VariableStatement`.

The virtual filesystem the server delegates to when the process is started with --callbacks=, mirroring dist/api/fs.d.ts. Every member is optional, and one left unset is not registered at all, so the server never asks about it.

The node type `VoidExpression`.

The node type `WhileStatement`.

Widening, one module per alias. Each is the identity at runtime; the point is that the constraint only admits tags the schema says belong to the alias.

The node type `WithStatement`.

The AST string table is WTF-8, not UTF-8: an unpaired UTF-16 surrogate is encoded as the three bytes `ED A0-BF 80-BF`, which strict UTF-8 rejects. `Encoding.UTF8.GetString` replaces those with U+FFFD, so identifiers and string literals carrying a lone surrogate come back silently corrupted. TypeScript permits them, so we decode them ourselves.

The node type `YieldExpression`.