@velarscript/web 0.10.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,89 @@
+# @velarscript/web
+
+The official Web framework for VelarScript. This package is the versioned
+authority for the `velar/look`, `velar/app`, `velar/config`, `velar/web`, `velar/forms`,
+`velar/http`, `velar/storage`, `velar/browser`, `velar/files`,
+`velar/realtime`, `velar/worker`, `velar/websocket`, and `velar/web-test`
+language modules. It also owns the
+component/JSX, reactive, lifecycle, Look, DOM/CSS lowering, project-manifest,
+and editor contributions that a Core-only VelarScript project does not load. Its
+compiler entry owns the Web parser, analyzer, semantic index contribution,
+intrinsic API rules, dependency/public-interface inspection, and emitter as
+one versioned extension boundary. Its separate `./host` entry owns Web document
+generation, the development reload client, initial compile-error document, CSP
+and deployment projection, browser-test metadata, base-path behavior, and
+production source-map policy. The Web editor contribution owns JSX tag/native
+HTML/native SVG completion, JSX attribute completion, and the special
+`children` rename guard; the generic CLI project semantic layer only supplies
+checked symbols and members.
+
+Applications keep the language-level imports:
+
+```velar
+
+import {Head, Link, Router, route} from "velar/web"
+import {http} from "velar/http"
+import {rgb, spacing} from "velar/look"
+
+const accent = rgb(45, 79, 190)
+const pagePadding = spacing(24px, 16px)
+```
+
+One-off base properties use the same checked table through JSX directives, and
+remain ordered after any composed Look:
+
+```velar fragment
+<button
+    look={controlLook}
+    look:color={paper}
+    look:background={accent}
+>Save</button>
+```
+
+State hooks, viewport conditions, pseudo-elements, and other structural visual
+logic remain in a full `look:` value rather than being encoded into directive
+names.
+
+`Head` owns route-scoped metadata and accepts a checked `language` tag when an
+application switches document language at runtime.
+
+The project declares `"extensions": ["@velarscript/web"]`; the project-local
+`velar` CLI resolves this package's compiler contract and injects its browser
+runtime. Application code does not import the npm package directly. The
+explicit `./compiler` and `./host` exports are tooling infrastructure, not
+second application APIs. The CLI discovers those entries from the project
+extension list, validates host protocol version 1 and the matching `web`
+capability, and never installs or identifies this package itself.
+The npm manifest declares generic `velar.extension` metadata with the owned
+`web` project field, so `velar add` and `velar remove` can maintain project
+activation without teaching the CLI this package's name.
+
+The Web Worker runtime snapshots caller-owned transferable data, then transfers
+nested `Bytes`, `UInt8Buffer`, `UInt16Buffer`, `UInt32Buffer`, and
+`Float32Buffer` storage after checked request/response validation and a bounded
+cycle-safe graph scan. Caller buffers stay intact. Pull WebSockets independently
+bound unread message count, aggregate unread bytes, and pending send bytes;
+normal EOF preserves queued messages for draining, while receive failure clears
+them immediately.
+
+`@velarscript/web` requires the exact matching `@velarscript/compiler`
+version. It has no dependency on VelarOS Workbench and does not define the
+future Canvas-oriented `velar/game` framework.
+
+Browser HTTP responses expose `.bytes()`, IndexedDB databases expose
+`getBytes`, `setBytes`, and atomic `batch`, and the same immutable `Bytes`
+contract crosses WebSocket and Worker boundaries. Worker source entries come
+from the project manifest, so application source does not construct bundle URLs.
+Requests and responses are checked with runtime `Type` values; pools, call
+queues, message queues, transfers, cancellation, timeout, and crash convergence
+are bounded by the shared Core contracts. The existing `velar/realtime` text
+surface remains available unchanged.
+
+The package also owns Look, the checked visual language integrated with VelarScript
+values and JSX. `look:` values, ordinary functions, imports/exports, named
+`velar/look` builders, unit-aware properties and arithmetic, bounded `if` conditions, `@state` hooks, and
+`@target` blocks lower to extracted standard CSS with stable readable markers.
+Native and component JSX accept universal `class` and `look` props; inline
+`style` directives are rejected. Raw CSS is available only through an explicit
+`import css unsafe` declaration whose mandatory `before look` or `after look`
+placement defines source order without inventing priority semantics.

package/dist/analyzer.d.ts

@@ -0,0 +1,302 @@
+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;
+export declare class VelarWebAnalyzer extends Analyzer {
+    private componentStates;
+    private mountedDepth;
+    private cleanupDepth;
+    /** D51 (audit 12): a component `watch` body runs on a change and ends, exactly as a module `watch` body does. */
+    private watchBodyDepth;
+    private synchronousReactiveDepth;
+    private jsxDepth;
+    private readonly resources;
+    private readonly unsafeCssImports;
+    private readonly probedOperandTypes;
+    private readonly importedLookStaticValues;
+    private lookStaticValues;
+    private readonly lookEntryScopes;
+    private readonly derivedReactiveNames;
+    private readonly checkedBuilderCalls;
+    private readonly staticJsxKeys;
+    private readonly honoredJsxKeys;
+    private readonly reportedJsxKeys;
+    private lookBuilderNames;
+    private lookLiteralDepth;
+    /**
+     * D71 rule 182: the declaration spans of every `computed` binding in scope.
+     * A binding's span survives narrowing, so it identifies the declaration a
+     * name resolves to even where a narrowed copy answers the lookup.
+     */
+    private readonly computedBindingSpans;
+    /** Local names bound to an imported `export computed`, from the Web interface. */
+    private readonly importedComputedNames;
+    /** The resolved spans of those imports, so a local shadow of the name is not one. */
+    private readonly importedComputedSpans;
+    /** D71 migration state: retired `const x = computed(...)` sites, their reads, and every other `computed` reference. */
+    private readonly retiredAccessorDeclarations;
+    private readonly retiredAccessorReads;
+    private readonly retiredComputedReferences;
+    private readonly migratedComputedCallees;
+    /** Callee span identity -> call span, for every zero-argument call of a plain name. */
+    private readonly plainCallSpans;
+    /** D57 rule 138: `velar/web-test` is legal only where the browser runner looks. */
+    private readonly webModulePath;
+    /** D74: only props whose authors wrote a readonly contract receive prop-specific guidance. */
+    private explicitReadonlyPropBindings;
+    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.
+     */
+    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;
+    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;
+    private writableStateName;
+    /**
+     * 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. The subject
+     * is refused only where the compile can *prove* nothing behind it moves, so a
+     * call whose reactivity lives inside another module is left alone: a rule that
+     * rejected those would be worse than the hole it closes.
+     *
+     * The two refusals are separate because their causes are: a reader that was
+     * not called has one correct spelling to name, and a frozen value has none.
+     */
+    private rejectFrozenWatchSubject;
+    /** 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 is retired in favour of
+     * `cached(...)`, and `const x = computed(() => E)` is retired in favour of the
+     * declaration. 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 the retired `computed` global this pass owns. */
+    private recordRetiredAccessorRead;
+    /**
+     * D71 migration: one message per retired site, and a mechanical rewrite only
+     * where the compile can prove the rewrite. Where the accessor is used as a
+     * value the choice between `computed x = E` and `cached(...)` turns on whether
+     * the caller wants the cache, which is the author's decision — so that site
+     * gets the message and no edit.
+     */
+    private reportRetiredComputedFunction;
+    /**
+     * D71 rule 183 keeps the export-boundary contract the retired spelling had:
+     * an exported cached reader has no inferable public type, so the annotation
+     * is required at the boundary rather than discovered by the importer.
+     */
+    private reportExportedCachedContract;
+    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;
+    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;
+    private checkAnimateBuilderCall;
+    private checkAnimationKeyword;
+    private analyzeKeyframes;
+    private reportKeyframeSnapshotReads;
+    /**
+     * 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;
+    private validateLookStringVocabulary;
+    /**
+     * 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;
+    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;
+    private analyzeComponentRef;
+    private analyzeNativeJsxAttribute;
+    /**
+     * 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;
+    private isJsxAttributeValue;
+    private isOptionalString;
+    private checkWebRouteComponent;
+    private analyzeInlineVisualAttribute;
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,UAAU,EAAE,KAAK,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACzF,OAAO,EACL,QAAQ,EAgBR,KAAK,eAAe,EACpB,KAAK,yBAAyB,EAC9B,KAAK,gCAAgC,EACrC,KAAK,UAAU,EAEf,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,SAAS,EACf,MAAM,iCAAiC,CAAC;AAwEzC,eAAO,MAAM,oBAAoB,iDAAiD,CAAC;AAsFnF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,gCAAgC,GAAG,SAAS,GAAG,SAAS,CAyLlG;AAiaD,qBAAa,gBAAiB,SAAQ,QAAQ;IAC5C,OAAO,CAAC,eAAe,CAA4B;IACnD,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,YAAY,CAAK;IACzB,iHAAiH;IACjH,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,wBAAwB,CAAK;IACrC,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA8B;IACxD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAqB;IACtD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAgC;IACnE,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAuC;IAChF,OAAO,CAAC,gBAAgB,CAAmD;IAC3E,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkC;IAClE,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAqB;IAC1D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IACzD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAsF;IACpH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmC;IAClE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAmC;IACnE,OAAO,CAAC,gBAAgB,CAA0C;IAClE,OAAO,CAAC,gBAAgB,CAAK;IAC7B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAqB;IAC1D,kFAAkF;IAClF,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAsB;IAC5D,qFAAqF;IACrF,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAqB;IAC3D,uHAAuH;IACvH,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAiD;IAC7F,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA6B;IAClE,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAA2B;IACrE,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAqB;IAC7D,uFAAuF;IACvF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA2B;IAC1D,mFAAmF;IACnF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,8FAA8F;IAC9F,OAAO,CAAC,4BAA4B,CAA0C;IAE9E,YAAY,OAAO,GAAE,eAAoB,EAAE,UAAU,GAAE,SAAS,yBAAyB,EAAO,EAW/F;IAEQ,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,UAAU,EAAE,CAUxD;IAED;;;;;;OAMG;IACH,OAAO,CAAC,wBAAwB;IAShC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,uBAAuB;IA6C/B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAW3B,UAAmB,4BAA4B,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAM7E;IAED,UAAmB,yBAAyB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAuG1E;IAED,UAAmB,gBAAgB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAa9D;IAED,OAAO,CAAC,0BAA0B;IAelC,OAAO,CAAC,eAAe;IAWvB,UAAmB,gCAAgC,CAAC,SAAS,EAAE,SAAS,GAAG;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;KAAE,GAAG,IAAI,CAM/H;IAED;;;;;;OAMG;IACH,OAAO,CAAC,0BAA0B;IAgBlC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAKzB,OAAO,CAAC,yBAAyB;IAKjC;;;;;;;OAOG;IACH,UAAmB,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,OAAO,GAAG,MAAgB,GAAG,IAAI,CAWnG;IAED,UAAmB,wBAAwB,CAAC,UAAU,EAAE,UAAU,EAAE,eAAe,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CA2GrH;IAED,UAAmB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,cAAc,GAAE,SAAuB,GAAG,SAAS,CA0B7G;IAID,OAAO,CAAC,iBAAiB;IAIzB;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAqB7B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,wBAAwB;IAkBhC,0EAA0E;IAC1E,OAAO,CAAC,kBAAkB;IAK1B;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IA0B1B,8FAA8F;IAC9F,OAAO,CAAC,eAAe;IAQvB;;;;;OAKG;IACH,OAAO,CAAC,wBAAwB;IAehC;;;;;;OAMG;IACH,OAAO,CAAC,gCAAgC;IAuBxC,kFAAkF;IAClF,OAAO,CAAC,yBAAyB;IAkBjC;;;;;;OAMG;IACH,OAAO,CAAC,6BAA6B;IAgCrC;;;;OAIG;IACH,OAAO,CAAC,4BAA4B;IAYpC,UAAmB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI,CAExF;IAED,UAAmB,kBAAkB,CACnC,MAAM,EAAE,OAAO,iCAAiC,EAAE,kBAAkB,EACpE,UAAU,EAAE,SAAS,UAAU,EAAE,EACjC,aAAa,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,EACrD,QAAQ,EAAE,IAAI,GACb,SAAS,GAAG,SAAS,CASvB;IAED,UAAmB,2BAA2B,CAC5C,MAAM,EAAE,OAAO,iCAAiC,EAAE,UAAU,EAC5D,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,iCAAiC,EAAE,UAAU,KAAK,OAAO,EACnF,OAAO,EAAE,CAAC,SAAS,EAAE,aAAa,KAAK,SAAS,GAC/C,OAAO,GAAG,SAAS,CA8CrB;IAED;;;;;OAKG;IACH,UAAmB,uBAAuB,IAAI,MAAM,GAAG,IAAI,CAM1D;IAED,UAAmB,4BAA4B,IAAI,OAAO,CAGzD;IAED,UAAmB,4BAA4B,IAAI,MAAM,GAAG,IAAI,CAI/D;IAED,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,0BAA0B;IAyBlC,OAAO,CAAC,UAAU;IAalB,OAAO,CAAC,wBAAwB;IAKhC,OAAO,CAAC,gBAAgB;IAwHxB,OAAO,CAAC,oBAAoB;IAO5B,OAAO,CAAC,2BAA2B;IAQnC,UAAmB,iBAAiB,CAAC,SAAS,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,CAE/E;IAED,OAAO,CAAC,2BAA2B;IAsBnC,OAAO,CAAC,qBAAqB;IAkB7B,OAAO,CAAC,kBAAkB;IA4D1B;;;;;;;OAOG;IACH,OAAO,CAAC,uBAAuB;IAyB/B;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAS3B;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IA2C5B,OAAO,CAAC,uBAAuB;IAkC/B,OAAO,CAAC,qBAAqB;IAO7B,OAAO,CAAC,gBAAgB;IAgCxB,OAAO,CAAC,2BAA2B;IAqBnC;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAQvB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAgCxB,OAAO,CAAC,4BAA4B;IA8DpC;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;IAWnC,OAAO,CAAC,kBAAkB;IAiE1B,OAAO,CAAC,sBAAsB;IAa9B,OAAO,CAAC,QAAQ;IA8DhB,OAAO,CAAC,uBAAuB;IAe/B,OAAO,CAAC,wBAAwB;IAuBhC,OAAO,CAAC,uBAAuB;IA8E/B;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IAsB/B,OAAO,CAAC,mBAAmB;IA2B3B,OAAO,CAAC,yBAAyB;IAwGjC;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IAc/B;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAM5B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAwBpB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IA0BxB,OAAO,CAAC,yBAAyB;IAcjC,OAAO,CAAC,WAAW;IASnB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,sBAAsB;IAY9B,OAAO,CAAC,4BAA4B;CAmBrC"}