@velarscript/compiler 0.10.1

package/dist/analyzer.d.ts

@@ -0,0 +1,1175 @@
+import type { Expression, FunctionDeclaration, Program, Statement, TypeParameterDeclaration, TypeReference, TypeSyntax } from "./ast.ts";
+import { type PermanentNamespaceName } from "./core-vocabulary.ts";
+import { type Diagnostic, type DiagnosticFix } from "./diagnostic.ts";
+import type { CompilerAnalysisExtension } from "./extension.ts";
+import { type Span } from "./source.ts";
+import { type EnumInfo, type BinaryStorageKind, type ExtensionValueType, type GenericTypeInfo, type TypeEnvironment, type TypeParameterBound, type ValueType } from "./types.ts";
+interface Binding {
+    readonly mutable: boolean;
+    type: ValueType;
+    declaredType: ValueType;
+    storageType: ValueType;
+    readonly storageBinding?: Binding;
+    readonly span: Span;
+    narrowingFrame: number | null;
+    /**
+     * D44 rule 71: true while the active narrowing was established by an
+     * assignment (or a declaration initializer) rather than a check. Only
+     * meaningful when narrowingFrame is not null. Assigned facts refine reads;
+     * equality tests still judge the declared domain (storageType).
+     */
+    assignedFact?: boolean;
+    reactiveKind?: "state" | "prop";
+    /**
+     * D51 rule 101: the binding holds — or carries — a resource this scope owns
+     * and releases at its exit. `handle` is the `using` name to blame, and
+     * `depth` is the scope nesting level that releases it, so a store into any
+     * shallower binding is a store into something that outlives the release.
+     */
+    ownedResource?: {
+        readonly handle: string;
+        readonly depth: number;
+    };
+}
+interface AnalyzableFunctionDeclaration {
+    readonly kind: string;
+    readonly name: string;
+    readonly typeParameters?: readonly TypeParameterDeclaration[];
+    readonly parameters: FunctionDeclaration["parameters"];
+    readonly returnType: FunctionDeclaration["returnType"];
+    readonly resultAnnotationSpan?: FunctionDeclaration["resultAnnotationSpan"];
+    readonly signatureSpan: FunctionDeclaration["signatureSpan"];
+    readonly body: FunctionDeclaration["body"];
+    readonly span: Span;
+    readonly asynchronous?: boolean;
+}
+export interface ClassField {
+    readonly mutable: boolean;
+    readonly type: ValueType;
+}
+export interface ClassInfo {
+    readonly identity?: string;
+    /** D43 item 69: the class declares `@dispose:`, and whether releasing awaits. */
+    readonly dispose?: "sync" | "async";
+    /**
+     * D68 rule 177: the collection the class's own `@iterate:` block answers
+     * with. Absent when the class declares no block — a derived class reads its
+     * base's answer instead of copying it, because overriding replaces rather
+     * than composes.
+     */
+    readonly iterate?: ValueType;
+    readonly parameters: readonly ValueType[];
+    readonly parameterNames?: readonly string[];
+    readonly requiredParameters: number;
+    readonly constructorRest?: ValueType;
+    readonly base: string | null;
+    readonly abstract: boolean;
+    readonly fields: ReadonlyMap<string, ClassField>;
+    readonly getters: ReadonlySet<string>;
+    readonly abstractGetters: ReadonlySet<string>;
+    readonly methods: ReadonlyMap<string, ValueType>;
+    readonly abstractMethods: ReadonlySet<string>;
+    readonly staticFields: ReadonlyMap<string, ClassField>;
+    readonly staticGetters: ReadonlySet<string>;
+    readonly staticMethods: ReadonlyMap<string, ValueType>;
+}
+export type CollectionOperation = "get" | "slice" | "listAppend" | "listExtend" | "listInsert" | "listRemove" | "listPop" | "listCopy" | "listCount" | "listIndex" | "listFind" | "listSome" | "listEvery" | "listMap" | "listFilter" | "listFlatMap" | "listReduce" | "listJoin" | "listSorted" | "listReversed" | "listSum" | "listMin" | "listMax" | "setAdd" | "setUpdate" | "setCopy" | "setUnion" | "setIntersection" | "setDifference" | "mapSet" | "mapUpdate" | "mapCopy" | "recordSet" | "recordCopy" | "has" | "remove" | "clear" | "keys" | "values" | "entries";
+export type PrimitiveOperation = "stringTrim" | "stringUpper" | "stringLower" | "stringSlice" | "stringChar" | "stringHas" | "stringIndex" | "stringCount" | "stringStartsWith" | "stringEndsWith" | "stringSplit" | "stringReplace" | "stringReplaceAll" | "stringPadStart" | "stringPadEnd" | "stringRepeat" | "stringIsBlank" | "numberAbs" | "numberRound" | "numberFloor" | "numberCeil" | "numberToFixed" | "numberIsInteger" | "numberIsNaN" | "numberIsFinite";
+export interface FormReadField {
+    readonly name: string;
+    readonly kind: "string" | "number" | "bool" | "enum" | "strings";
+    readonly optional: boolean;
+    readonly enumValues?: readonly string[];
+}
+export interface LoweringHints {
+    readonly collectionCalls: ReadonlyMap<number, CollectionOperation>;
+    readonly collectionSizes: ReadonlySet<number>;
+    /** Binary members and indexes lower directly against their typed-array storage. */
+    readonly binaryCalls: ReadonlyMap<number, "bufferCopy" | "bufferSlice" | "bufferToBytes">;
+    readonly binarySizes: ReadonlyMap<number, BinaryStorageKind>;
+    readonly binaryIndexes: ReadonlyMap<string, BinaryStorageKind>;
+    readonly primitiveCalls: ReadonlyMap<number, PrimitiveOperation>;
+    readonly stringSizes: ReadonlySet<number>;
+    readonly constructorCalls: ReadonlySet<string>;
+    readonly javaScriptCallBoundaries: ReadonlySet<string>;
+    readonly classChecks: ReadonlySet<string>;
+    readonly privateMembers: ReadonlySet<string>;
+    readonly classNames: ReadonlySet<string>;
+    /** Class names whose chain reaches the builtin Error — their lowering stamps `.name` (audit 4 micro-ruling). */
+    readonly errorSubclassNames: ReadonlySet<string>;
+    readonly enumNames: ReadonlySet<string>;
+    /**
+     * Module-scope bindings that hold runtime Type objects: local `type`
+     * declarations and aliases, plus imported ones. A narrowing recheck for any
+     * of these names may call `Name.is(value)` — the exporting module always
+     * emits the validator object for an exported type. Names outside this set
+     * (erased generics, extension host types such as DOM interfaces) have no
+     * such binding and keep the presence-only recheck.
+     */
+    readonly runtimeTypeObjectNames: ReadonlySet<string>;
+    /**
+     * D55 rule 121: module-scope names bound to a generic record's instantiation
+     * factory, local or imported. A generic name is *not* a Type object — it
+     * answers `.of(...)`, never `.is(...)` — so the emitter has to tell the two
+     * apart before it writes either into the output.
+     */
+    readonly genericTypeNames: ReadonlySet<string>;
+    readonly optionalMembers: ReadonlySet<string>;
+    readonly optionalCalls: ReadonlySet<string>;
+    readonly optionalIndexes: ReadonlySet<string>;
+    readonly optionalCallees: ReadonlySet<string>;
+    readonly truthConditions: ReadonlySet<string>;
+    readonly normalizedNullResults: ReadonlySet<string>;
+    readonly normalizedPromiseValues: ReadonlySet<string>;
+    readonly asyncResolvedValues: ReadonlySet<string>;
+    readonly asyncForStatements: ReadonlySet<number>;
+    /** Direct, unshadowed `for name in range(...)` loops that can use a counted loop. */
+    readonly nativeRangeForStatements: ReadonlySet<number>;
+    readonly normalizedUndefinedExpressions: ReadonlySet<string>;
+    readonly instanceFieldReads: ReadonlySet<string>;
+    readonly errorCodeReads: ReadonlySet<string>;
+    readonly privateInstanceFieldReads: ReadonlySet<string>;
+    readonly staticFieldReads: ReadonlyMap<string, number>;
+    /**
+     * Member spans that read a class method as a value rather than calling it.
+     * Methods live on the prototype, so these emit as receiver-evaluated-once
+     * plus a bind at the reference site (charter sections 8 and 18).
+     */
+    readonly classMethodReferences: ReadonlySet<string>;
+    readonly optionalBindingEntries: ReadonlySet<number>;
+    readonly reactiveReferences: ReadonlyMap<string, "state" | "prop">;
+    readonly enumValueBindings: ReadonlyMap<number, string>;
+    readonly exhaustiveMatches: ReadonlySet<number>;
+    readonly formReads: ReadonlyMap<string, readonly FormReadField[]>;
+    readonly namedArgumentOrders: ReadonlyMap<string, readonly number[]>;
+    readonly extensionLiterals: ReadonlyMap<string, string>;
+    readonly extensionCalls: ReadonlyMap<string, string>;
+    /** Prelude and permanent-namespace reads, keyed by span so lexical shadows win. */
+    readonly builtinValueReferences: ReadonlyMap<string, PermanentNamespaceName | "range">;
+    readonly runtimeNarrowings: ReadonlyMap<string, RuntimeNarrowingGuard>;
+    /**
+     * Span identities of `==`/`!=` operations (and comparison-chain links)
+     * whose operands may both be NaN at runtime. These lower to SameValueZero;
+     * every other equality elides the repair and emits plain `===` (D36 item 41).
+     */
+    readonly sameValueZeroEqualities: ReadonlySet<string>;
+    /**
+     * Span identities of match value candidates that must compare by
+     * SameValueZero — the subject and the candidate can both be NaN — so
+     * `case box.nan:` agrees with `==` (ENM-D2, charter section 8). Everything
+     * else keeps plain `===`.
+     */
+    readonly sameValueZeroMatchValues: ReadonlySet<string>;
+    /** Span identities of calls to the prelude's equals(a, b) (D47 rule 81). */
+    readonly equalsCalls: ReadonlySet<string>;
+    /**
+     * Span identities of ordered comparisons (`< <= > >=`, including
+     * comparison-chain links) whose operands are strings. These lower through
+     * the code-point comparator so string order is code-point order everywhere
+     * (TXT-D1); number comparisons keep the plain operator.
+     */
+    readonly stringOrderings: ReadonlySet<string>;
+    /**
+     * Span identities of ordered comparisons between `Comparable`-bounded type
+     * parameters (D41 item 61). The runtime category is not known statically,
+     * so these lower through the dispatching comparator, which keeps a string
+     * pair in code-point order exactly as a monomorphic string comparison is.
+     */
+    readonly dynamicOrderings: ReadonlySet<string>;
+    /**
+     * How each `using` statement releases its value, keyed by the statement's
+     * span identity (D43 item 69). The analyzer resolves the contract because it
+     * is the only stage that knows the value's type.
+     */
+    readonly usingDisposals: ReadonlyMap<string, DisposalContract>;
+    /**
+     * Class declarations whose `@dispose:` must forward to an inherited one
+     * (D51 rule 102), keyed by the declaration's span identity. The value is the
+     * inherited release's async-ness, which decides whether the forward awaits.
+     */
+    readonly classDisposeChains: ReadonlyMap<string, "sync" | "async">;
+    /**
+     * D68 rule 177: span identities of the expressions a consumer iterates
+     * through a class's `@iterate:` contract — the eight sites that consume an
+     * iterable. The emitter projects each one through the contract member, so
+     * what the runtime receives is the List, Set, Map, or Record the block
+     * returns and every consumer keeps the lowering it already had.
+     */
+    readonly iterationContracts: ReadonlySet<string>;
+    /**
+     * Span identities of JavaScript-boundary calls in synchronous
+     * module-initialization position. A non-Error value thrown there would
+     * reach the host uncaught and unnormalized — the last unowned failure
+     * shape at the bridge — so these sites rethrow through the owned Error
+     * normalization channel (BRG-U10).
+     */
+    readonly moduleTopLevelHostCalls: ReadonlySet<string>;
+}
+export interface RuntimeNarrowingGuard {
+    readonly expected: ValueType;
+    readonly description: string;
+}
+export interface AnalysisContext {
+    readonly imports?: ReadonlyMap<string, ValueType>;
+    readonly dynamicImports?: ReadonlyMap<string, ValueType>;
+    readonly reactiveImports?: ReadonlyMap<string, "state">;
+    readonly namedTypes?: ReadonlyMap<string, ReadonlyMap<string, ValueType>>;
+    readonly namedTypeReadonlyFields?: ReadonlyMap<string, ReadonlySet<string>>;
+    readonly namedTypeIdentities?: ReadonlyMap<string, string>;
+    /** D55: imported generic record declarations, by the name this module writes. */
+    readonly genericTypes?: ReadonlyMap<string, GenericTypeInfo>;
+    readonly typeAliases?: ReadonlyMap<string, ValueType>;
+    readonly enums?: ReadonlyMap<string, EnumInfo>;
+    readonly classes?: ReadonlyMap<string, ClassInfo>;
+    readonly extensionImports?: ReadonlyMap<string, ReadonlyMap<string, unknown>>;
+    readonly extensionModules?: ReadonlyMap<string, readonly unknown[]>;
+    readonly resources?: ReadonlyMap<string, string>;
+    /** Compiler-owned seeds used while omitted function results converge. */
+    readonly inferredFunctionResults?: ReadonlyMap<string, ValueType>;
+    /** True only for the final semantic pass after result inference converges. */
+    readonly finalizeFunctionResultInference?: boolean;
+    /** The module's own path; `test "name":` is only declared in a `*.test.vel` module. */
+    readonly path?: string;
+}
+/**
+ * A direct read of an imported binding from a module-initialization position
+ * (top-level initializers and expression statements, static class fields,
+ * extension top-level initializers). The project driver combines these with
+ * the module graph to reject import cycles whose source module has not
+ * evaluated when the read runs (D31 item 23).
+ */
+export interface InitializationImportRead {
+    readonly local: string;
+    readonly source: string;
+    /**
+     * The name the source module exports, which may differ from `local`. The
+     * project driver follows it through re-export barrels to the module that
+     * actually declares the binding; a namespace import has no single name and
+     * records null.
+     */
+    readonly imported: string | null;
+    readonly span: Span;
+}
+export declare const inferredResultPlaceholderType: ValueType;
+/**
+ * D43 item 69: the emitted member behind a class's `@dispose:` block. The key
+ * is not a source-shaped identifier, so no author member can collide with it —
+ * `@dispose` is the language's name, not a name in the author's namespace.
+ */
+export declare const disposeMemberKey = "__velar:dispose";
+/**
+ * D68 rule 177: the emitted member behind a class's `@iterate:` block, under
+ * the same kind of key and for the same reason — `@iterate` is the language's
+ * name for the question, so no author member can answer it by accident and no
+ * author call can reach it.
+ */
+export declare const iterateMemberKey = "__velar:iterate";
+/** How a `using` binding releases its value at scope exit. */
+export interface DisposalContract {
+    readonly member: string;
+    readonly asynchronous: boolean;
+    readonly owner: "class" | "capability";
+}
+export declare const TEXT_NAMESPACE_MEMBERS: readonly string[];
+export declare const MATH_NAMESPACE_MEMBERS: readonly string[];
+/**
+ * D57 rule 136: the permanent namespace that reaches every export of a retired
+ * standard module, or null while the module still publishes something of its
+ * own. Derived from the roster VEL3008 rejects imports with, so a diagnostic
+ * cannot list a module as importable after its members moved behind a prefix.
+ */
+export declare function permanentNamespaceCoveringModule(source: string, exports: Iterable<string>): PermanentNamespaceName | null;
+export declare function isCorePrimitiveName(name: string): boolean;
+export declare class Analyzer implements TypeEnvironment {
+    protected readonly diagnostics: Diagnostic[];
+    private readonly scopes;
+    private readonly memberNarrowings;
+    private readonly namedTypes;
+    private readonly namedTypeReadonlyFields;
+    private readonly namedTypeIdentities;
+    /** D55: generic record declarations in scope, by the name this module writes. */
+    private readonly genericTypes;
+    /** The same declarations by identity, so a substituted application can be re-instantiated. */
+    private readonly genericTypesByIdentity;
+    /** Every instantiation seen, by identity, waiting for its field table to be asked for. */
+    private readonly genericApplications;
+    /** One canonical object per instantiation, so identity-keyed cycle guards still cut. */
+    private readonly canonicalGenericApplications;
+    private readonly typeAliases;
+    private readonly invalidDeclaredTypes;
+    private readonly typeReferenceValidity;
+    private readonly typeParameterFrames;
+    private readonly typeParameterFrameBounds;
+    private readonly invalidExternTypeReferences;
+    private readonly enums;
+    private readonly classes;
+    private readonly classDisplayNames;
+    private readonly externModules;
+    private readonly externTypeImports;
+    private readonly externClassDeclarations;
+    private readonly returnContexts;
+    private readonly asynchronousFunctions;
+    private readonly collectionCalls;
+    private readonly collectionSizes;
+    private readonly binaryCalls;
+    private readonly binarySizes;
+    private readonly binaryIndexes;
+    private readonly primitiveCalls;
+    private readonly sameValueZeroEqualities;
+    private readonly sameValueZeroMatchValues;
+    private readonly equalsCalls;
+    private readonly stringOrderings;
+    private readonly dynamicOrderings;
+    private readonly reportedBoundViolations;
+    private readonly usingDisposals;
+    private readonly classDisposeChains;
+    /** D68 rule 177: expression spans a consumer iterates through `@iterate:`. */
+    private readonly iterationContracts;
+    /**
+     * D68 rule 177: the function depth of each `@iterate:` body being analyzed.
+     * A nested arrow inside the block is an ordinary callable and keeps the
+     * ordinary advice, so the contract's own message needs the exact depth.
+     */
+    private readonly iterateContractDepths;
+    /** D51 rule 101: arrows that read a `using`-owned binding, by arrow span. */
+    private readonly arrowOwnedCaptures;
+    private readonly arrowCaptureFrames;
+    private readonly declaredTestTitles;
+    private readonly moduleTopLevelHostCalls;
+    private readonly stringSizes;
+    private readonly constructorCalls;
+    private readonly javaScriptBindings;
+    private readonly javaScriptCallBoundaries;
+    private readonly classChecks;
+    private readonly privateMembers;
+    private readonly optionalMembers;
+    private readonly optionalCalls;
+    private readonly optionalIndexes;
+    private readonly optionalCallees;
+    private readonly constructorFieldInitializations;
+    private readonly truthConditions;
+    private readonly normalizedNullResults;
+    private readonly normalizedPromiseValues;
+    private readonly asyncResolvedValues;
+    private readonly asyncForStatements;
+    private readonly nativeRangeForStatements;
+    private readonly nonFallthroughWhileStatements;
+    private readonly reportedPromiseResolutionHazards;
+    private readonly normalizedUndefinedExpressions;
+    private readonly instanceFieldReads;
+    private readonly errorCodeReads;
+    private readonly privateInstanceFieldReads;
+    private readonly staticFieldReads;
+    private readonly classMethodReferences;
+    private readonly callExpressionCallees;
+    private readonly memberAccessReceivers;
+    private readonly readonlyClassScanVerdicts;
+    private readonly optionalBindingEntries;
+    protected readonly reactiveBindings: Map<string, "state">;
+    private readonly reactiveReferences;
+    private readonly pendingScopeDeclarations;
+    private readonly reportedShadowedReads;
+    protected readonly enumValueBindings: Map<number, string>;
+    private readonly exhaustiveMatches;
+    private readonly formReads;
+    private readonly namedArgumentOrders;
+    protected readonly extensionLiterals: Map<string, string>;
+    protected readonly extensionCalls: Map<string, string>;
+    private readonly builtinValueReferences;
+    private readonly semanticBindingTypes;
+    private readonly semanticBindingMembers;
+    private readonly semanticMemberCache;
+    private readonly semanticExpressionTypes;
+    private readonly semanticExpressionMembers;
+    private readonly semanticExpressionOwners;
+    private readonly semanticObjectPropertyOwners;
+    private readonly semanticBindingEntryOwners;
+    protected readonly semanticJsxAttributeOwners: Map<string, ValueType>;
+    private readonly semanticExpressionContexts;
+    private readonly semanticExpressionContextMembers;
+    private readonly contextualAssignments;
+    private readonly inferredExpressionTypes;
+    private readonly runtimeNarrowings;
+    private readonly inferredFunctionResultSeeds;
+    private readonly inferredFunctionResultTypes;
+    private readonly finalizeFunctionResultInference;
+    private readonly logicalConditionNarrowings;
+    private readonly collectionInferenceGroups;
+    private readonly collectionInferenceTypes;
+    private readonly privateFields;
+    private readonly privateGetters;
+    private readonly privateMethods;
+    private readonly privateStaticFields;
+    private readonly privateStaticGetters;
+    private readonly privateStaticMethods;
+    private readonly predeclared;
+    private functionDepth;
+    private parameterDefaultDepth;
+    private loopDepth;
+    private finallyLoopDepths;
+    private unreachableDiagnosticDepth;
+    private readonly loopFlowContexts;
+    private loopCaptureFloor;
+    private currentClass;
+    private superMemberContext;
+    private classFieldInitializerDepth;
+    private instanceFieldInitializerDepth;
+    protected deferredExecutionDepth: number;
+    private readonly importedBindingSources;
+    private readonly importedBindingOrigins;
+    /** Namespace import locals by name, known before signature validation runs (ENM-I9 teaching). */
+    private readonly namespaceImportLocals;
+    private readonly initializationImportReadSites;
+    /** Local class bindings mapped to the source offset where their `class` statement evaluates (CLS-D8). */
+    private readonly hoistedClassDeclarations;
+    /** Module-scope names bound to runtime Type objects (local and imported); see LoweringHints.runtimeTypeObjectNames. */
+    private readonly runtimeTypeObjectNames;
+    private staticFieldInitialization;
+    protected constructorDepth: number;
+    private allowedSuperCall;
+    protected flowFrameDepth: number;
+    private readonly primitiveNames;
+    private readonly primitiveParents;
+    private readonly primitiveMutableFields;
+    private readonly extensionGlobals;
+    private readonly extensionReservedBindings;
+    private readonly globalGuidance;
+    private readonly scopedGlobalGuidance;
+    private readonly analysisExtensions;
+    private readonly retiredNamespaces;
+    /** Every `Retired.member` read, collected so one migration can carry the whole rewrite. */
+    private readonly retiredNamespaceUses;
+    /** The property each member access asks for, keyed by the receiver's span. */
+    private readonly memberAccessProperties;
+    /** Every name this module declares anywhere, so a rewrite can prove it collides with nothing. */
+    private readonly declaredNames;
+    private readonly promiseInitializerBindings;
+    private readonly testExpectOperands;
+    /** D52 rule 116: reads of a name imported from a module that has a permanent namespace. */
+    private readonly permanentNamespaceImportReads;
+    /** The import each such local came from, keyed by the local name. */
+    private readonly permanentNamespaceImportOrigins;
+    constructor(context?: AnalysisContext, extensions?: readonly CompilerAnalysisExtension[]);
+    /**
+     * The guidance a reserved global earns where it was written. A module path
+     * suffix selects the door that is actually open there before the module-wide
+     * answer applies.
+     */
+    private guidanceForGlobal;
+    private nearestVisibleBindingName;
+    private readonly modulePath;
+    private readonly importBindings;
+    private readonly dynamicImports;
+    analyze(program: Program): readonly Diagnostic[];
+    private registerExternTypeImports;
+    private validateDataTypeDeclarations;
+    private validateCoreDeclarationSignatures;
+    private typeSyntaxReferencesInvalidDeclaration;
+    private rejectUnproductiveRecursiveTypes;
+    private predeclareTopLevel;
+    private registerExternClassDeclarations;
+    private validateExternDeclarations;
+    private validateReExports;
+    private registerExternModules;
+    loweringHints(): LoweringHints;
+    semanticTypes(): ReadonlyMap<string, ValueType>;
+    inferredFunctionResults(): ReadonlyMap<string, ValueType>;
+    static inferredFunctionResultsMatch(left: ReadonlyMap<string, ValueType>, right: ReadonlyMap<string, ValueType>): boolean;
+    semanticMembers(): ReadonlyMap<string, ReadonlyMap<string, ValueType>>;
+    analyzedClasses(): ReadonlyMap<string, ClassInfo>;
+    semanticExpressions(): {
+        readonly types: ReadonlyMap<string, ValueType>;
+        readonly members: ReadonlyMap<string, ReadonlyMap<string, ValueType>>;
+        readonly owners: ReadonlyMap<string, ValueType>;
+        readonly objectPropertyOwners: ReadonlyMap<string, ValueType>;
+        readonly bindingEntryOwners: ReadonlyMap<string, ValueType>;
+        readonly jsxAttributeOwners: ReadonlyMap<string, ValueType>;
+        readonly contexts: ReadonlyMap<string, ValueType>;
+        readonly contextMembers: ReadonlyMap<string, ReadonlyMap<string, ValueType>>;
+    };
+    fieldsOf(identity: string): ReadonlyMap<string, ValueType> | null;
+    /**
+     * D55 rule 121: an instantiation's field table is the declaration's fields
+     * with the arguments substituted, registered under the instantiation's own
+     * identity. Computing it on demand rather than at the point the application
+     * was written is what makes `type Tree<T>: kids: List<Tree<T>>` terminate:
+     * the application is *noted* while the declaration is still being read, and
+     * substituted only once someone asks, by which time the template is whole.
+     * Substitution rebuilds nested applications through the same constructor, so
+     * each one is noted in turn and the walk is finite in the number of distinct
+     * instantiations — homogeneous recursion reaches its fixed point, and rule
+     * 125's declaration-site rule is what stops a polymorphic one from existing.
+     */
+    private instantiateGenericFields;
+    /**
+     * Records every generic application inside a type so its field table can be
+     * built on demand. Called wherever an application can first become visible —
+     * a resolved annotation, an imported binding, a substituted field — because a
+     * missed site is an instantiation whose fields silently read as "not a
+     * record" (the batch M failure shape, one layer out).
+     */
+    private noteGenericApplications;
+    /** The generic record a name in this module refers to, local or imported. */
+    protected genericTypeInfo(name: string): GenericTypeInfo | null;
+    /**
+     * D55 rule 121: the one place an application written in this module becomes
+     * canonical — declaration identity, display text, instantiation identity, and
+     * the note that lets its field table be built. Every path that can be the
+     * first to see an application calls this, so none of them can produce a
+     * half-resolved one.
+     */
+    private resolveGenericApplication;
+    /**
+     * D55 rules 124 and 126: everything an instantiation has to answer for at the
+     * place it is written — arity, the declared bounds, and the one argument
+     * shape a runtime-validated record can never hold.
+     */
+    private validateGenericApplication;
+    /**
+     * D55 rule 125: a generic record's reference to a declaration in its own
+     * recursive group must pass that group's parameters straight through.
+     * `type Tree<T>: kids: List<Tree<T>>` is homogeneous — `Tree<string>` needs
+     * only `Tree<string>`, and monomorphization reaches its fixed point. The
+     * refused shape, `type Bad<T>: next: Bad<List<T>>?`, demands
+     * `Bad<List<string>>`, `Bad<List<List<string>>>`, without end. The rule is
+     * checked here, on the line that declares it, because an instantiation-depth
+     * limit could only say "too deep" at some later call — the undirected
+     * diagnostic family D42 spent its length removing.
+     */
+    private rejectPolymorphicRecursion;
+    isExtensionTypeAssignable(actual: ExtensionValueType, expected: ExtensionValueType, assign: (actual: ValueType, expected: ValueType) => boolean): boolean | undefined;
+    extensionTextForm(type: ValueType): boolean | undefined;
+    protected readonlyDataViewOf(type: ValueType): ValueType;
+    readonlyFieldsOf(identity: string): ReadonlySet<string> | null;
+    /**
+     * D44 rule 72: `readonly T` promises that everything reachable through the
+     * view is protected data, so a class type at any depth is rejected at the
+     * declaration site — otherwise the promise would silently end at the class
+     * member. Bare type parameters stay legal (opacity is as good as
+     * immutability), `unknown`/`any` are already where static promises end, and
+     * function types are behavior boundaries whose signatures are not data.
+     * Named records are memoized per identity; a verdict computed through a
+     * recursion cut stays local to that traversal so shared types keep sound
+     * cached answers.
+     */
+    protected findClassInReadonlyData(type: ValueType, seen?: Set<string>, sawCycle?: {
+        cut: boolean;
+    }): {
+        readonly suffix: string;
+        readonly className: string;
+    } | null;
+    protected predeclareExtensionStatement(_statement: Statement): boolean;
+    protected analyzeExtensionStatement(_statement: Statement): boolean;
+    protected extensionExpressionContainsDirectAwait(expression: Expression, contains: (expression: Expression) => boolean): boolean | undefined;
+    protected extensionStatementContainsDirectAwait(statement: Statement, containsExpression: (expression: Expression) => boolean, containsBlock: (statements: readonly Statement[]) => boolean): boolean | undefined;
+    protected prescanExtensionScopeDeclaration(_statement: Statement): {
+        readonly name: string;
+        readonly span: Span;
+    } | null;
+    protected inferExtensionExpression(_expression: Expression, _contextualType: ValueType): ValueType | undefined;
+    protected inferExtensionCall(_callee: ExtensionValueType, _arguments: readonly Expression[], _argumentNames: readonly (string | null)[] | undefined, _callSpan: Span): ValueType | undefined;
+    protected validateExtensionTypeSyntax(_syntax: TypeSyntax, _validate: (syntax: TypeSyntax) => boolean, _resolve: (reference: TypeReference) => ValueType): boolean | undefined;
+    protected extensionFieldsOf(_name: string): ReadonlyMap<string, ValueType> | null;
+    protected invalidExtensionAwaitContext(): boolean;
+    protected invalidExtensionAwaitMessage(): string | null;
+    protected isTopLevelScope(): boolean;
+    protected isPredeclared(statement: object): boolean;
+    isSubclassOf(actual: string, expected: string): boolean;
+    isPrimitiveType(name: string): boolean;
+    isPrimitiveSubtype(actual: string, expected: string): boolean;
+    /**
+     * D51 rule 109: `Comparable`, `Text`, and `Data` are the compiler's own
+     * closed bound vocabulary (D41 item 61). A user type of the same name used to
+     * be accepted and then silently ignored at every `<T: Data>` — the bound won,
+     * so `save(42)` passed a function whose author had declared a record. The
+     * name is rejected where it is introduced, which is the only place a rename
+     * is cheap; the use site could only report an ambiguity nobody can fix.
+     */
+    private rejectReservedTypeNames;
+    private registerAliasShapes;
+    protected expandAliases(type: ValueType, seen?: ReadonlySet<string>): ValueType;
+    /**
+     * D55 rule 120: generic record declarations are registered in two steps —
+     * every name and parameter list first, then the field types. A field type may
+     * apply another generic record, or this one, and neither could be resolved if
+     * the declarations were read one at a time.
+     */
+    private registerGenericTypeShapes;
+    private registerTypeShapes;
+    private registerEnumShapes;
+    private registerClassNames;
+    private registerClassShapes;
+    protected analyzeStatement(statement: Statement): void;
+    private checkFloatingPromiseStatement;
+    private checkDiscardedExpressionResult;
+    private carriesPromise;
+    private checkDiscardedPureResult;
+    private callSpelling;
+    private analyzeAsyncStatement;
+    private analyzeTypeDeclaration;
+    private analyzeTypeAliasDeclaration;
+    private analyzeClassDeclaration;
+    /**
+     * D51 item NEW-D7: `name`, `code`, `message`, `stack`, and `cause` are the
+     * Error contract's own members, not names a subclass may reuse. The generic
+     * inherited-field check let a `const` through whenever it restated the same
+     * type — and that spelling forged `code` (charter 2070 promises `code` and
+     * `name` never disagree) or silently discarded the constructed message.
+     */
+    private errorContractMemberRejection;
+    private validateClassMemberName;
+    private analyzeClassInitialization;
+    /**
+     * D39 item 53: `test "name":` is one test. Its body is an async frame — a
+     * test awaits its own work — and its name is the product specification a
+     * person reads, so it must be present, unique in the module, and declared
+     * where the runner actually looks.
+     */
+    private analyzeTestDeclaration;
+    /**
+     * D43 item 69: `using name = expression` claims ownership of a resource for
+     * the enclosing scope. The value's type must declare the release contract,
+     * the scope must be able to run it, and the module top level — which lives
+     * until the process ends — has no scope exit to release at.
+     */
+    private analyzeUsingDeclaration;
+    /**
+     * D51 rule 101: an owned resource may not leave the scope that releases it.
+     * `using` means "this scope owns it and guarantees the release", so letting
+     * the value out hands back a reference that is already known to be dead —
+     * which is the construct's definition, not a restriction on top of it. The
+     * judgement is *storage and return*, never use: passing the handle to a
+     * function stays legal, because a callee borrows and must not assume
+     * ownership. Returns the owned binding an expression carries, or null.
+     */
+    private carriedOwnedResource;
+    /** The scope nesting level a name is declared at, or 0 when it is not a local. */
+    private bindingScopeDepth;
+    private rejectOwnedResourceEscape;
+    /**
+     * The release contract of a value's type: a class's own `@dispose:` block, or
+     * a standard capability handle, which delegates to the verb it already
+     * publishes (`close()` or `stop()`) rather than being renamed for `using`.
+     */
+    private disposalContract;
+    /**
+     * D51 rule 102 + item NEW-D4. Rule 102 makes the compiler chain a derived
+     * `@dispose:` into its base's, so the emitter is told which classes forward
+     * and whether the forwarded release awaits. NEW-D4 is the soundness half:
+     * `using` reads the release contract off the *static* type, so a subclass
+     * that starts awaiting where its ancestors do not would be released without
+     * an await through a base-typed binding — an unhandled rejection that kills
+     * the process. Adding `await` downward is therefore rejected at the subclass;
+     * an ancestor that already awaits carries every descendant with it.
+     */
+    private checkDisposalChain;
+    /** Every `@dispose:` a class releases through, most derived first (D51 rule 102). */
+    private disposalChain;
+    /**
+     * D43 item 69 rule 6: `using` needs a scope exit to release at. The module
+     * top level has none — it lives until the process ends. An extension whose
+     * body is not an ordinary scope adds its own answer.
+     */
+    protected ownershipScopeRejection(): string | null;
+    private disposalGuidance;
+    /**
+     * D43 item 69: the `@dispose:` body is a release contract, not a method. It
+     * runs with `self` in scope and may `await`; whether it actually does is what
+     * decides that a `using` of this class needs an async scope.
+     */
+    private analyzeClassDispose;
+    /** D68 rule 177: the convergence key of one `@iterate:` block. */
+    private iterationResultKey;
+    /**
+     * D68 rule 177: `@iterate:` carries no result annotation — the block *is* the
+     * answer — so the class shape pre-pass reads what the previous convergence
+     * pass learned. Without the seed, a use written above the class would see an
+     * unresolved placeholder, which is the same problem an omitted function
+     * result has and gets the same solution.
+     */
+    private seededIterationSource;
+    /**
+     * D68 rule 177: `@iterate:` answers the language's question "what does
+     * iterating you mean?" with a collection the language already iterates. It
+     * shares `@dispose:`'s path because it is the same kind of member — a
+     * contract, not a method — and it differs in exactly two ways, both forced:
+     * it produces a value, and it may not `await`, because every one of the eight
+     * consumers reads it synchronously.
+     */
+    private analyzeClassIterate;
+    /**
+     * The four collections are the whole answer space: the block says "iterating
+     * me is iterating this", and the language already fixed what iterating a
+     * List, Set, Map, or Record means. Anything else would be a second iteration
+     * semantics, which is the thing charter section 19 keeps out.
+     */
+    private validatedIterationSource;
+    /** The `@iterate:` answer a class inherits, most derived ancestor first. */
+    private inheritedIterationSource;
+    /**
+     * D68 rule 177: what iterating this value means. A class answers through
+     * `@iterate:` — its own, or the one it inherits, because overriding replaces
+     * a single answer instead of composing a chain the way `@dispose:` does.
+     */
+    private iterationContract;
+    /**
+     * Projects one consumer's operand through `@iterate:` and records the span so
+     * the emitter projects it too. Every consumer of an iterable calls this, so
+     * `for item in bag` and `item in bag` can never disagree about whether a
+     * class participates — D68 names that split as the trap this design exists to
+     * avoid.
+     */
+    private iterationSource;
+    /**
+     * The one sentence that teaches the contract, appended wherever a consumer
+     * refuses a class. A class that already declares `@iterate:` gets nothing:
+     * its own block carries the precise diagnostic.
+     */
+    private iterationGuidance;
+    private validateConstructorShape;
+    private validateMethodSignature;
+    private findField;
+    private findGetter;
+    private findMethod;
+    private asyncPullElementType;
+    private findStaticField;
+    private findStaticFieldOwner;
+    private findStaticGetter;
+    private findStaticMethod;
+    private privateFieldForAccess;
+    private privateMethodForAccess;
+    private declaresPrivateMember;
+    private unimplementedAbstractMethods;
+    /**
+     * D58 rule 139: `-> null` is the one result annotation that names nothing a
+     * caller can use — a caller that ignores a result already knows as much — so
+     * where a body infers exactly that, the annotation is two spellings of one
+     * declaration and the written one is refused. `extern` declarations,
+     * abstract methods, and function types have no body to infer from and keep
+     * declaring it (VEL4023, VEL2001), and a getter's result is the property's
+     * type, which the parser requires outright (VEL2023).
+     *
+     * Deleting an annotation the compiler would infer identically is provably
+     * equivalent, so it is a mechanical fix under D50 rule 95 — but only there.
+     * D58 correction 2: where the body returns a value, the deletion is not
+     * equivalent, it widens the signature and takes VEL4001 down with it, so the
+     * refusal is reported without a fix and the author decides whether the body
+     * or the intent was wrong. `velar fix` runs unattended because it never does
+     * the second kind of thing.
+     *
+     * D64 rule 162: dropping the fix was only half of that correction. The
+     * message still said "delete the annotation" — the one move the ruling had
+     * just refused to make — so the diagnostic taught an exit it rejects on the
+     * next step, which is the D57 rule 136 shape. The two cases now carry two
+     * messages: where the body does infer null the deletion is the answer, and
+     * where it does not, the disagreement between the body and the annotation is
+     * the answer, and deleting would only widen the signature to hide it.
+     */
+    private inferredNullResultAnnotation;
+    private reportInferredNullResult;
+    protected analyzeFunctionDeclaration(statement: AnalyzableFunctionDeclaration, className: string | null, method?: boolean, declareSelf?: boolean, forceAsynchronous?: boolean, declarationKind?: string): void;
+    protected analyzeBlock(statements: readonly Statement[], narrowed?: ReadonlyMap<string, ValueType>): ReadonlyMap<string, ValueType>;
+    private survivingNarrowings;
+    protected analyzeStatements(statements: readonly Statement[]): void;
+    private analyzeAssignment;
+    private primitiveFieldWritable;
+    protected inferExpression(expression: Expression, contextualType?: ValueType): ValueType;
+    private inferredOrAnalyze;
+    private hasNullishContract;
+    private expressionAlreadyNormalizesUndefined;
+    private shouldNormalizeNullish;
+    private recordSemanticExpression;
+    /**
+     * CLS-I1: the positions where `self` does not exist, and why. A field
+     * initializer runs while the instance is still being assembled, so there is
+     * no complete `self` to read; a static member belongs to the class and has
+     * no instance at all. Outside a class the word is simply an unknown name and
+     * keeps the ordinary message.
+     */
+    private unavailableSelfGuidance;
+    private inferExpressionType;
+    private isCoreDurationLiteral;
+    private containsCoreDuration;
+    private inferCoreDurationExpression;
+    private inferBinary;
+    private requireIntersectingEquality;
+    private rejectFreshCollectionEquality;
+    private freshCollectionOperand;
+    private requireMembershipIntersection;
+    private rejectDisjointEnumTest;
+    /** The enum/null arms of a type, or null when any arm falls outside that domain. */
+    private pureEnumDomainArms;
+    private rejectDisjointEnumValidatorProbe;
+    private enumTargetOfValidatorObject;
+    /** The enum behind a type alias name, or null when the alias does not resolve to an enum. */
+    private aliasedEnumTarget;
+    private rejectCollidingKeyDomain;
+    /**
+     * The declared domain behind an assignment-established fact: what a test
+     * (`== null`, `??`) judges, and what an unannotated alias declares. Returns
+     * the inferred type unchanged when the expression's narrowing came from a
+     * check (or from nothing).
+     */
+    private assignedFactDomain;
+    private equalityTypesIntersect;
+    private typesIntersect;
+    private equalityGuidance;
+    private valueLevelEnum;
+    private hasValueLevelString;
+    private equalityOperandMayBeNaN;
+    private equalityMayCompareNaN;
+    private coalescingFallbackContext;
+    private requireOrderedComparison;
+    private unorderedTypeGuidance;
+    private mentionsEnumType;
+    protected inferParameterDefault(expression: Expression, contextualType?: ValueType): ValueType;
+    protected resolvedAsyncResult(type: ValueType): ValueType;
+    private asyncResultContainsPromise;
+    private callableThenMember;
+    private promiseResolutionHazard;
+    private promiseResolutionNeedsRuntimeGuard;
+    private reportPromiseResolutionHazard;
+    private reportPromiseCarrierHazard;
+    private inferArrow;
+    private inferCall;
+    private javaScriptBoundaryCallee;
+    private inferGenericCall;
+    /**
+     * D41 item 61 check site 1: once the two-phase inference has solved the
+     * bindings, every bound is verified before the ordinary assignability loop
+     * runs, so a rejected type argument is reported once, at its cause.
+     */
+    private reportGenericBoundViolations;
+    /**
+     * D41 item 61 check site 2: a generic callable used as a value is solved and
+     * erased silently, so the wrapper re-asks the bound question and turns the
+     * rejection into a directed message at the value's own span.
+     */
+    private instantiateCallable;
+    private genericBoundViolation;
+    private concreteCallableFor;
+    /** One diagnostic per site, whichever of the two value paths reaches it first. */
+    private reportFirstClassBoundViolation;
+    private inferIntrinsicCall;
+    private inferRangeCall;
+    private inferEqualsCall;
+    /** The reason a type cannot participate in equals(a, b), or null when it is pure data. */
+    private equalsDomainViolation;
+    private inferCollectionCall;
+    private inferPrimitiveCall;
+    private planNamedArguments;
+    private inferMember;
+    /**
+     * A record shorthand names a binding. Reserved names have no binding to name,
+     * so `{computed}` and `{print}` used to reach past the author entirely and
+     * capture the runtime entry point. The shorthand is refused with the explicit
+     * spelling, which is the only way to mean either thing on purpose — and it
+     * puts the reserved names on the same footing as every softened word, whose
+     * shorthand now resolves to an ordinary binding.
+     */
+    private checkShorthandReservedName;
+    private recordRuntimeObjectShape;
+    private listMember;
+    private stringMember;
+    private numberMember;
+    private collectionMemberError;
+    /**
+     * D38 §48: a retired collection member whose guidance names one successor
+     * member is a mechanical rename of the member name itself.
+     */
+    private collectionMemberFix;
+    private isNullExclusionPredicate;
+    private mapMember;
+    private recordMember;
+    private setMember;
+    private inferredExpressionType;
+    private checkArguments;
+    private orderNamedArguments;
+    private callableWithInferredResult;
+    private updateInferredCallableResult;
+    private functionResultKey;
+    protected inferredFunctionResult(statement: Pick<FunctionDeclaration, "returnType" | "signatureSpan"> & {
+        readonly abstract?: boolean;
+    }): ValueType;
+    private inferCollectedFunctionResult;
+    private functionType;
+    private externFunctionType;
+    private externConstantType;
+    private externClassIdentity;
+    private resolveExternAnnotation;
+    private crossBlockExternClassType;
+    private resolveValidatedExternAnnotation;
+    private importType;
+    protected narrowingFor(expression: Expression, knownType?: ValueType): ReadonlyMap<string, ValueType>;
+    protected negativeNarrowingFor(expression: Expression, knownType?: ValueType): ReadonlyMap<string, ValueType>;
+    private conditionNarrowing;
+    /** What one element of a membership probe's container is, matching the `in` operand rules. */
+    private membershipElementType;
+    /** The concrete checked value behind `Kind.is(value)`, when Kind is a runtime validator. */
+    private validatorTargetOf;
+    private bareConditionNarrowing;
+    private excludeCheckedType;
+    private addLocationNarrowing;
+    private narrowableLocation;
+    private narrowEnumMember;
+    /**
+     * FLW-N7: the fact a boolean-literal comparison proves about its owner.
+     * A location already typed `bool` learns nothing, so no fact is recorded
+     * for it — a needless fact would only buy a runtime recheck on every later
+     * read.
+     */
+    private narrowToBoolean;
+    private narrowDiscriminatedOwner;
+    private inferNarrowedExpression;
+    private withTemporaryNarrowings;
+    private optionalExecutionNarrowings;
+    private inferConditionWithNarrowings;
+    private combineNarrowings;
+    protected requireCondition(type: ValueType, condition: Expression): void;
+    /**
+     * FLW-S2: a getter is a computed value, not a stable location, so a check on
+     * one establishes no fact — the guard reads exactly like every other
+     * narrowing check and silently does nothing. Say so where it is written,
+     * and name the one spelling that works: bind the getter to a `const` and
+     * check that. Following `?.` instead would compute the getter twice.
+     */
+    private checkGetterNarrowingTest;
+    /** The location a condition would narrow, for the forms that narrow one. */
+    private narrowingSubjectExpression;
+    /** The property name when an expression reads a getter rather than a stored field. */
+    private getterAccessProperty;
+    private conditionSubjectText;
+    protected requireAssignable(actual: ValueType, expected: ValueType, valueSpan: Span): void;
+    /**
+     * D44 rule 72's readonly view refuses exactly one shape of assignment: the
+     * value is the target type with readonly added. Component props arrive that
+     * way — the body of `component List(items: List<Item>)` sees a readonly
+     * projection — so the helper that would accept the value has a signature the
+     * author never wrote, and the diagnostic is the only place to hand it over.
+     * The return shape matters as much as the parameter: a List built from a
+     * readonly List carries readonly elements.
+     */
+    private readonlyProjectionGuidance;
+    /**
+     * D64 rule 163: the async result annotation is spelled two ways in two
+     * positions, and both are right. A *declaration* annotates the resolved
+     * value — `async def load(id: string) -> string` — because the `async` is
+     * standing right there; VEL4018 refuses `-> Promise<T>` for that reason. A
+     * function *type* has no `async` on it and describes the value the call
+     * hands back, which is a Promise, so `-> Promise<T>` is the spelling there.
+     *
+     * An author who has just been taught VEL4018 therefore writes `-> string` in
+     * the type position and is refused for obeying it. Naming only the mismatch
+     * leaves that author with two diagnostics that contradict each other, so the
+     * refusal names the spelling the type position wants. The check is exact:
+     * the mismatch has to disappear when the result is wrapped, which is what
+     * makes the named spelling a fact rather than a guess.
+     */
+    private asyncResultSpellingGuidance;
+    private collectionBridgeGuidance;
+    private freezeEscapedCollectionInference;
+    private contextuallyAssignable;
+    private contextualObjectType;
+    private contextualObjectDiscriminantsMatch;
+    private knownEnumSingleton;
+    private widenAggregateSingleton;
+    private contextualCollectionType;
+    private formReadField;
+    private jsonSerializable;
+    private isHttpFormBody;
+    private orderedTypeCategory;
+    private combineJsonStatuses;
+    private typeParameterFrame;
+    /** D41 item 61: the ordered bound vector of a declaration, for its callable type. */
+    private typeParameterBoundVector;
+    /**
+     * D41 item 61 risk 2: only the innermost frame is consulted. A nested `def`
+     * may not name an enclosing declaration's type parameter (VEL4021 rejects
+     * it), so one frame is the whole visible scope.
+     */
+    boundOf(type: Extract<ValueType, {
+        kind: "parameter";
+    }>): TypeParameterBound | null;
+    /**
+     * The one decision procedure for "does this solved type argument satisfy
+     * this bound", shared by the call site and the first-class value path. Each
+     * bound reuses the predicate that already governs its capability.
+     */
+    satisfiesBound(type: ValueType, bound: TypeParameterBound): boolean;
+    private withTypeParameterFrame;
+    private enclosingTypeParameterName;
+    private checkTypeParameterDeclarations;
+    private isDeclaredTypeName;
+    private rejectErasedRuntimeCheck;
+    protected resolveAnnotation(reference: TypeReference | null): ValueType;
+    protected resolveRawTypeReference(reference: TypeReference): ValueType;
+    protected resolveValidatedAnnotation(reference: TypeReference | null): ValueType;
+    protected resolveResult(reference: TypeReference | null): ValueType;
+    protected resolveValidatedResult(reference: TypeReference | null): ValueType;
+    private resolveNamedClasses;
+    protected validateTypeReference(reference: TypeReference, resolve?: (reference: TypeReference) => ValueType): boolean;
+    /**
+     * The retired namespace whose module exports this bare name, when exactly one
+     * does and no permanent namespace claims the same spelling. `min`, `max`, and
+     * `clamp` are claimed by `Math.` as well, so those keep the guidance and lose
+     * only the automatic rewrite — a fix has to be provably the author's meaning,
+     * and there the meaning is genuinely ambiguous.
+     */
+    private retiredNamespaceOwning;
+    private recordMemberAccessProperty;
+    /** The import line a migration writes, in the sorted shape every module here already uses. */
+    private renderNamedImport;
+    /** Where a module that has no import of `source` yet should grow one. */
+    private importInsertion;
+    private registerPermanentNamespaceImports;
+    /**
+     * D52 rule 114: the migration off a namespace prefix the language withdrew.
+     * It is the mirror of the one below — that one takes an import away and puts
+     * a prefix on, this one takes the prefix off and puts an import back — and
+     * both answer in one step, because a migration that needs a second compile to
+     * find the working spelling has taught a loop rather than a spelling.
+     */
+    private reportRetiredNamespaceUses;
+    /**
+     * D52 rule 116 / D50 rule 90: a permanent namespace needs no import, so the
+     * import spelling retires. The rewrite is the import's own inverse — take the
+     * specifier out, put the prefix on every read it left behind — and it is
+     * carried whole so the author never sees a half-migrated module.
+     */
+    private reportPermanentNamespaceImports;
+    /** A member name to show in the rule 106 guidance, so the fix is concrete. */
+    private firstNamespaceMember;
+    protected typeError(message: string, errorSpan: Span, fix?: DiagnosticFix): void;
+    protected recoveredTypeError(message: string, errorSpan: Span, fix?: DiagnosticFix): void;
+    private analyzeMatchPattern;
+    private matchLocationNarrowing;
+    private retargetNarrowings;
+    private matchFallthroughType;
+    private matchPatternCoversWholeType;
+    private unwrapMatchAs;
+    private matchPatternIsIrrefutable;
+    private matchPatternCoversType;
+    private addMatchBinding;
+    private matchListCandidates;
+    private matchObjectCandidates;
+    private matchObjectField;
+    private matchPatternMayMatchType;
+    private matchObjectRestType;
+    private narrowMatchType;
+    private matchLiteralCompatible;
+    private matchValueKey;
+    private matchValueDisplay;
+    private matchTypesOverlap;
+    private runtimeTypeCheckMayExecute;
+    private matchTypeFullyCovered;
+    private enumMemberCoverageKey;
+    /** ENM-I5: enum members reached through a type pattern (parenthesized singletons, unions of them) credit member coverage. */
+    private creditEnumMemberCoverage;
+    /** ENM-I6: the enum behind a match subject - bare or optional - that carries the exhaustiveness contract. */
+    private enumMatchSubject;
+    /** The class arms of a match subject: the type itself, or the class members of its optional/union spellings. */
+    private classArmsOf;
+    private blockAlwaysReturns;
+    private statementAlwaysExitsBlock;
+    private blockAlwaysExits;
+    private builtin;
+    private isFreshUnresolvedCollection;
+    private joinCollectionInference;
+    private createCollectionInference;
+    private refineCollectionInference;
+    private rebindCollectionInference;
+    protected declareBinding(name: string, mutable: boolean, type: ValueType, declarationSpan: Span, internal?: boolean, declaredType?: ValueType, importSource?: string): void;
+    private recordImportedBindingSource;
+    private recordImportedBindingOrigin;
+    private recordInitializationImportRead;
+    /** True while analysis is directly in a declaration body rather than a function frame. */
+    protected inComponentSetupPosition(): boolean;
+    protected inModuleInitializationPosition(): boolean;
+    /** Initialization-position reads of imported bindings, for the project module-cycle check. */
+    moduleInitializationImportReads(): readonly InitializationImportRead[];
+    private requireTextConvertible;
+    private isTextConvertible;
+    /**
+     * The `TypeEnvironment` view of alias expansion. Assignability needs it to
+     * decide the text-conversion parameter domain on the expanded shape, exactly
+     * as the direct `str()` check does.
+     */
+    expandTypeAliases(type: ValueType): ValueType;
+    protected markDeclaredBindingReactive(name: string, kind?: "state" | "prop"): void;
+    protected reactiveBindingKind(name: string): "state" | "prop" | null;
+    private recordSemanticBinding;
+    protected semanticMembersOf(original: ValueType): ReadonlyMap<string, ValueType>;
+    private privateSemanticContext;
+    private createSemanticMembersOf;
+    /** The runtime surface of an enum object: its members plus is, parse, and values() (ENM-U1). */
+    private enumRuntimeMember;
+    private runtimeTypeObjectValue;
+    private displayExternalClasses;
+    protected prescanScopeDeclarations(statements: readonly Statement[]): void;
+    private collectPatternNames;
+    private checkShadowedRead;
+    private declarePattern;
+    private validateKnownBindingShape;
+    protected lookup(name: string): Binding | null;
+    protected isBuiltinValueReference(expression: Expression, name: PermanentNamespaceName | "range"): boolean;
+    protected applyNarrowings(narrowed: ReadonlyMap<string, ValueType>, narrowingSpan: Span): void;
+    private persistNarrowings;
+    private assignedFactType;
+    /**
+     * A check that narrows a location installs a shadow of the binding in the
+     * scope it entered, so nested checks leave one shadow per enclosing scope.
+     * Clearing only the innermost shadow lets an outer scope keep a fact this
+     * write just falsified — visible after a `while` whose condition narrows
+     * the same name its body assigns, where the body's shadow is discarded with
+     * the body scope and the loop's own shadow never learns of the write.
+     */
+    private invalidateShadowedNarrowings;
+    private establishAssignedFact;
+    /** Rule 71 for member targets: establish after invalidation so the new fact survives its own write. */
+    private establishAssignedMemberFact;
+    /** Rule 71 for destructuring declarations: each binding learns its own initializer piece. */
+    private establishAssignedPatternFacts;
+    private stableMemberAccessPath;
+    private stableOptionalMemberAccessPath;
+    private stableDataMember;
+    private discriminatedDataField;
+    private dataFieldIsReadonly;
+    private lookupMemberNarrowing;
+    private lookupMemberNarrowingEntry;
+    private invalidateAssignmentNarrowings;
+    private invalidateMemberNarrowings;
+    private invalidateMemberDescendantNarrowings;
+    private invalidateMutableCollectionCallReceiver;
+    private invalidateCurrentMemberNarrowings;
+    private invalidateAliasableMemberNarrowings;
+    /** The current type of the binding a member-narrowing path is rooted at, or null when it cannot be resolved. */
+    private memberNarrowingRootType;
+    private runtimeCheckedType;
+    private matchPatternReflectionMayExecute;
+    private snapshotFlowFacts;
+    private restoreFlowFacts;
+    private analyzeIsolatedFlow;
+    private flowInvalidationsSince;
+    private reanalyzeLoopBackEdge;
+    private flowInvalidationsAffectFacts;
+    private deduplicateDiagnostics;
+    private clearCachedFlowTypes;
+    private clearCachedFlowTypesInSpan;
+    private flowSnapshotAfterInvalidations;
+    private visibleBindings;
+    private narrowingsForVisibleBindings;
+    private narrowingsInSnapshot;
+    private commonNarrowings;
+    /**
+     * FLW-S1: a `while` is left through the condition test taken either on
+     * entry or after the back edge, so the fact that holds afterwards is the
+     * union of what the two tests prove. A location only one of them names is
+     * dropped, because the other test proves nothing about it.
+     */
+    private joinedNarrowings;
+    private applyFlowInvalidations;
+    protected enterScope(): void;
+    protected exitScope(): void;
+}
+export {};
+//# sourceMappingURL=analyzer.d.ts.map