@velarscript/web 0.31.0 → 0.33.0

package/dist/analyzer.d.ts

@@ -1,7 +1,8 @@
 import { type Diagnostic, type Span } from "@velarscript/compiler";
-import { Analyzer, type AnalysisContext, type CompilerAnalysisExtension, type CompilerIntrinsicAnalysisContext, type Expression, type Program, type Statement, type TypeReference, type ValueType } from "@velarscript/compiler/extension";
-export declare const routeContextIdentity = "@velarscript/web:velar/web#type:RouteContext";
-export declare function inferWebIntrinsic(context: CompilerIntrinsicAnalysisContext): ValueType | undefined;
+import { Analyzer, type AnalysisContext, type CompilerAnalysisExtension, type Expression, type Program, type Statement, type TypeReference, type ValueType } from "@velarscript/compiler/extension";
+import { inferWebIntrinsic } from "./analysis/calls/intrinsics.ts";
+import { routeContextIdentity } from "./analysis/web-types.ts";
+export { inferWebIntrinsic, routeContextIdentity };
 export declare class VelarWebAnalyzer extends Analyzer {
     private componentStates;
     private mountedDepth;
@@ -80,643 +81,43 @@ export declare class VelarWebAnalyzer extends Analyzer {
     private publicConfigNames;
     /** velar/look builder calls this compile refused on their own arguments (D114 0.29.0 LK-I2). */
     private readonly refusedBuilderCalls;
+    /** The one object every `analysis/` collaborator reads this analyzer through. */
+    private readonly host;
     constructor(context?: AnalysisContext, extensions?: readonly CompilerAnalysisExtension[]);
     analyze(program: Program): readonly Diagnostic[];
-    /**
-     * D57 rule 138: `velar/web-test` only has a runtime under `velar test
-     * --browser`, so an import of it anywhere else compiles a call that cannot
-     * succeed. D51 rule 109 puts the refusal at the declaration rather than at the
-     * eventual use, so the error lands on the `import` line — including the
-     * JavaScript-bridge and re-export spellings, which reach the same runtime.
-     */
-    private reportBrowserTestImports;
-    /**
-     * D72 rule 186: a Web module publishes its own type names, and a user
-     * declaration of one used to be accepted at the declaration and then lose at
-     * every use — `type Event:` compiled, and `describe({kind: "charge"})` was
-     * told it could not assign to `Event`, naming a type the author had just
-     * written. D51 rule 109 already settled where that refusal belongs: at the
-     * declaration, which is the only place a rename is cheap.
-     *
-     * The names come from the extension's own published table, so adding a type
-     * to `WEB_OWNED_TYPE_NAMES` extends this protection with it. The last time
-     * this family was repaired by listing names instead of deriving them, the
-     * list drifted; D57 rule 135 is the same repair on the Core roster.
-     *
-     * Core now says the same sentence about its own built-in type names —
-     * `builtinTypeNameDeclarationMessage` in packages/compiler/src/analyzer.ts,
-     * reported as VEL3007. The rosters differ; the wording is meant to read
-     * alike, so a change to either sentence belongs in both.
-     *
-     * `Duration` is on both rosters — Core owns it as a primitive and
-     * `velar/look` republishes it — so a Web module used to report it twice. This
-     * refusal is the more specific of the two, because it names the surface the
-     * author is writing against, so it marks the name refused and Core's stays
-     * unsaid. The mark is Core's own hook, which is what lets this pass take
-     * precedence without either side learning the other's roster.
-     */
-    private rejectWebOwnedTypeNames;
-    /**
-     * WEB-C1: charter §14 promises that a key outside a keyed shape is a
-     * diagnostic rather than a silent no-op. Interpolated positions report while
-     * their interpolation is walked; static positions are collected during JSX
-     * inference and reported once every keyed interpolation is known.
-     */
-    private reportStaticJsxKeys;
     protected predeclareExtensionStatement(statement: Statement): boolean;
     protected analyzeExtensionStatement(statement: Statement): boolean;
     protected analyzeStatement(statement: Statement): void;
-    private directReadonlyPropMutation;
-    private rootBindingName;
     protected prescanExtensionScopeDeclaration(statement: Statement): {
         readonly name: string;
         readonly span: Span;
     } | null;
-    /**
-     * D71 rule 182: a derived value is reactive and read-only, which is exactly
-     * the reactive identity a component prop already carries — a bare read lowers
-     * through `.get()`, and nothing may write it. Registering that identity
-     * rather than `state` is what keeps `bind={doubled}` and every other writable
-     * position refusing a derived name for free.
-     */
-    private analyzeComputedDeclaration;
-    /**
-     * True when `name` resolves to a `computed` declaration or to an imported one.
-     * The question is asked of the *binding* the name resolves to, never of the
-     * spelling: a local `state` may shadow an imported derived name, and that
-     * shadow is writable state.
-     */
-    private isComputedBinding;
-    /**
-     * True when `name` resolves to a `resource` declaration. Asked of the binding
-     * rather than of the spelling, for the reason `isComputedBinding` is: a local
-     * `state` may shadow a resource's name, and the shadow is not a resource.
-     */
-    private isResourceBinding;
-    private isImportedComputedBinding;
-    /**
-     * D71 rule 184: a cross-module `computed` travels through `reactiveExports`
-     * so its bare read lowers through `.get()` like an exported `state` — but it
-     * is not writable, and the imported binding must not inherit the writable
-     * identity that carries `bind={...}` and `event => name = ...`. The Web
-     * extension publishes which exported names are derived, so the import is
-     * demoted to the read-only reactive identity here.
-     */
     protected markDeclaredBindingReactive(name: string, kind?: "state" | "prop"): void;
     protected inferExtensionExpression(expression: Expression, _contextualType: ValueType): ValueType | undefined;
     protected inferExpression(expression: Expression, contextualType?: ValueType): ValueType;
-    /** Infers one builder slot and parks the answer in the probe cache, so the call's own analysis reads it back. */
-    private probedSlotType;
-    private writableStateName;
-    /**
-     * P2b-5: a `def` that answers markup and answers it with a component element.
-     *
-     * Everything about the shape is legal one step out. A component element is a
-     * legal module-level expression — `const root = <App />` is the instantiation
-     * site D90 R4-b rules on, and `mount` takes exactly the instance it evaluates
-     * to. A `def` answering markup is a legal markup helper — dispatch over a
-     * closed vocabulary is what the P2b wave was writing. The defect is only
-     * where the two meet, and it is a representation split the type does not
-     * carry: a component element in a *child* position lowers to `__velarChild`,
-     * which owns a scope and answers a DOM node, while the same element standing
-     * alone lowers to `__velarInstantiate`, which answers an instance. Both are
-     * typed `WebNode`; only one is one. Returned from a helper and handed to a
-     * render, the instance reaches `__velarAppend` and takes the whole subtree
-     * down with "JSX can render only text, finite numbers, bool, enums, WebNode
-     * values, and Lists of those values" — the check-green, runtime-dead shape.
-     *
-     * The walk stops at every JSX element, which is exactly where the emitter
-     * stops: inside one, every position is a child position and every component
-     * element there is already correct — `return <div><Badge /></div>` and an
-     * interpolated `{cond ? <Badge /> : ...}` both work today and must keep
-     * working. Only a component element the returned markup *starts* with is the
-     * defect, including one reached through a `.map(...)` answering a row per
-     * item, which fails the same way for the same reason.
-     */
-    private rejectUnownedComponentElement;
-    /**
-     * The audit's seventh root cause: a `def` that declares reactive state and
-     * answers `WebNode` is a component wearing a function's clothes, and calling
-     * it bypasses exactly what the charter already refuses `View(...)` for. Two
-     * things follow from the call, both reproduced: every call runs the `state`
-     * declaration again, so the value resets on every re-render; and the
-     * observers the returned markup registers bind to whatever scope the call
-     * site was building — at module scope the global one, which is never
-     * destroyed, so they are never cleaned up.
-     *
-     * Only DECLARATION is refused. A `def -> WebNode` that merely reads state or a
-     * prop is a legitimate markup helper — examples/app has two — and a `def`
-     * nested inside a component binds its observers to that component's scope, so
-     * nothing about reading is defective.
-     *
-     * What answers "this `def` returns markup" is the sink, not one spelling of
-     * it: `-> WebNode?` and `-> List<WebNode>` are the shapes markup travels in,
-     * and a `def` may carry no return type at all — all three reached the same
-     * defect with the same body while only the bare annotation was read.
-     */
-    private rejectStatefulWebNodeFunction;
-    /**
-     * D71 rule 182: a declared derived value is read bare, exactly like state.
-     * Calling one is the habit the retired `computed(...)` accessor taught, and it
-     * is also what a half-migrated project looks like from the importing side — so
-     * the answer names the one spelling and carries the edit that reaches it,
-     * which is what lets `velar fix` finish a migration that crosses modules.
-     */
-    private calledComputedBinding;
-    /**
-     * D69 rule 178: a `watch` body that can never run is a block of statements
-     * the compile silently drops — the same defect a bare `5` is already rejected
-     * for (VEL4030), reached from a position the rule could not see.
-     *
-     * D90 R15(a) adds the third refusal and fixes the order the three are asked
-     * in. A frozen subject is answered before the shape rule so that one shape
-     * never draws two messages: a subject built only from frozen parts has no
-     * reactive source at all, and telling its author to declare a `computed`
-     * would only buy him a dead one. What survives both is either a path — the
-     * name of a reactive binding, or a member/index read out of one — or a
-     * computation, and a computation has a spelling of its own.
-     *
-     * The three refusals are separate because their causes are: a reader that was
-     * not called names a value that never moves, a frozen value has no reactive
-     * source behind it at all, and a computed subject has one but hides which.
-     */
-    private rejectFrozenWatchSubject;
-    /**
-     * D114 W: the three watch shapes a compile can prove re-trigger the watch
-     * itself. D90 R21 removed the analysis of *who writes what* across calls, and
-     * nothing here brings it back: two watches writing one state are still an
-     * ordinary program, a write reached through an ordinary helper is still
-     * silent, and a write under `if`, `match`, a loop, `try`, a nested `def` or an
-     * arrow is still the author's converging correction to make.
-     *
-     * What is refused is only what is decided at the top of the body, with no
-     * condition to end it:
-     *
-     *  - **B** the body writes the watched place itself (`watch count: count =
-     *    count + 1`), assignment, compound assignment, or a mutating collection
-     *    call on the watched collection;
-     *  - **A2(a)** the subject is a `resource` field and the body reloads that
-     *    same resource — a reload writes exactly those fields, so every completed
-     *    load re-triggers the watch;
-     *  - **A2(b)** the body starts an `action` or an `async def` of this module
-     *    whose own top level writes the watched place. One hop, one module, no
-     *    condition on either end; anything further is the runtime budget's.
-     *
-     * One diagnostic per watch, at the first statement that earns it. A watch with
-     * two of these has two mistakes, and the second is read after the first is
-     * fixed, exactly as two errors on one line are.
-     */
-    private rejectWatchCycle;
-    /**
-     * D114 0.28.0 H-D1: the type of the place `steps` below the watched subject,
-     * or null when the walk cannot reach one.
-     *
-     * Only the steps the reactive graph publishes as part of the subject are
-     * walked — a record field and a collection element — because those are the
-     * writes a watch on the containing value is woken by. A step that leaves them
-     * (a class instance, a capability handle, a field the record does not declare)
-     * is not provably part of the subject, and a refusal that must be right every
-     * time answers no there rather than guessing.
-     */
-    /**
-     * Whether a write `steps` below the watched subject, made the given way, is a
-     * write of the subject — the one definition both the body scan (VEL5077) and
-     * the one-hop writer scan (VEL5079) read. An assignment to a place the walk
-     * can reach is a write; a call is one only when the type at that depth is a
-     * collection and the call is on its own mutating roster.
-     */
-    private watchSubjectWrite;
-    private reactivePlaceType;
-    /**
-     * D89 A4: records `list = list.map(item => {…})`, React's immutable update,
-     * where the callback builds a new record rather than changing a field.
-     *
-     * D90 R2 stands — `__velarKeyed` compares identity and that does not move,
-     * and the framework does not accommodate the idiom. This channel is not the
-     * framework taking responsibility; it is the compiler telling the author that
-     * the row he is typing into is about to be destroyed. Nothing is reported
-     * yet: the advisory is owed only if the rewritten list is what a keyed list
-     * renders, and the render usually sits below the update.
-     */
-    private recordKeyedListRebuild;
-    /**
-     * D89 A4, the wider proven shape: the same churn written as a derived value.
-     * `computed rows = source.map(item => {…})` and `computed rows = build(...)`
-     * over a `for`/`append` builder both hand a keyed position a fresh record for
-     * every row on every recompute, which is exactly what the assignment shape
-     * does — the reconciliation wave compiled both and found only one of them
-     * named. It is one advisory with a wider proof, not a second code: the defect,
-     * the consequence, and the suppression are the same.
-     *
-     * A `const` in a component body is deliberately not here. It is constructed
-     * once, so its records never move, and advising it would be a guess rather
-     * than a proof.
-     */
-    private recordDerivedKeyedListRebuild;
-    /**
-     * Whether a derived initializer constructs one fresh record per source
-     * element. Two spellings are proven and everything else is silent: a `map`
-     * whose callback answers a record literal — the same recognizer the
-     * assignment shape uses — and a call to a `def` this module declares whose
-     * whole answer is a list it filled with record literals.
-     */
-    private rebuildsRecordsPerElement;
-    /**
-     * D89 A4: raises the advisory for the rebuilds whose list a keyed position
-     * really renders. The advisory channel cannot reach `this.diagnostics`, so
-     * nothing here fails a build, changes an emitted byte, or moves a semantic
-     * rule; `// velar-allow A4: <reason>` suppresses it where building the rows is
-     * the only spelling, which a `readonly` list or one API response makes it.
-     */
-    private adviseKeyedListRebuilds;
-    /** A value that is read by calling it and takes no arguments to do so. */
-    private zeroArgumentReader;
-    /**
-     * True only for subjects built entirely from values the compile can see are
-     * frozen: literals, and non-reactive bindings whose type is a primitive, so no
-     * deep-reactive object can be hiding behind the name. Every member access,
-     * index, and call is excluded on purpose — `alias.done` on a const bound to a
-     * reactive element does track, and a call can read anything.
-     */
-    private frozenWatchSubject;
-    /** A primitive holds no reactive identity, so a non-reactive binding of one is a snapshot. */
-    private frozenValueType;
-    /**
-     * D71 rule 182: a derived value has no writable location behind it, so the
-     * const message ("cannot assign to const binding") would name the wrong
-     * reason. Answering here means the reader is told what a derived value is and
-     * which spelling holds a value that is written.
-     */
-    private rejectComputedAssignment;
-    /**
-     * D71 rule 183: `computed(...)` the function — the shape Vue and the signals
-     * libraries teach — is not how a derived value is written here; the `computed`
-     * declaration is. The declaration is recorded before the core walks the module
-     * so its reads can be matched against it — the rewrite that removes the call
-     * parentheses is only offered when every read is a plain `x()`.
-     */
-    private recordRetiredAccessorDeclaration;
-    /** Returns true when the name is one of the retired accessor globals this pass owns. */
-    private recordRetiredAccessorRead;
-    /**
-     * D71 migration: one message per site, and a mechanical rewrite only where
-     * the compile can prove the rewrite. Where the
-     * accessor is used as a value there is no second spelling left to offer, so
-     * that site is told to declare the value and write an ordinary `def` where a
-     * callable is what the caller wants — and it gets no edit, because moving a
-     * reader out of a value position is the author's decision.
-     */
-    private reportRetiredComputedFunction;
     protected extensionFieldsOf(name: string): ReadonlyMap<string, ValueType> | null;
     protected inferExtensionCall(callee: import("@velarscript/compiler/extension").ExtensionValueType, arguments_: readonly Expression[], argumentNames: readonly (string | null)[] | undefined, callSpan: Span): ValueType | undefined;
     protected validateExtensionTypeSyntax(syntax: import("@velarscript/compiler/extension").TypeSyntax, validate: (syntax: import("@velarscript/compiler/extension").TypeSyntax) => boolean, resolve: (reference: TypeReference) => ValueType): boolean | undefined;
-    /**
-     * D43 item 69: a component body is a construction section, not a scope with
-     * an exit — its resources live until unmount. Ownership belongs to the
-     * lifecycle hook or to a function inside the component, so the setup section
-     * says so instead of releasing at the wrong moment.
-     */
     protected ownershipScopeRejection(): string | null;
-    /**
-     * D114 0.29.0 JX-I2: a component body has no function frame, so a `return` nested
-     * inside it — in a `match` arm, an `if`, a `for` — used to earn VEL3003 next to
-     * VEL5008 ("exactly one top-level return"), two rules its author can only read as
-     * contradicting each other. A lifecycle hook and a watch body are inside the same
-     * component and are *not* it: neither returns anything, so a `return` there keeps
-     * VEL3003.
-     */
     protected extensionOwnsFunctionlessReturn(): boolean;
     protected invalidExtensionAwaitContext(): boolean;
     protected invalidExtensionAwaitMessage(): string | null;
-    private componentType;
-    private analyzeResourceDeclaration;
-    private actionType;
-    private analyzeActionDeclaration;
-    private analyzeComponent;
-    private containsReadonlyView;
-    private validateComponentHandleType;
     protected resolveAnnotation(reference: TypeReference | null): ValueType;
-    private normalizeComponentContracts;
-    private validateComponentHost;
-    private analyzeLookEntries;
-    /**
-     * LOK-D1: a `look:` literal is constructed once, where it is written. Its
-     * conditions and its values are snapshot positions — a reactive read inside
-     * one compiles cleanly and then never updates, which is the quietest trap in
-     * the visual language. The two spellings that stay live are the JSX
-     * expression position and the `look:property` directive, so the read is
-     * rejected here and both are taught.
-     */
-    private reportLookSnapshotReads;
-    /**
-     * True when a name both belongs to a derived reactive declaration and still
-     * resolves to one here: a computed accessor is a zero-argument function, and a
-     * resource or action handle is a record with its reactive fields. An ordinary
-     * binding that happens to share the name — a function parameter, a local — is
-     * not a reactive read.
-     */
-    private derivedReactiveRead;
-    /**
-     * LOK-U8: the velar/look builders check their numeric domains at run time, so
-     * a literal out-of-range colour used to compile clean and blank the page on
-     * the first paint. Literal arguments are checked in the same terms while the
-     * module compiles; dynamic arguments keep the runtime guard.
-     */
-    private checkLookBuilderCall;
-    /**
-     * D103 rules 1 and 5 — what a checked token reference has to be at the site
-     * that writes it.
-     *
-     * The compiler cannot see a design system's values: no token stylesheet is an
-     * input to this compile, and the whole point of the contract is that the
-     * theme swaps values under the same names. So the reference itself is the
-     * only thing there is to check, and it is checked completely — a literal
-     * name, spelled as a CSS custom property identifier, and nothing else in the
-     * call. A computed name would leave a Look value with no checked part at all,
-     * which is the surface D50 rule 92 says is worse than none.
-     */
-    private checkLookTokenCall;
-    /**
-     * D103 rule 4 — the migration off the one passthrough that used to work.
-     *
-     * The rewrite carries the `token` import when the module does not already
-     * have one, because a fix that leaves a module naming an unimported builder
-     * is not mechanical. A `var(--x, fallback)` reference has no rewrite: rule 5
-     * closed the contract against per-site fallbacks, so the message says that
-     * rather than offering a migration that would silently drop the fallback.
-     */
-    private reportLookColorVarReference;
-    /** The one edit that gives this module a `token` import, in the shape D103's migration needs. */
-    private lookTokenImportEdit;
-    private checkAnimateBuilderCall;
-    private checkAnimationKeyword;
-    private analyzeKeyframes;
-    /** Whether a builder call this compile refused on its own arguments lies inside `sourceSpan`. */
-    private refusedBuilderCallWithin;
-    private reportKeyframeSnapshotReads;
-    /**
-     * D104 rule 2 — the wider half of the promise VEL5039 already made. A
-     * repeated property name is refused because the second entry overwrites the
-     * first and Look has no source order to settle which is meant; a shorthand
-     * beside a longhand it writes is the same defect with two spellings, and it
-     * is the one that hid thirty-six dead declarations in a consumer's shell.
-     * Reports once against the entry that completes the pair.
-     */
-    private reportLookShorthandOverlap;
-    /**
-     * The same rule where the properties are written as element directives. A
-     * `look:` directive lowers to exactly the rule a block entry does, so an
-     * element carrying `look:padding` and `look:paddingTop` has the pair in the
-     * same scope as surely as a block does. The `style:` directives are not
-     * checked here: they compose one inline style object, where the browser's own
-     * source order settles the pair.
-     */
-    private reportLookDirectiveOverlap;
-    /**
-     * Records one entry in its lowered scope (condition signature plus target) so
-     * two sibling blocks with the same condition report the property they both
-     * set. Returns false when the entry repeats. LOK-I4: the charter's duplicate
-     * promise used to hold only inside a single indented scope.
-     */
-    private recordLookEntry;
-    /**
-     * The vocabulary checks a Look property shares between the block spelling and
-     * the `look:`/`style:` directives. Returns false when the entry is already
-     * reported and its value needs no further checking. LOK-I1: an unrecognized
-     * property no longer co-reports a `stringType` fallback assignment error.
-     */
-    private analyzeLookValue;
-    /** Whether this value is written as a call to the module's `token` builder, alias included. */
-    private isLookTokenCall;
-    /**
-     * A complete CSS filter function whose arguments fit the checked Look
-     * builders has one equivalent source spelling. The parser deliberately
-     * stops at the first function or argument grammar it cannot prove, leaving
-     * arbitrary CSS and externally defined filter functions as ordinary text.
-     */
-    private adviseLookFilterSpelling;
-    /** Uses an existing alias when present and lists only builders the fix must import. */
-    private localizeLookBuilderCall;
-    /** Rewrites either a Look entry expression or the synthetic value of a JSX Look directive. */
-    private lookBuilderRewrite;
-    /** Adds missing builders to the module's one velar/look import in stable order. */
-    private lookBuilderImportEdit;
-    /** How this module spells a call to the token builder, honouring an aliased import. */
-    private lookTokenCallText;
-    /**
-     * The edits that replace one written Look value with the checked token call,
-     * in the spelling of the site that wrote it.
-     *
-     * A `look:property="text"` directive is analyzed through a synthetic literal
-     * standing for the whole attribute, so the rewrite replaces the attribute:
-     * splicing a call between an attribute's quotes is not JSX, and a fix that
-     * produces a parse error is not a mechanical fix. The `look:property={...}`
-     * spelling carries a real expression whose span is the value alone, and is
-     * rewritten in place like a block entry.
-     */
-    private lookTokenRewrite;
-    /**
-     * D103 rule 4, free-text half — an advisory rather than a refusal.
-     *
-     * `fontFamily`, `backdropFilter` and the other free-text kinds accept
-     * arbitrary CSS text by construction, and a `var()` inside a larger value is
-     * a legitimate spelling with no single token to rewrite it to: the tail of a
-     * font stack, one layer of a filter list. Refusing there would refuse real
-     * CSS. What is advised is the narrow case where the *whole* value is one
-     * reference, because there `token("--name")` is the checked spelling of the
-     * same thing and the rewrite is unambiguous — which is the bar the `A`
-     * roster is written to.
-     */
-    private adviseLookTokenSpelling;
-    /**
-     * `subject` names the position in the message. It is the property itself
-     * everywhere except the `transition(...)` builder, whose first argument takes
-     * `transitionProperty`'s vocabulary but is not written as that property — a
-     * refusal that named the longhand there would name a spelling the author
-     * never wrote.
-     */
-    private validateLookStringVocabulary;
-    /**
-     * D65 rule 168 closed the closed sets against misspelled literals, and D65
-     * item 3 makes a `const` string a first-class design token — so the two have
-     * to agree. A name or a record field that folds to a bare CSS keyword is
-     * checked exactly as the literal spelling of it is; anything that folds to
-     * composed CSS text (a builder result, a unit, a gradient) is not a keyword
-     * and is left to the type and to the builder's own checks.
-     */
-    private foldedLookKeyword;
-    /**
-     * LOK-D3: a bare number on a length property reaches CSS as a declaration the
-     * browser discards. The union already rejects it; this diagnostic replaces the
-     * union dump with the unit the author meant to write.
-     */
-    private reportLookNumberWithoutUnit;
-    private inferLookCondition;
-    private checkViewportThreshold;
-    private inferJsx;
-    /**
-     * WEB-S3: `srcdoc` builds a whole document out of a string, and that document
-     * inherits this page's origin — so it is a second raw-HTML boundary next to
-     * the one the charter names (`unsafe:html`), reachable with no marker at all.
-     * The marker this one gets is `sandbox`, because sandbox is what actually
-     * takes the origin away; requiring it makes the boundary visible where it is
-     * crossed. `allow-scripts allow-same-origin` together hands the origin back,
-     * so the pair is refused by name rather than accepted as a sandbox.
-     */
-    private reportIframeSrcdocSandbox;
-    /**
-     * WEB-S2: the analyzer already refuses an anchor that opens a window without
-     * 'noopener', so a URL attribute whose value is a script scheme cannot be the
-     * one URL question it declines to ask. A written-down URL is answered here; a
-     * value that arrives at run time is answered by the runtime attribute check.
-     */
-    private reportUrlAttributeScheme;
-    private checkKeyedInterpolation;
-    private reportIneffectiveJsxKeys;
-    private analyzeComponentElement;
-    /**
-     * The `look=` attribute on either host kind. A Look block written inline is
-     * reported without inferring its entries, so the one directive-level message
-     * stands alone; an empty list names the accepted family rather than rendering
-     * `List<unknown>` (LOK-I3, LOK-I6).
-     */
-    private analyzeJsxLookAttribute;
-    /**
-     * Composition is how a Look overrides another one: `...baseLook` puts the two
-     * in an order the reader can see, and everything after it wins. Two looks
-     * placed side by side on one element state no order at all, so a property both
-     * of them set has no answer the source gives — the winner used to fall out of
-     * whichever rule the stylesheet happened to carry last. The shape is refused
-     * rather than ordered by fiat, and the refusal names the spelling that states
-     * the order the author meant.
-     */
-    private reportIndependentLookCollisions;
-    private analyzeComponentRef;
-    private analyzeNativeJsxAttribute;
-    /**
-     * A14: `condition ? "true" : "false"` is the expanded spelling of the Core
-     * text conversion `str(condition)`. Keep that conversion explicit at a DOM
-     * text boundary instead of teaching every attribute its own coercion rule.
-     *
-     * The rule does not reach component props or HTML bool-presence attributes.
-     * A string "false" keeps such an attribute present; accepting that spelling
-     * as canonical would hide a likely presence bug whose direct expression is
-     * the bool itself.
-     */
-    private adviseNativeBooleanTextConversion;
-    /** Directives and compiler-owned control attributes do not use DOM text conversion. */
-    private plainNativeTextAttribute;
-    /**
-     * D90 coherence-3: DOM attribute names and ARIA are documented as checked
-     * surfaces, and nothing checked them — `className="panel"` compiled clean and
-     * emitted a dead attribute, while the sibling React reflex `onClick=` on the
-     * same element was already refused. So a model got a clean bill of health on
-     * exactly the half of its React habit that silently breaks the page.
-     *
-     * The rule diagnoses names that are KNOWN wrong, never names that are merely
-     * unknown. HTML lets a document carry attributes no roster can enumerate, so
-     * `foo="bar"`, `data-*`, and a framework's own prefixes stay legal; a false
-     * positive there would block a correct program, which is worse than the
-     * silence it replaces. Three closed rosters answer three closed questions:
-     * the React / JavaScript-property spellings, the ARIA attribute names (ARIA,
-     * unlike HTML, admits no custom names), and the ARIA and role vocabularies.
-     *
-     * D61 bounds the value half. Every native attribute uses the same presence
-     * rule: false/null remove it, true writes an empty value, and strings carry
-     * literal text. A token vocabulary is therefore read only against a string
-     * literal; expression values are runtime questions. A14 separately shortens
-     * an explicit bool-to-text conditional to `str(bool)` when that rewrite is
-     * provably equivalent.
-     *
-     * Returns true when it reported, so the caller does not stack a value-shape
-     * message on an attribute whose name is already answered.
-     */
-    private reportNativeAttributeSpelling;
-    /**
-     * GRM-A4: an event handler runs for effect and returns null. The hole this
-     * closes is `on:click={() => {}}`: after a fat arrow, braces build a record,
-     * never a block, so the empty-record factory used to be accepted as a handler
-     * and silently did nothing on every click.
-     */
-    private checkEventHandlerResult;
-    /**
-     * D47 rule 84(A): a bind target is a writable reactive location — a state
-     * name, or a record-field / List-index / Map-key path rooted in one. A
-     * computed accessor, a const, and a function result stay rejected: nothing
-     * would receive the write.
-     */
-    private isWritableBindTarget;
-    /**
-     * Walks a member/index path inward to its root state binding, checking every
-     * segment is a writable location: a declared record field, a List element, or
-     * a Map value. Returns the root state name, or null when the path is not a
-     * writable reactive location.
-     */
-    private bindPathRoot;
-    /**
-     * D47 rule 84: `bind:group` binds a set of inputs that share one decision.
-     * A radio group holds the selected input's `value`; a checkbox group holds the
-     * checked values as a List<string>, so checking and unchecking are membership
-     * changes.
-     */
-    private analyzeBindGroup;
-    private eventAssignedStateBinding;
-    private isLookInput;
-    private isClassInput;
-    private isJsxRenderable;
     /**
-     * F1's qualifying rule, and the whole of it: the types whose rendering is
-     * *exactly* one text node.
-     *
-     * `string` and `number` are the two. `__velarAppend` answers a string with one
-     * text node carrying it — the empty string included, which is why `""` is not
-     * a special case — and a number with one text node carrying `String(value)`,
-     * or refuses a non-finite number. An enum member is text at runtime and is
-     * assignable to `string`, so it rides the same branch it always did.
-     *
-     * Everything else stays on the full dynamic region, and the reason is always
-     * the same one: it does not render as *one* node.
-     * - `bool` renders **zero** nodes (`__velarAppend` returns on `true`/`false`),
-     *   so a text node would be an added child where an element previously had
-     *   none — observable to `:empty`, to `childNodes`, and to anything that
-     *   walks them.
-     * - An optional of either renders zero nodes when null and one when present,
-     *   so it needs an anchor to come back to.
-     * - `WebNode`, lists, unions, `any` and every named type can hold markup or
-     *   several nodes, which is what the comment pair exists to bracket.
-     *
-     * Widening this set is a semantic ruling, not an optimisation: it would
-     * change the node count of a rendered document.
+     * The one host the `analysis/` collaborators read this analyzer through,
+     * built here because a `private` member cannot be read outside the class it is
+     * declared in (TS2341, D114 line 512). Every table the walk replaces once per
+     * program and every depth a collaborator moves arrives as an accessor pair, so
+     * a collaborator reads the live value and keeps its own `host.jsxDepth += 1`
+     * text.
      */
-    private isScalarTextType;
-    private isJsxAttributeValue;
-    private isOptionalString;
+    private analysisHost;
     /**
-     * The elements of a `<Router routes={...}>` list literal, one at a time.
-     *
-     * A route written as `route("/a", Panel)` is checked at that call; the record
-     * that call returns — `{path: "/a", component: Panel}` — is a legal spelling
-     * of the same value, reaches the same runtime position, and until now was
-     * checked by nothing: `{path: "no-leading-slash", component: 5}` compiled
-     * clean and handed `5` to the Router as a component. Closing the sink rather
-     * than the spelling means asking the same questions wherever a route arrives,
-     * so this reports exactly what `route(...)` reports, word for word.
-     *
-     * The runtime is already the second referee (D90 R19): `routerTable`
-     * validates every path and refuses a component that is not callable. Nothing
-     * here changes which programs run — it moves a refusal the author would have
-     * met at mount to the place the source shows the mistake.
-     *
-     * The `any` component slot is skipped here rather than inside
-     * `checkWebRouteComponent`, which is why that method carries no `any` arm:
-     * this loop and the Router `fallback` attribute are its only two callers, and
-     * both filter first. An `any` reaches this slot for real — `web.lazy` answers
-     * `anyType` from each of its error paths — and it arrives with the author's
-     * real message already reported, so a second "received any" would be a
-     * cascade. The `route(...)` twin skips it for the same reason.
+     * The base-analyzer operations the collaborators perform, bound to this
+     * analyzer. They are their own object because they are plain function values:
+     * spreading them into the host above copies the bindings, while an accessor
+     * has to be written in the literal that becomes the host.
      */
-    private checkWebRouteRecords;
-    private checkWebRouteComponent;
-    private analyzeInlineVisualAttribute;
+    private analyzerOperations;
 }
 //# sourceMappingURL=analyzer.d.ts.map