typescript-extract-type-json.ts

Identity-keyed registry of exported alias-lost type aliases, consulted by the tree builder at nameless positions behind written-name recovery. Built per analysis cycle by buildAliasRegistry (typescript-alias-registry.ts); undefined wherever no pre-pass ran (registry recovery disabled, written recovery unaffected).

A name registered for an alias-lost type — see buildAliasRegistry in typescript-alias-registry.ts.

Whether the checker kept no name for a type-alias declaration's resolved type: no alias symbol (the checker still prints type A = B as B), no nominal symbol (interfaces/classes/enums print their own name), and not an interned terminal (type A = string and type A = 'x' carry no alias symbol either but print fine). True exactly for the expansion-prone class the alias registry targets and the alias_lost diagnostic reports — indexed-access and conditional right-hand sides (z.infer<typeof S> et al.), whose resolution lands on a pre-existing interned type that TypeScript never retroactively stamps an alias symbol on.

Whether a type is an intersection carrying an intrinsic or literal member — the .brand() shape (string & BRAND<'x'>). Such aliases are lost but unrecoverable, readable, and author-unfixable, so the alias_lost diagnostic excludes them.

Whether a type is a union of literals only (z.enum outputs — a lost alias over one degrades mildly and readably, so the alias_lost diagnostic excludes it). Enum-member literals match too.

The type's non-anonymous symbol name (__type/__object/__function mark anonymous shapes). The one anonymity rule shared by the recovery gate here, the alias-lost predicate (isAliasLostType), and the registry's safety-gate walk (typescript-alias-registry.ts) — never ObjectFlags.Anonymous, which real inferred schema outputs (zod's are Mapped | Instantiated) don't carry.

The single owner of the optional-widening strip, shared with getTypeSignature and getNonOptionalType (in typescript-extract-shared.ts) so the flat string, the tree, and the structural queries can't drift. Owns the optional gate too — a non-optional position passes through, so call sites hand over the flag rather than branching around the call. For a type at an optional-flagged position (a ?-marked declaration or tuple element):

• a non-union carries no separate widening member to strip, so it passes through. Three shapes land here: x?: undefined (the written type and the widening coincide), and x?: unknown / x?: any (both absorb undefined). getNonNullableType must not run on any of them — it answers {} for unknown, which would report x?: unknown as "{}"
• a null-bearing union keeps its shape and reports dropUndefined — the walk drops only the widening member (so the alias survives) and the printer trims the printed suffix
• a union left with exactly one member after dropping undefined takes that member directly — it *is* the annotated type. Matters for a bare unconstrained type parameter (c?: E), where getNonNullableType can only answer NonNullable<E> and would print E & {}
• every other union takes getNonNullableType, which rebuilds the union rather than picking a member (so a union of callables keeps its combined call signature) and preserves the alias symbol

Under exactOptionalPropertyTypes the checker widens optional *properties* not at all, so property sites gate optional off via optionalWidened (in typescript-extract-shared.ts) and never reach the strip; optional parameters and tuple elements widen under both modes and keep passing optional unconditionally.

The symbol name of a named generic instantiation (Snippet<[a: string]>, Map<string, B>) — checker Reference-flagged, non-anonymous symbol, carrying type arguments — or undefined for everything else. One predicate for the two decisions that must agree: the callable-classification exception (such a type is a reference node even when it has call signatures) and the object branch's reference emission. Tuples never match (their references carry no symbol); bare and aliased signatures are Anonymous-flagged; non-generic callable interfaces either aren't Reference-flagged (thisless) or carry no type arguments (the declared type of a this-referencing interface or a class is its own Reference with an empty argument list) — all of these stay function nodes.

The structured type for an output field, or undefined when the flat string is the whole story (the TypeJson absence contract).

Matches getTypeSignature's optional handling by construction — both select through optionalWideningTarget (see there for the case split); x?: undefined stays terminal. What's specific to the tree: union members walk the union's origin (see unionMemberTypes), so member order matches the printed string and a null-bearing optional alias survives: dropping the widening from the origin list leaves the alias-carrying union as the sole member, which the 1-member collapse promotes to the root (a?: A where A is nullable yields the A union, matching the flat string's printed-string surgery). When no usable origin exists both degrade together, bounded: checker- internal member order, alias lost.

Self-named alias roots relax the contract. checker.typeToString prints a type carrying an alias symbol as that alias's bare name, so a type alias's own typeSignature reads "StrArr", not "string[]" — there is no descriptive flat sibling for the tree to defer to, and the usual gate would leave type StrArr = string[] and type Pair = [string, number] with no type information at all. When the type reports ownAliasName as its alias the node is emitted regardless, except for the kinds members already covers (REDUNDANT_WITH_MEMBERS). Interned types (intrinsics, literals) never carry the alias symbol, so type Str = string still prints structurally and stays absent.

Recovered roots relax it too. When writtenNode or aliasRegistry names a nameless type, the tree emits {kind: 'reference', name} (see buildWrittenNameMap / recoveredReference) — and at the root that node is emitted even though a bare reference normally stays absent: a checker-named bare reference defers to a flat sibling printing the same name, while a recovered one stands against a flat sibling printing the anonymous expansion, so the name exists only in the tree.

Declaration-site context for resolveTypeInfo — see its param doc.

Both output forms of a rest tuple element, which present it as the array it collects (...rest: B[] carries "B[]" and an array node) — the flat/structured counterpart of buildTuple's array rewrap, for extractSnippetParameters. Paired in one function so the two can't be half applied: a printed array beside a non-array tree would describe two different types.

The string prints through the checker's internal createArrayType so parenthesization is the printer's own — hand rules get the edges wrong (a readonly B[] element *must* parenthesize or readonly B[][] denotes a different type, a bare union needs parens, a unique symbol prints as a typeof query). If the internal factory disappears, the fallback parenthesizes everything but bare identifier paths — sometimes over-parenthesized, never a different type. The tree is presence-gated like any array node (present when the element is a reference or carries structure). writtenNode and aliasRegistry feed name recovery like resolveTypeInfo's — the caller passes the same annotation and registry it hands the sibling tree, so the two projections of one element can't disagree on a recovered name.

The name a module exports an aliased symbol under, or undefined when the alias names no export (a default or namespace import, a star re-export).

The one rule shared by both name-recovery channels — this file's written-name lookup and externalTypeRefText's textual substitution (typescript-extract-shared.ts). Both specifier kinds carry the name, on opposite sides of their own as: an ImportSpecifier takes the module's side, its propertyName (import type {Bag as B} → Bag, B being this file's private spelling), while an ExportSpecifier *is* the module's side, so its name is what it publishes (export {Internal as Public} → Public, Internal being the other module's). Unrenamed, both collapse to the one name written.

Stopping at a specifier rather than resolving the whole alias chain is what makes the result importable: the chain ends at the *declaration's* name, which a module renaming on the way out never exports — recovering Internal there names something no consumer of that module can reach.

The written element label as an output name: a NamedTupleMember's identifier, or a parameter-derived label's (Parameters<F> tuples) — the identifier guard is defensive, since binding-pattern parameters produce no label declaration at all. The one naming rule for both tupleElements consumers, so parameters and the typeInfo tree can't disagree on names.

The per-index element metadata of a tuple reference — the one place the typeArguments/elementFlags/labeledElementDeclarations triple is read, consumed by buildTuple here and extractSnippetParameters in svelte.ts.

Per-element checker metadata from tupleElements — one walk, projected per consumer.

The member-set key of a union — sorted internal type ids, undefined filtered — or undefined when unusable (an internal-API id missing, or fewer than two non-undefined members, a set no widened-union lookup can produce). One function for both sides so registration and lookup can't drift. Identity safety carries over from the ids: two unions share a key only when they share their non-undefined members by object identity.