@velarscript/web 0.23.4 → 0.25.0

package/README.md

@@ -92,7 +92,10 @@ The package also owns Look, the checked visual language integrated with VelarScr
 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.
+Native and component JSX accept universal `class` and `look` props, checked
+`look:property` and `style:property` directives, and a raw `style` attribute is
+rejected. A design system's CSS custom property is read by `token("--name")`,
+which is legal in every Look property, so a token-driven visual layer stays
+inside Look. Raw CSS is available 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

@@ -10,10 +10,14 @@ export declare class VelarWebAnalyzer extends Analyzer {
     private watchBodyDepth;
     /** D89 A4: the binding identity of every list a keyed `.map(...)` interpolation renders. */
     private readonly keyedListSources;
-    /** D89 A4: every `list = list.map(item => {…})` rewrite of this module, in source order. */
+    /** D89 A4: every row rebuild of this module — assigned or derived — in source order. */
     private readonly keyedListRebuilds;
+    /** D89 A4: this module's `def` bodies by name, so a `computed` that calls one can be read through. */
+    private moduleFunctions;
     private synchronousReactiveDepth;
     private jsxDepth;
+    /** VEL5075: how many component bodies enclose the declaration being analyzed. */
+    private componentBodyDepth;
     private readonly resources;
     private readonly unsafeCssImports;
     private readonly probedOperandTypes;
@@ -124,6 +128,32 @@ export declare class VelarWebAnalyzer extends Analyzer {
     protected inferExtensionExpression(expression: Expression, _contextualType: ValueType): ValueType | undefined;
     protected inferExpression(expression: Expression, contextualType?: ValueType): ValueType;
     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
@@ -184,12 +214,33 @@ export declare class VelarWebAnalyzer extends Analyzer {
      */
     private recordKeyedListRebuild;
     /**
-     * D89 A4: raises the advisory for the rewrites whose list a keyed position
+     * 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 `map` plus a record
-     * literal is the only spelling, which a `readonly` list or one API response
-     * makes it.
+     * 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. */
@@ -306,6 +357,24 @@ export declare class VelarWebAnalyzer extends Analyzer {
     private checkAnimationKeyword;
     private analyzeKeyframes;
     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

package/dist/analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"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"}

package/dist/analyzer.js

@@ -2,7 +2,7 @@ import { mechanicalEdits, mechanicalFix, semanticTypeIdentity } from "@velarscri
 import { Analyzer, anyType, boolType, describeType, expressionContainsDirectAwait, invalidType, isInvalidType, isAssignable, isReadonlyView, nullType, nonOptional, numberType, optionalOf, spanIdentity, stringType, unknownType, } from "@velarscript/compiler/extension";
 import { BROWSER_TEST_MODULE, BROWSER_TEST_SOURCE_SUFFIX, browserTestImportGuidance } from "./browser-test.js";
 import { cssTokens } from "./css-tokens.js";
-import { LOOK_ABSENT_MEDIA_SUBJECTS, LOOK_ARITHMETIC_HINT, LOOK_ANIMATION_DIRECTIONS, LOOK_ANIMATION_EASINGS, LOOK_ANIMATION_FILLS, LOOK_BORDER_STYLE_NAMES, LOOK_BUILDER_NUMERIC_RANGES, LOOK_BUILDER_SIGNATURES, LOOK_BUILDERS, LOOK_EXCLUDED_PROPERTIES, LOOK_HOOKS, LOOK_CSS_WIDE_KEYWORDS, LOOK_LARGE_KEYWORD_SETS, LOOK_LENGTH_BUILDERS, LOOK_MEDIA_LENGTH_UNITS, LOOK_MEDIA_SUBJECTS, LOOK_NUMERIC_TYPE_NAMES, LOOK_NON_ANIMATABLE_PROPERTIES, LOOK_PARTIAL_KEYWORD_PROPERTIES, LOOK_PROPERTIES, LOOK_PROPERTY_KEYWORDS, LOOK_PROPERTY_VALUE_KINDS, LOOK_TARGETS, LOOK_TOKEN_NAME_RULE, LOOK_TOKEN_NO_FALLBACK_GUIDANCE, LOOK_UNIT_TYPES, LOOK_UNITLESS_PROPERTIES, isLookTokenName, isLookVarReference, lookOwnKeywords, lookTokenReference, lookVarReferenceName, nearestLookName, } from "./look.js";
+import { LOOK_ABSENT_MEDIA_SUBJECTS, LOOK_ARITHMETIC_HINT, LOOK_ANIMATION_DIRECTIONS, LOOK_ANIMATION_EASINGS, LOOK_ANIMATION_FILLS, LOOK_BORDER_STYLE_NAMES, LOOK_BUILDER_NUMERIC_RANGES, LOOK_BUILDER_SIGNATURES, LOOK_BUILDERS, LOOK_EXCLUDED_PROPERTIES, LOOK_HOOKS, LOOK_CSS_WIDE_KEYWORDS, LOOK_LARGE_KEYWORD_SETS, LOOK_LENGTH_BUILDERS, LOOK_MEDIA_LENGTH_UNITS, LOOK_MEDIA_SUBJECTS, LOOK_NUMERIC_TYPE_NAMES, LOOK_NON_ANIMATABLE_PROPERTIES, LOOK_PARTIAL_KEYWORD_PROPERTIES, LOOK_PROPERTIES, LOOK_PROPERTY_KEYWORDS, LOOK_PROPERTY_VALUE_KINDS, LOOK_TARGETS, LOOK_TOKEN_NAME_RULE, LOOK_TOKEN_NO_FALLBACK_GUIDANCE, LOOK_UNIT_TYPES, LOOK_UNITLESS_PROPERTIES, isLookTokenName, isLookVarReference, lookOwnKeywords, lookShorthandOverlap, lookShorthandParts, lookTokenReference, lookVarReferenceName, nearestLookName, } from "./look.js";
 import { collectLookStaticValues, evaluateLookStaticExpression, isLookStaticValue, lookStaticCss } from "./look-static.js";
 import { keyframeCssValue } from "./keyframes.js";
 import { byCodeUnit } from "./stable-order.js";
@@ -428,6 +428,21 @@ function lookShorthandStringGuidance(name, value) {
     }
     return null;
 }
+/**
+ * D104 rule 2 — what a refusal says when two entries in one scope write the
+ * same CSS declaration. Written once because two positions raise it: a Look
+ * block's entries and an element's `look:` directives lower to the same
+ * one-rule-per-property stylesheet, so they have the same defect and deserve
+ * the same sentence (D57 rule 134).
+ *
+ * The message leads with the mechanism, because the pair is legal CSS and the
+ * author has every reason to expect source order to settle it. It does not
+ * here: see LOOK_SHORTHAND_LONGHANDS for why the winner is decided module-wide.
+ */
+function lookShorthandOverlapMessage(shorthand, longhand, subject) {
+    const parts = lookShorthandParts(shorthand);
+    return `${subject} sets '${shorthand}' and '${longhand}', and the shorthand writes the longhand. Look lowers every entry to its own CSS rule and orders those rules by where each property first appears in the module rather than by this block, so which of the two wins is not this code's to choose — an unrelated look elsewhere in the module decides it. Write ${parts.join(", ")} in place of '${shorthand}', or drop '${longhand}'`;
+}
 const lookCssWideKeywords = new Set(LOOK_CSS_WIDE_KEYWORDS);
 const lookSharedMetricKeywords = ["auto", "none", "normal", "min-content", "max-content", "fit-content", "stretch"];
 const lookMetricKeywords = new Set([...lookCssWideKeywords, ...lookSharedMetricKeywords]);
@@ -1275,6 +1290,134 @@ function keyedRebuiltRecord(body, row) {
     }
     return null;
 }
+/**
+ * D89 A4, the wider proven shape: every `def` of the module by name, so a
+ * `computed` whose initializer calls one can be read through to what that call
+ * builds. A name declared twice maps to null — two bodies under one name make
+ * the question unanswerable, and an advisory that cannot prove which body runs
+ * stays silent rather than guessing.
+ */
+function collectModuleFunctions(program) {
+    const functions = new Map();
+    const record = (statements) => {
+        for (const statement of statements) {
+            if (statement.kind === "FunctionDeclaration") {
+                functions.set(statement.name, functions.has(statement.name) ? null : statement);
+                record(statement.body);
+                continue;
+            }
+            if (isWebStatement(statement) && statement.kind === "ExtensionStatement:web:component") {
+                record(statement.body);
+            }
+        }
+    };
+    record(program.body);
+    return functions;
+}
+/** Every name a binding pattern introduces, added to `names`. */
+function collectPatternNames(pattern, names) {
+    if (pattern.kind === "NameBindingPattern") {
+        names.add(pattern.name);
+        return;
+    }
+    if (pattern.kind === "ListBindingPattern") {
+        for (const element of pattern.elements)
+            if (element)
+                collectPatternNames(element, names);
+    }
+    else {
+        for (const entry of pattern.entries)
+            collectPatternNames(entry.pattern, names);
+    }
+    if (pattern.rest)
+        names.add(pattern.rest.name);
+}
+/** True when the expression reads one of `names` anywhere inside it. */
+function readsAnyName(value, names) {
+    if (!value || typeof value !== "object")
+        return false;
+    if (Array.isArray(value))
+        return value.some((item) => readsAnyName(item, names));
+    const record = value;
+    if (record.kind === "IdentifierExpression" && typeof record.name === "string" && names.has(record.name))
+        return true;
+    return Object.values(record).some((child) => readsAnyName(child, names));
+}
+/**
+ * D89 A4, the wider proven shape: whether a `def` answers a list it filled with
+ * freshly constructed records — the `for`/`append` builder that spells the same
+ * churn `list = list.map(item => {…})` spells with `map`, and the spelling the
+ * P2b consumer actually wrote.
+ *
+ * Four things are proven, and any one of them missing leaves the advisory
+ * silent, because the whole product is naming a rebuild that really happens:
+ *
+ * 1. the body's last statement returns a name it declared here, initialized to
+ *    an empty list literal — so the list is the `def`'s own, not one handed in;
+ * 2. every value appended to that list is a record literal, so every element is
+ *    a new value on every call. One `append(row)` of a source record is the
+ *    identity-preserving spelling this advisory teaches, and one member call
+ *    the proof cannot read leaves the whole answer unproven;
+ * 3. at least one such record reads a parameter of the `def` or the binding of
+ *    the `for` that appends it. A builder whose records are constant answers
+ *    the same content every call, so nothing it is derived from can move and
+ *    the `computed` over it never recomputes;
+ * 4. nothing else touches the list — it is built and answered, nothing more.
+ */
+function buildsFreshRecords(declaration) {
+    const returned = declaration.body.at(-1);
+    if (!returned || returned.kind !== "ReturnStatement" || returned.value?.kind !== "IdentifierExpression")
+        return false;
+    const built = returned.value.name;
+    const local = declaration.body.find((statement) => statement.kind === "VariableDeclaration"
+        && statement.pattern.kind === "NameBindingPattern" && statement.pattern.name === built);
+    if (!local || local.kind !== "VariableDeclaration")
+        return false;
+    if (local.initializer.kind !== "ListExpression" || local.initializer.elements.length > 0)
+        return false;
+    const parameters = new Set(declaration.parameters.map((parameter) => parameter.name));
+    let records = 0;
+    let varying = false;
+    let unproven = false;
+    const walk = (statements, visible) => {
+        for (const statement of statements) {
+            if (statement.kind === "ForStatement") {
+                const inner = new Set(visible);
+                collectPatternNames(statement.pattern, inner);
+                if (statement.secondPattern)
+                    collectPatternNames(statement.secondPattern, inner);
+                walk(statement.body, inner);
+                continue;
+            }
+            if (statement.kind === "IfStatement") {
+                walk(statement.thenBody, visible);
+                walk(statement.elseBody ?? [], visible);
+                continue;
+            }
+            if (statement.kind === "WhileStatement") {
+                walk(statement.body, visible);
+                continue;
+            }
+            if (statement.kind !== "ExpressionStatement")
+                continue;
+            const call = statement.expression;
+            if (call.kind !== "CallExpression" || call.callee.kind !== "MemberExpression")
+                continue;
+            if (call.callee.object.kind !== "IdentifierExpression" || call.callee.object.name !== built)
+                continue;
+            const [appended] = call.arguments;
+            if (call.callee.property !== "append" || !appended || appended.kind !== "ObjectExpression") {
+                unproven = true;
+                continue;
+            }
+            records += 1;
+            if (readsAnyName(appended, visible))
+                varying = true;
+        }
+    };
+    walk(declaration.body, parameters);
+    return !unproven && records > 0 && varying;
+}
 /**
  * The reactive declarations a `def` body may not hold when the `def` answers
  * `WebNode`. `watch`, `resource` and `action` are already refused outside a
@@ -1396,6 +1539,59 @@ function subtreeHoldsJsx(value) {
     }
     return false;
 }
+/**
+ * VEL5075: the JSX elements a body's own `return`s *start* with — the roots of
+ * the returned markup, which is where the emitter decides between an instance
+ * and a child. The walk descends through ordinary expression nodes, `.map(...)`
+ * callbacks included, and stops at the first JSX element on every path: inside
+ * one, every JSX position is a child position and needs no verdict. A nested
+ * `def` or `component` owns its own returns, exactly as it does elsewhere here.
+ */
+function returnedMarkupRoots(body) {
+    const roots = [];
+    const collect = (value) => {
+        const pending = [value];
+        while (pending.length > 0) {
+            const entry = pending.pop();
+            if (Array.isArray(entry)) {
+                for (const item of entry)
+                    pending.push(item);
+                continue;
+            }
+            if (entry === null || typeof entry !== "object")
+                continue;
+            const node = entry;
+            if (node.kind === "ExtensionExpression:web:jsx") {
+                roots.push(node);
+                continue;
+            }
+            for (const key of Object.keys(node))
+                pending.push(node[key]);
+        }
+    };
+    const pending = [...body];
+    while (pending.length > 0) {
+        const value = pending.pop();
+        if (Array.isArray(value)) {
+            for (const entry of value)
+                pending.push(entry);
+            continue;
+        }
+        if (value === null || typeof value !== "object")
+            continue;
+        const node = value;
+        const kind = typeof node.kind === "string" ? node.kind : null;
+        if (kind === "FunctionDeclaration" || kind === "ExtensionStatement:web:component")
+            continue;
+        if (kind === "ReturnStatement") {
+            collect(node.value);
+            continue;
+        }
+        for (const key of Object.keys(node))
+            pending.push(node[key]);
+    }
+    return roots;
+}
 /** The component spelling of a helper's name: components render as a PascalCase tag. */
 function componentSpelling(name) {
     return name.length === 0 ? name : `${name[0].toUpperCase()}${name.slice(1)}`;
@@ -1413,10 +1609,14 @@ export class VelarWebAnalyzer extends Analyzer {
     watchBodyDepth = 0;
     /** D89 A4: the binding identity of every list a keyed `.map(...)` interpolation renders. */
     keyedListSources = new Set();
-    /** D89 A4: every `list = list.map(item => {…})` rewrite of this module, in source order. */
+    /** D89 A4: every row rebuild of this module — assigned or derived — in source order. */
     keyedListRebuilds = [];
+    /** D89 A4: this module's `def` bodies by name, so a `computed` that calls one can be read through. */
+    moduleFunctions = new Map();
     synchronousReactiveDepth = 0;
     jsxDepth = 0;
+    /** VEL5075: how many component bodies enclose the declaration being analyzed. */
+    componentBodyDepth = 0;
     resources;
     unsafeCssImports = new Set();
     probedOperandTypes = new Map();
@@ -1478,6 +1678,7 @@ export class VelarWebAnalyzer extends Analyzer {
         this.rejectWebOwnedTypeNames(program);
         this.keyedListSources.clear();
         this.keyedListRebuilds.length = 0;
+        this.moduleFunctions = collectModuleFunctions(program);
         super.analyze(program);
         this.reportStaticJsxKeys();
         this.reportRetiredComputedFunction();
@@ -1591,8 +1792,10 @@ export class VelarWebAnalyzer extends Analyzer {
         if (statement.kind === "VariableDeclaration") {
             this.recordRetiredAccessorDeclaration(statement);
         }
-        if (statement.kind === "FunctionDeclaration")
+        if (statement.kind === "FunctionDeclaration") {
             this.rejectStatefulWebNodeFunction(statement);
+            this.rejectUnownedComponentElement(statement);
+        }
         if (!isWebStatement(statement))
             return false;
         switch (statement.kind) {
@@ -1771,6 +1974,7 @@ export class VelarWebAnalyzer extends Analyzer {
         this.declareBinding(statement.name, false, declared, statement.span);
         this.markDeclaredBindingReactive(statement.name, "prop");
         this.computedBindingSpans.add(spanIdentity(statement.span));
+        this.recordDerivedKeyedListRebuild(statement);
     }
     /**
      * True when `name` resolves to a `computed` declaration or to an imported one.
@@ -1944,6 +2148,49 @@ export class VelarWebAnalyzer extends Analyzer {
     writableStateName(name) {
         return this.reactiveBindingKind(name) === "state";
     }
+    /**
+     * 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.
+     */
+    rejectUnownedComponentElement(statement) {
+        // A helper nested in a component body is emitted with that component's
+        // scope in hand, so its component elements are `__velarChild` and answer
+        // nodes. Only a helper standing outside every component body has nowhere
+        // for the emitter to put them.
+        if (this.componentBodyDepth > 0)
+            return;
+        const answersMarkup = statement.returnType
+            ? carriesWebNode(this.resolveAnnotation(statement.returnType))
+            : bodyReturnsJsx(statement.body);
+        if (!answersMarkup)
+            return;
+        for (const element of returnedMarkupRoots(statement.body)) {
+            if (!/^[A-Z]/u.test(element.tag))
+                continue;
+            this.diagnostics.push(diagnostic("VEL5075", `'${statement.name}' answers markup with the component element '<${element.tag} />', and a component element standing on its own is an instance rather than a node: it is built by the position that shows it, and a 'def' is not one, so what this returns fails the moment JSX tries to render it. Write '<${element.tag} />' where it is rendered — a component's own body, or a child position inside markup this returns such as '<div><${element.tag} ... /></div>' — and keep the helper for the native elements it builds.`, element.span));
+        }
+    }
     /**
      * 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
@@ -2088,6 +2335,7 @@ export class VelarWebAnalyzer extends Analyzer {
         if (!binding)
             return;
         this.keyedListRebuilds.push({
+            kind: "assignment",
             source: spanIdentity(binding.span),
             name: statement.target.name,
             field: rebuilt.field,
@@ -2095,12 +2343,57 @@ export class VelarWebAnalyzer extends Analyzer {
         });
     }
     /**
-     * D89 A4: raises the advisory for the rewrites whose list a keyed position
+     * 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.
+     */
+    recordDerivedKeyedListRebuild(statement) {
+        if (!this.rebuildsRecordsPerElement(statement.initializer))
+            return;
+        this.keyedListRebuilds.push({
+            kind: "derived",
+            source: spanIdentity(statement.span),
+            name: statement.name,
+            field: null,
+            span: statement.span,
+        });
+    }
+    /**
+     * 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.
+     */
+    rebuildsRecordsPerElement(value) {
+        if (value.kind !== "CallExpression")
+            return false;
+        if (value.callee.kind === "MemberExpression" && value.callee.property === "map") {
+            const callback = value.arguments[0];
+            if (!callback || callback.kind !== "ArrowFunctionExpression" || callback.parameters.length !== 1)
+                return false;
+            const [row] = callback.parameters;
+            return row !== undefined && keyedRebuiltRecord(callback.body, row.name) !== null;
+        }
+        if (value.callee.kind !== "IdentifierExpression")
+            return false;
+        const declaration = this.moduleFunctions.get(value.callee.name);
+        return declaration !== undefined && declaration !== null && buildsFreshRecords(declaration);
+    }
+    /**
+     * 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 `map` plus a record
-     * literal is the only spelling, which a `readonly` list or one API response
-     * makes it.
+     * 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.
      */
     adviseKeyedListRebuilds() {
         for (const rebuild of this.keyedListRebuilds) {
@@ -2110,8 +2403,13 @@ export class VelarWebAnalyzer extends Analyzer {
             // the same key and then drops it because the row it holds is no longer
             // the same value, so a message blaming the key sends an author to check
             // `id`, find it unchanged, and conclude the advisory is wrong.
-            const field = rebuild.field ?? "<field>";
-            this.advise("A4", `This rebuilds every row of '${rebuild.name}', so every row is a new value and the keyed list that renders '${rebuild.name}' no longer recognises any of them: it destroys and rebuilds all of its children — an input being typed into loses focus. Change the field in place instead: '${rebuild.name}[index].${field} = ...'`, rebuild.span);
+            // A derived value has no row to write: whatever it hands the keyed
+            // position it built itself. The two ways out are to render the rows that
+            // do have an identity, or to carry those same records through.
+            const remedy = rebuild.kind === "derived"
+                ? "A derived value cannot keep rows it builds: render the source rows and change the field on them in place, or carry the source records through instead of constructing new ones."
+                : `Change the field in place instead: '${rebuild.name}[index].${rebuild.field ?? "<field>"} = ...'`;
+            this.advise("A4", `This rebuilds every row of '${rebuild.name}'${rebuild.kind === "derived" ? " on every recompute" : ""}, so every row is a new value and the keyed list that renders '${rebuild.name}' no longer recognises any of them: it destroys and rebuilds all of its children — an input being typed into loses focus. ${remedy}`, rebuild.span);
         }
     }
     /** A value that is read by calling it and takes no arguments to do so. */
@@ -2419,6 +2717,9 @@ export class VelarWebAnalyzer extends Analyzer {
         const outerConstructorDepth = this.constructorDepth;
         if (!this.isPredeclared(statement))
             this.declareBinding(statement.name, false, this.componentType(statement), statement.span);
+        // VEL5075: a `def` written from here to the matching decrement lowers
+        // through this component's scope, so its component elements are children.
+        this.componentBodyDepth += 1;
         this.enterScope();
         this.flowFrameDepth += 1;
         const previousStates = this.componentStates;
@@ -2559,6 +2860,7 @@ export class VelarWebAnalyzer extends Analyzer {
         this.explicitReadonlyPropBindings = previousExplicitReadonlyProps;
         this.flowFrameDepth -= 1;
         this.exitScope();
+        this.componentBodyDepth -= 1;
         this.constructorDepth = outerConstructorDepth;
     }
     containsReadonlyView(type) {
@@ -2673,6 +2975,7 @@ export class VelarWebAnalyzer extends Analyzer {
                 this.analyzeLookEntries(entry.entries, true, true, inheritedTerms, repeated ? `${scopeKey}@${entry.name}#${entry.span.start}` : `${scopeKey}@${entry.name}`);
                 continue;
             }
+            this.reportLookShorthandOverlap(scopeKey, entry.name, entry.span);
             if (!this.recordLookEntry(scopeKey, entry.name)) {
                 this.diagnostics.push(diagnostic("VEL5039", `Look property '${entry.name}' is defined more than once in the same scope`, entry.span));
             }
@@ -2998,6 +3301,46 @@ export class VelarWebAnalyzer extends Analyzer {
         };
         visit(expression);
     }
+    /**
+     * 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.
+     */
+    reportLookShorthandOverlap(scopeKey, name, span) {
+        for (const other of this.lookEntryScopes.get(scopeKey) ?? []) {
+            const overlap = lookShorthandOverlap(other, name);
+            if (!overlap)
+                continue;
+            this.diagnostics.push(diagnostic("VEL5039", lookShorthandOverlapMessage(overlap.shorthand, overlap.longhand, "This Look scope"), span));
+            return;
+        }
+    }
+    /**
+     * 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.
+     */
+    reportLookDirectiveOverlap(expression) {
+        const written = [];
+        for (const attribute of expression.attributes) {
+            if (!attribute.name.startsWith("look:"))
+                continue;
+            const property = attribute.name.slice("look:".length);
+            if (!LOOK_PROPERTIES.has(property))
+                continue;
+            const overlapping = written.map((other) => lookShorthandOverlap(other, property)).find(Boolean);
+            if (overlapping) {
+                this.diagnostics.push(diagnostic("VEL5039", lookShorthandOverlapMessage(overlapping.shorthand, overlapping.longhand, `Element '<${expression.tag}>'`), attribute.span));
+            }
+            written.push(property);
+        }
+    }
     /**
      * Records one entry in its lowered scope (condition signature plus target) so
      * two sibling blocks with the same condition report the property they both
@@ -3309,6 +3652,7 @@ export class VelarWebAnalyzer extends Analyzer {
         }
         if (attributes.size !== expression.attributes.length)
             this.diagnostics.push(diagnostic("VEL5014", `JSX element '${expression.tag}' has duplicate attributes`, expression.span));
+        this.reportLookDirectiveOverlap(expression);
         for (const attribute of expression.attributes) {
             if (removedJsxControlAttributes.has(attribute.name)) {
                 this.diagnostics.push(diagnostic("VEL5029", `JSX '${attribute.name}' was removed; branch with an ordinary expression such as {condition ? <A /> : <B />}`, attribute.span));