@velarscript/web 0.29.2 → 0.30.1

package/README.md

@@ -1,5 +1,9 @@
 # @velarscript/web
 
+**VelarScript 0.30.1 · Web surface `web@0.14`.** The counter is what a project
+declares in `velar.json`'s `surfaces` and what a mismatch is refused by; the
+release number every toolchain package steps to says only what you installed.
+
 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`,
@@ -20,15 +24,19 @@ 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"
+import {hsl, rgb, spacing} from "velar/look"
 
 const accent = rgb(45, 79, 190)
+const accentTint = hsl(224, 62%, 95%)
 const pagePadding = spacing(24px, 16px)
 ```
 
+`hsl`'s saturation and lightness are a `Percentage`, the spelling CSS uses for
+those two slots; a bare number is refused with the percentage it meant, and
+`velar fix` writes it where the argument is a literal. The hue stays a number.
+
 One-off base properties use the same checked table through JSX directives, and
 remain ordered after any composed Look:
 

package/dist/analysis/look-values.d.ts

@@ -5,7 +5,8 @@
  * D115 §三: one question about types, asked in two places, so it is written
  * once here rather than twice in the middle of the Web analyzer.
  */
-import { type Expression, type ValueType } from "@velarscript/compiler/extension";
+import { type Diagnostic } from "@velarscript/compiler";
+import { type Expression, type Span, type ValueType } from "@velarscript/compiler/extension";
 export declare function isLookNumericType(type: ValueType): boolean;
 /**
  * The type two visual operands add up to: the same kind on both sides keeps it,
@@ -27,4 +28,78 @@ export declare function lookAdditiveType(left: ValueType, right: ValueType, same
 export declare function foldedLengthPercentage(expression: Extract<Expression, {
     kind: "CallExpression";
 }>, builderOf: (name: string) => string | undefined, inferSlot: (argument: Expression) => ValueType, join: (left: ValueType, right: ValueType) => ValueType | null): ValueType | null;
+/**
+ * Where the bare number a builder slot refused is actually written, and the
+ * binding it came through when that is not the argument itself.
+ *
+ * D114 F9-web (WB-I7): `hsl(210, sat, 45%)` under `const sat = 70` folds to a
+ * number, and the report was drawn under `sat` while its remedy said `70%` — so
+ * an author editing at the caret replaced the binding's use with a literal. The
+ * number is written in the binding's initializer, so that is where the caret
+ * goes, and the sentence names the binding so the line it lands on is explained.
+ * A constant imported from another module has no site here and keeps the
+ * argument's own span, which is the only position this compile can point at.
+ */
+export type LookStaticSites = ReadonlyMap<string, Span>;
+/**
+ * D114 P6 item 2 (LK-I3): a bare number written where a builder slot takes a
+ * `Percentage`.
+ *
+ * The refusal already exists and is already in the right place — it is core's
+ * assignability check on the argument — so this teaches that one the remedy
+ * instead of adding a second report of one mistake. The message names the
+ * percentage the author meant, and `velar fix` writes it where the argument is
+ * a literal; an identifier that folded to a number is a binding whose
+ * declaration is the place to change, so it earns the sentence there and no
+ * rewrite — retyping the binding is not a mechanical edit, because every other
+ * use of it is part of the answer.
+ *
+ * Returns whether the refusal was found and taught.
+ */
+export declare function teachLookPercentageSlot(diagnostics: Diagnostic[], slot: string, argument: Expression, literal: number, sites: LookStaticSites): boolean;
+/**
+ * D114 F7-web-b: a bare number written in a builder slot that will not take
+ * one — the mistake LK-I3 found on `hsl`, which on the length builders had been
+ * left drawing two reports about one number: core's `Cannot assign number to
+ * Length` and this analyzer's unit advice, side by side.
+ *
+ * Which slots those are is the builder's own published type, handed in by the
+ * caller, so there is no second table of builder positions kept in step by
+ * hand. Three shapes, three lessons:
+ *
+ *   - a slot whose type is exactly `Length` — `blur`'s radius, `border`'s
+ *     width, the offsets and spread of `shadow` and `dropShadow` — has one
+ *     natural unit, so the sentence names it and `velar fix` writes `4px`;
+ *   - a slot that takes a length *or* a percentage — `min`, `max` and `clamp`,
+ *     the three builders that exist to mix them — names both spellings and
+ *     offers no rewrite, because `100px` and `100%` are different pictures and
+ *     the one the author meant is not the compiler's to guess;
+ *   - a slot whose union admits `number` as well — `spacing`, `tracks`,
+ *     `minmax` — draws no refusal from core at all, so the unit advice is the
+ *     whole diagnosis, and zero passes because that union really does take it.
+ *
+ * D114 F9-web (WB-I2): all three sentences are one sentence, built from the
+ * slot's own published type, because the advice used to be written twice. The
+ * unit advice said "(only 0 is unitless)" for every builder that composes
+ * lengths — true of the third shape, whose union takes a bare `0`, and a
+ * falsehood on `blur` and `shadow`, where `blur(0)` is refused. A slot cannot
+ * now be told what it takes by anything but its type: `slotAccepts` reads it,
+ * and the "or 0" clause exists exactly where a bare number is accepted.
+ *
+ * Zero is refused in the first two: `blur(0)` and `min(0, 600px)` are not CSS,
+ * so the slot says what to write. A slot that admits no length at all — a
+ * colour, a border style, `inset` — is not this rule's business and earns
+ * nothing here.
+ *
+ * D114 WB-X1: `declared` is the builder's whole published type rather than one
+ * slot of it, because a rest parameter's type is the type of every position it
+ * collects and reading `parameters[position]` stopped at the last named one.
+ * `tracks(4, 8px)` was refused and `tracks(8px, 4)` drew nothing at all — the
+ * second argument of a builder whose signature declares one parameter had no
+ * published type to read, so the lesson never ran there.
+ *
+ * Returns whether the argument was refused here, which is the caller's record
+ * that this call failed its own argument check.
+ */
+export declare function teachLookLengthSlot(diagnostics: Diagnostic[], builder: string, position: number, declared: ValueType, argument: Expression, literal: number, sites: LookStaticSites): boolean;
 //# sourceMappingURL=look-values.d.ts.map

package/dist/analysis/look-values.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"look-values.d.ts","sourceRoot":"","sources":["../../src/analysis/look-values.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAMlF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAE1D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAO3G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,EAC3D,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,EAC/C,SAAS,EAAE,CAAC,QAAQ,EAAE,UAAU,KAAK,SAAS,EAC9C,IAAI,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,KAAK,SAAS,GAAG,IAAI,GAC5D,SAAS,GAAG,IAAI,CAclB"}
+{"version":3,"file":"look-values.d.ts","sourceRoot":"","sources":["../../src/analysis/look-values.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,IAAI,EAAE,KAAK,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAM7F,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAE1D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAO3G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,EAC3D,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,EAC/C,SAAS,EAAE,CAAC,QAAQ,EAAE,UAAU,KAAK,SAAS,EAC9C,IAAI,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,KAAK,SAAS,GAAG,IAAI,GAC5D,SAAS,GAAG,IAAI,CAclB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAkBxD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,UAAU,EAAE,EACzB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,GACrB,OAAO,CAUT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,UAAU,EAAE,EACzB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,SAAS,EACnB,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,GACrB,OAAO,CAiCT"}

package/dist/analysis/look-values.js

@@ -5,6 +5,7 @@
  * D115 §三: one question about types, asked in two places, so it is written
  * once here rather than twice in the middle of the Web analyzer.
  */
+import { mechanicalFix } from "@velarscript/compiler";
 import {} from "@velarscript/compiler/extension";
 import { LOOK_BUILDER_SIGNATURES, LOOK_NUMERIC_TYPE_NAMES } from "../look.js";
 const lookLengthPercentage = { kind: "named", name: "LengthPercentage" };
@@ -58,4 +59,196 @@ export function foldedLengthPercentage(expression, builderOf, inferSlot, join) {
     }
     return folded;
 }
+function lookSlotOrigin(argument, sites) {
+    if (argument.kind !== "IdentifierExpression")
+        return { span: argument.span, binding: null };
+    const site = sites.get(argument.name);
+    return site === undefined ? { span: argument.span, binding: null } : { span: site, binding: argument.name };
+}
+/** "4 is a number", or "'n' holds 4, a number" where the argument folded through a binding. */
+function heldNumber(origin, written, refused) {
+    return origin.binding === null ? `${written} is ${refused}` : `'${origin.binding}' holds ${written}, ${refused}`;
+}
+/**
+ * D114 P6 item 2 (LK-I3): a bare number written where a builder slot takes a
+ * `Percentage`.
+ *
+ * The refusal already exists and is already in the right place — it is core's
+ * assignability check on the argument — so this teaches that one the remedy
+ * instead of adding a second report of one mistake. The message names the
+ * percentage the author meant, and `velar fix` writes it where the argument is
+ * a literal; an identifier that folded to a number is a binding whose
+ * declaration is the place to change, so it earns the sentence there and no
+ * rewrite — retyping the binding is not a mechanical edit, because every other
+ * use of it is part of the answer.
+ *
+ * Returns whether the refusal was found and taught.
+ */
+export function teachLookPercentageSlot(diagnostics, slot, argument, literal, sites) {
+    const written = `${Number(literal.toPrecision(12))}%`;
+    const origin = lookSlotOrigin(argument, sites);
+    const rewritable = argument.kind === "LiteralExpression" && typeof argument.value === "number";
+    return teachSlotRefusal(diagnostics, argument, "Percentage", (item) => ({
+        ...item,
+        span: origin.span,
+        message: `${slot} is a percentage, and ${heldNumber(origin, String(literal), "a number")}; write ${written}`,
+        ...(rewritable ? { fix: mechanicalFix(argument.span, written, `Write ${written}`) } : {}),
+    }));
+}
+/**
+ * D114 F7-web-b: a bare number written in a builder slot that will not take
+ * one — the mistake LK-I3 found on `hsl`, which on the length builders had been
+ * left drawing two reports about one number: core's `Cannot assign number to
+ * Length` and this analyzer's unit advice, side by side.
+ *
+ * Which slots those are is the builder's own published type, handed in by the
+ * caller, so there is no second table of builder positions kept in step by
+ * hand. Three shapes, three lessons:
+ *
+ *   - a slot whose type is exactly `Length` — `blur`'s radius, `border`'s
+ *     width, the offsets and spread of `shadow` and `dropShadow` — has one
+ *     natural unit, so the sentence names it and `velar fix` writes `4px`;
+ *   - a slot that takes a length *or* a percentage — `min`, `max` and `clamp`,
+ *     the three builders that exist to mix them — names both spellings and
+ *     offers no rewrite, because `100px` and `100%` are different pictures and
+ *     the one the author meant is not the compiler's to guess;
+ *   - a slot whose union admits `number` as well — `spacing`, `tracks`,
+ *     `minmax` — draws no refusal from core at all, so the unit advice is the
+ *     whole diagnosis, and zero passes because that union really does take it.
+ *
+ * D114 F9-web (WB-I2): all three sentences are one sentence, built from the
+ * slot's own published type, because the advice used to be written twice. The
+ * unit advice said "(only 0 is unitless)" for every builder that composes
+ * lengths — true of the third shape, whose union takes a bare `0`, and a
+ * falsehood on `blur` and `shadow`, where `blur(0)` is refused. A slot cannot
+ * now be told what it takes by anything but its type: `slotAccepts` reads it,
+ * and the "or 0" clause exists exactly where a bare number is accepted.
+ *
+ * Zero is refused in the first two: `blur(0)` and `min(0, 600px)` are not CSS,
+ * so the slot says what to write. A slot that admits no length at all — a
+ * colour, a border style, `inset` — is not this rule's business and earns
+ * nothing here.
+ *
+ * D114 WB-X1: `declared` is the builder's whole published type rather than one
+ * slot of it, because a rest parameter's type is the type of every position it
+ * collects and reading `parameters[position]` stopped at the last named one.
+ * `tracks(4, 8px)` was refused and `tracks(8px, 4)` drew nothing at all — the
+ * second argument of a builder whose signature declares one parameter had no
+ * published type to read, so the lesson never ran there.
+ *
+ * Returns whether the argument was refused here, which is the caller's record
+ * that this call failed its own argument check.
+ */
+export function teachLookLengthSlot(diagnostics, builder, position, declared, argument, literal, sites) {
+    const slot = lookSlotNoun(builder, position);
+    const accepts = slotAccepts(lookSlotType(declared, position));
+    if (slot === undefined || accepts === null)
+        return false;
+    const written = `${Number(literal.toPrecision(12))}`;
+    const origin = lookSlotOrigin(argument, sites);
+    const spellings = accepts === "a Length" ? `${written}px`
+        : accepts === "a Percentage" ? `${written}%` : `${written}px or ${written}%`;
+    // `tracks` is the one length builder whose name ends in an s, and "tracks's"
+    // is not how the possessive is written.
+    const lesson = `${builder}${builder.endsWith("s") ? "'" : "'s"} ${slot} is ${accepts},`
+        + ` and ${heldNumber(origin, written, accepts.endsWith("or 0") ? "none of those" : "a number")}; write ${spellings}`;
+    if (accepts === "a Length" && teachSlotRefusal(diagnostics, argument, "Length", (item) => ({
+        ...item,
+        span: origin.span,
+        message: lesson,
+        ...(argument.kind === "LiteralExpression" && typeof argument.value === "number"
+            ? { fix: mechanicalFix(argument.span, `${written}px`, `Write ${written}px`) }
+            : {}),
+    })))
+        return true;
+    // The refused type is the slot's own, so a slot that takes only a percentage
+    // finds its refusal too rather than falling through and reporting twice.
+    if (accepts !== "a Length" && teachSlotRefusal(diagnostics, argument, accepts === "a Percentage" ? "Percentage" : "LengthPercentage", (item) => ({
+        ...item,
+        span: origin.span,
+        message: lesson,
+    })))
+        return true;
+    // A slot whose union takes a bare number takes `0`, and CSS writes that one
+    // length without a unit; every other number in it is the dead declaration
+    // this report exists for.
+    if (literal === 0 && accepts.endsWith("or 0"))
+        return false;
+    diagnostics.push({ code: "VEL5042", message: lesson, span: origin.span });
+    return true;
+}
+/**
+ * The published type of the slot an argument lands in: the declared parameter
+ * at that position, or — past the last of those — the rest parameter's type,
+ * which is the type of every position it collects.
+ */
+function lookSlotType(declared, position) {
+    if (position < 0 || declared.kind !== "function")
+        return undefined;
+    return declared.parameters[position] ?? declared.rest;
+}
+/**
+ * How the lesson refers to the slot an argument lands in, or undefined where
+ * the builder has no slot there at all.
+ *
+ * D114 WB-X1: a rest parameter collects every position from its own onward, and
+ * the signature has a name for only the first of them — so `tracks(8px, 4)`
+ * used to read past the end of the name table and teach nothing, while
+ * `tracks(4, 8px)` was refused. The collected positions are named by their
+ * number rather than by the rest parameter's name, because "tracks' first
+ * argument" pointing at the second argument would be a sentence that is not
+ * true. The named positions keep the wording F9-web gave them exactly.
+ */
+function lookSlotNoun(builder, position) {
+    if (position < 0)
+        return undefined;
+    const signature = LOOK_BUILDER_SIGNATURES.get(builder);
+    if (signature === undefined)
+        return undefined;
+    const named = signature.parameters[position];
+    if (named !== undefined)
+        return `${named} argument`;
+    return signature.rest === true ? `argument ${position + 1}` : undefined;
+}
+/**
+ * What a slot's published type accepts, in the words the lesson names it with,
+ * or null where the slot carries no length at all. The "or 0" tail is the one
+ * fact a reader has to be able to trust in both directions, so it is read from
+ * the type rather than written into a sentence by hand.
+ */
+function slotAccepts(type) {
+    if (type === undefined)
+        return null;
+    if (type.kind === "named") {
+        if (!lengthPercentageNames.has(type.name))
+            return null;
+        return type.name === "Length" ? "a Length" : type.name === "Percentage" ? "a Percentage" : "a Length or a Percentage";
+    }
+    if (type.kind !== "union")
+        return null;
+    if (!type.members.some((member) => member.kind === "named" && lengthPercentageNames.has(member.name)))
+        return null;
+    return type.members.some((member) => member.kind === "number") ? "a Length, a Percentage, or 0" : "a Length or a Percentage";
+}
+/**
+ * The search both slot lessons make: core's assignability refusal for exactly
+ * this argument, rewritten in place. Diagnostics are collected in source order,
+ * so the scan walks back from the end and stops as soon as it is behind the
+ * argument. The refused type is named so that a slot's own lesson cannot land
+ * on some other refusal that happens to share the span.
+ */
+function teachSlotRefusal(diagnostics, argument, refused, rewrite) {
+    for (let index = diagnostics.length - 1; index >= 0; index -= 1) {
+        const item = diagnostics[index];
+        if (item.span.start < argument.span.start)
+            break;
+        if (item.code !== "VEL4001" || item.span.start !== argument.span.start || item.span.end !== argument.span.end)
+            continue;
+        if (!item.message.includes(refused))
+            continue;
+        diagnostics[index] = rewrite(item);
+        return true;
+    }
+    return false;
+}
 //# sourceMappingURL=look-values.js.map

package/dist/analysis/look-values.js.map

@@ -1 +1 @@
-{"version":3,"file":"look-values.js","sourceRoot":"","sources":["../../src/analysis/look-values.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAmC,MAAM,iCAAiC,CAAC;AAClF,OAAO,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAE9E,MAAM,oBAAoB,GAAc,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;AACpF,MAAM,qBAAqB,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,YAAY,EAAE,kBAAkB,CAAC,CAAC,CAAC;AAEpF,MAAM,UAAU,iBAAiB,CAAC,IAAe;IAC/C,OAAO,IAAI,CAAC,IAAI,KAAK,OAAO,IAAI,uBAAuB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACzE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAe,EAAE,KAAgB,EAAE,YAAqB;IACvF,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACvE,IAAI,YAAY;QAAE,OAAO,IAAI,CAAC;IAC9B,OAAO,IAAI,CAAC,IAAI,KAAK,OAAO,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;WACjD,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,qBAAqB,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;QAChF,CAAC,CAAC,oBAAoB;QACtB,CAAC,CAAC,IAAI,CAAC;AACX,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CACpC,UAA2D,EAC3D,SAA+C,EAC/C,SAA8C,EAC9C,IAA6D;IAE7D,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,KAAK,sBAAsB;QAAE,OAAO,IAAI,CAAC;IACnE,MAAM,OAAO,GAAG,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAClD,MAAM,SAAS,GAAG,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,uBAAuB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC3F,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,mBAAmB;QAAE,OAAO,IAAI,CAAC;IACxE,IAAI,UAAU,CAAC,SAAS,CAAC,MAAM,KAAK,SAAS,CAAC,UAAU,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IAC7E,IAAI,MAAM,GAAqB,IAAI,CAAC;IACpC,KAAK,MAAM,QAAQ,IAAI,UAAU,CAAC,SAAS,EAAE,CAAC;QAC5C,MAAM,IAAI,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;QACjC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QAC1C,MAAM,GAAG,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACrD,IAAI,MAAM,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC;IACnC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}
+{"version":3,"file":"look-values.js","sourceRoot":"","sources":["../../src/analysis/look-values.ts"],"names":[],"mappings":"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"}

package/dist/analysis/reactive-names.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The reactive names of one module: which names read reactively without being a
+ * `state` themselves, which names *are* `state`, and what each `computed` is
+ * computed from.
+ *
+ * D115 §三: three questions about one module's declarations, asked by the Look
+ * freezing check and by the watch-ring refusals. They are one reading of the
+ * program body, so they are one module rather than three walks in the middle of
+ * the Web analyzer.
+ */
+import { type Program } from "@velarscript/compiler/extension";
+/** The function spelling of a derived value; `computed` the declaration is what it becomes. */
+export declare function isRetiredAccessorName(name: string): boolean;
+/**
+ * Every name in a module or component body whose read is reactive but whose
+ * binding is not itself a state/prop reference: a computed accessor, a resource
+ * handle, an action handle. A Look literal that reads one of these freezes it
+ * exactly as it freezes a state read (LOK-D1).
+ *
+ * The retired `computed(...)` accessor stays in the callee test even though it
+ * is not a global any more (D71 replaced it with the declaration): analysis
+ * after a migration diagnostic still has to stay coherent, so the name a
+ * retired declaration binds is treated as derived exactly as it was before.
+ */
+export declare function collectDerivedReactiveNames(program: Program): ReadonlySet<string>;
+/**
+ * D114 P6 item 6 (ST-U2): one same-module `computed` and the state it is
+ * computed *from*, so `watch doubled:` writing `count` is refused where the
+ * runtime's per-task observer budget used to stop it after 50,000 rounds.
+ *
+ * The hop is exactly one, and it is proved rather than guessed:
+ *
+ *  - **Same module.** A cross-module `computed` is a name this program cannot
+ *    read the body of, so it is not in this map and nothing is reported.
+ *  - **One hop.** Only the names the computed's own initializer reads are
+ *    sources. A computed that reads another computed contributes that other
+ *    computed's name, not the state underneath it, so a two-hop chain fails
+ *    the comparison and stays with the runtime budget.
+ *  - **Unconditional.** A read inside a ternary branch, on the right of `and`,
+ *    `or` or `??`, or inside a function body is a read this evaluation may not
+ *    make, so it is not a proved cycle. The condition of a ternary and the left
+ *    operand of a short-circuit are always evaluated and are read.
+ *
+ * A name declared twice answers null, for `collectReactiveWriters`'s reason: a
+ * refusal that has to be right every time cannot pick one of two bodies.
+ */
+export declare function collectReactiveDerivations(program: Program): ReadonlyMap<string, ReadonlySet<string> | null>;
+/** Every `state name = ...` of one module: true where it is declared exactly once. */
+export declare function collectReactiveStateNames(program: Program): ReadonlyMap<string, boolean>;
+//# sourceMappingURL=reactive-names.d.ts.map

package/dist/analysis/reactive-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive-names.d.ts","sourceRoot":"","sources":["../../src/analysis/reactive-names.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAmB,KAAK,OAAO,EAAkB,MAAM,iCAAiC,CAAC;AAGhG,+FAA+F;AAC/F,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAiBjF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAoB5G;AAED,sFAAsF;AACtF,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAoBxF"}

package/dist/analysis/reactive-names.js

@@ -0,0 +1,199 @@
+/**
+ * The reactive names of one module: which names read reactively without being a
+ * `state` themselves, which names *are* `state`, and what each `computed` is
+ * computed from.
+ *
+ * D115 §三: three questions about one module's declarations, asked by the Look
+ * freezing check and by the watch-ring refusals. They are one reading of the
+ * program body, so they are one module rather than three walks in the middle of
+ * the Web analyzer.
+ */
+import {} from "@velarscript/compiler/extension";
+import { isWebStatement } from "../ast.js";
+/** The function spelling of a derived value; `computed` the declaration is what it becomes. */
+export function isRetiredAccessorName(name) {
+    return name === "computed";
+}
+/**
+ * Every name in a module or component body whose read is reactive but whose
+ * binding is not itself a state/prop reference: a computed accessor, a resource
+ * handle, an action handle. A Look literal that reads one of these freezes it
+ * exactly as it freezes a state read (LOK-D1).
+ *
+ * The retired `computed(...)` accessor stays in the callee test even though it
+ * is not a global any more (D71 replaced it with the declaration): analysis
+ * after a migration diagnostic still has to stay coherent, so the name a
+ * retired declaration binds is treated as derived exactly as it was before.
+ */
+export function collectDerivedReactiveNames(program) {
+    const names = new Set();
+    const record = (statements) => {
+        for (const statement of statements) {
+            if (statement.kind === "VariableDeclaration" && statement.pattern.kind === "NameBindingPattern"
+                && statement.initializer.kind === "CallExpression" && statement.initializer.callee.kind === "IdentifierExpression"
+                && isRetiredAccessorName(statement.initializer.callee.name)) {
+                names.add(statement.pattern.name);
+                continue;
+            }
+            if (!isWebStatement(statement))
+                continue;
+            if (statement.kind === "ExtensionStatement:web:resource" || statement.kind === "ExtensionStatement:web:action")
+                names.add(statement.name);
+            if (statement.kind === "ExtensionStatement:web:component")
+                record(statement.body);
+        }
+    };
+    record(program.body);
+    return names;
+}
+/**
+ * D114 P6 item 6 (ST-U2): one same-module `computed` and the state it is
+ * computed *from*, so `watch doubled:` writing `count` is refused where the
+ * runtime's per-task observer budget used to stop it after 50,000 rounds.
+ *
+ * The hop is exactly one, and it is proved rather than guessed:
+ *
+ *  - **Same module.** A cross-module `computed` is a name this program cannot
+ *    read the body of, so it is not in this map and nothing is reported.
+ *  - **One hop.** Only the names the computed's own initializer reads are
+ *    sources. A computed that reads another computed contributes that other
+ *    computed's name, not the state underneath it, so a two-hop chain fails
+ *    the comparison and stays with the runtime budget.
+ *  - **Unconditional.** A read inside a ternary branch, on the right of `and`,
+ *    `or` or `??`, or inside a function body is a read this evaluation may not
+ *    make, so it is not a proved cycle. The condition of a ternary and the left
+ *    operand of a short-circuit are always evaluated and are read.
+ *
+ * A name declared twice answers null, for `collectReactiveWriters`'s reason: a
+ * refusal that has to be right every time cannot pick one of two bodies.
+ */
+export function collectReactiveDerivations(program) {
+    const derivations = new Map();
+    const record = (statements) => {
+        for (const statement of statements) {
+            if (statement.kind === "FunctionDeclaration") {
+                record(statement.body);
+                continue;
+            }
+            if (!isWebStatement(statement))
+                continue;
+            if (statement.kind === "ExtensionStatement:web:computed") {
+                derivations.set(statement.name, derivations.has(statement.name) ? null : unconditionalReads(statement.initializer));
+                continue;
+            }
+            if (statement.kind === "ExtensionStatement:web:component" || statement.kind === "ExtensionStatement:web:action") {
+                record(statement.body);
+            }
+        }
+    };
+    record(program.body);
+    return derivations;
+}
+/** Every `state name = ...` of one module: true where it is declared exactly once. */
+export function collectReactiveStateNames(program) {
+    const states = new Map();
+    const record = (statements) => {
+        for (const statement of statements) {
+            if (statement.kind === "FunctionDeclaration") {
+                record(statement.body);
+                continue;
+            }
+            if (!isWebStatement(statement))
+                continue;
+            if (statement.kind === "ExtensionStatement:web:state") {
+                states.set(statement.name, !states.has(statement.name));
+                continue;
+            }
+            if (statement.kind === "ExtensionStatement:web:component" || statement.kind === "ExtensionStatement:web:action") {
+                record(statement.body);
+            }
+        }
+    };
+    record(program.body);
+    return states;
+}
+/**
+ * The names an expression reads on every evaluation. A branch a value may not
+ * take, and a function body this expression only *builds*, are excluded: the
+ * refusal this feeds must be right every time, and "reads it sometimes" is the
+ * runtime budget's case rather than a provable ring.
+ *
+ * The walk is written out rather than reflected over the node's own fields,
+ * because "which of my children does every evaluation reach" is a question only
+ * each shape can answer -- a ternary's branches and an arrow's body are fields
+ * like any other, and a structural walk would read them as reads. A shape this
+ * switch does not name contributes nothing, which is the safe direction: a
+ * missing source is a refusal not made, and a surplus one is a refusal made
+ * wrongly.
+ */
+function unconditionalReads(expression) {
+    const names = new Set();
+    const walk = (node) => {
+        switch (node.kind) {
+            case "IdentifierExpression":
+                names.add(node.name);
+                return;
+            case "FStringExpression":
+                for (const part of node.parts)
+                    if (part.kind === "expression")
+                        walk(part.value);
+                return;
+            case "ListExpression":
+                for (const element of node.elements)
+                    walk(element);
+                return;
+            case "ObjectExpression":
+                for (const entry of node.properties)
+                    walk(entry.value);
+                return;
+            case "SpreadExpression":
+            case "RequiredExpression":
+            case "TryExpression":
+            case "IsExpression":
+                walk(node.value);
+                return;
+            case "UnaryExpression":
+                walk(node.operand);
+                return;
+            case "ComparisonChainExpression":
+                for (const operand of node.operands)
+                    walk(operand);
+                return;
+            case "BinaryExpression":
+                // The left operand of `and`, `or` and `??` is always evaluated; the
+                // right one is exactly what those operators may skip.
+                walk(node.left);
+                if (node.operator !== "and" && node.operator !== "or" && node.operator !== "??")
+                    walk(node.right);
+                return;
+            case "ConditionalExpression":
+                // The condition decides; the branches are the conditional reads the
+                // ruling leaves to the runtime budget.
+                walk(node.condition);
+                return;
+            case "CallExpression":
+                // An optional call evaluates its arguments only when the callee is
+                // there, so those reads are conditional like a branch's.
+                walk(node.callee);
+                if (!node.optional)
+                    for (const argument of node.arguments)
+                        walk(argument);
+                return;
+            case "MemberExpression":
+                walk(node.object);
+                return;
+            case "IndexExpression":
+                walk(node.object);
+                if (!node.optional)
+                    walk(node.index);
+                return;
+            default:
+                // A literal, an arrow function's body, an extension expression: nothing
+                // this analysis can prove is read on every evaluation.
+                return;
+        }
+    };
+    walk(expression);
+    return names;
+}
+//# sourceMappingURL=reactive-names.js.map

package/dist/analysis/reactive-names.js.map

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

package/dist/analysis/watch-cycles.d.ts

@@ -173,4 +173,32 @@ export declare function finallySelfWrite(subject: Expression, place: ReactivePat
     readonly message: string;
     readonly span: Span;
 } | null;
+/**
+ * D114 P6 item 6 (ST-U2): the VEL5077 message a plain body statement earns for
+ * writing the state that the watched `computed` is computed from, or null.
+ *
+ * The charter's exclusion -- "a write of a different state leaves the watch
+ * untouched" -- read this shape as untouched, and it is not: `doubled` is
+ * `count`, one hop away, so a write of `count` at the top of the body
+ * invalidates `doubled` and re-triggers the watch. The runtime saw it only as a
+ * task that ran out of observer budget after 50,000 rounds, with no line to
+ * point at.
+ *
+ * Every limit the ruling names is a condition here rather than a caveat in a
+ * comment: the subject is a plain name this module declares as `computed`
+ * exactly once (a cross-module source is not in `derivations`), the write's root
+ * is a name this module declares as `state` exactly once, and that state is one
+ * the computed reads on every evaluation and directly -- a second `computed` in
+ * between contributes its own name, not the state under it, so a two-hop chain
+ * is not this refusal's.
+ *
+ * Shadowing is closed from both sides, because a name is not a binding. The
+ * module-wide roster answers "declared once", so a component that declares its
+ * own `state` of the same name makes the question unanswerable and nothing is
+ * reported; `writesState` answers "the write here really is a write of reactive
+ * state", resolved lexically, so an ordinary `let` of that spelling in front of
+ * the watch is not one. Only a write that passes both is the one the computed
+ * read.
+ */
+export declare function watchDerivedSourceWrite(subject: Expression, statement: Statement, derivations: ReadonlyMap<string, ReadonlySet<string> | null>, states: ReadonlyMap<string, boolean>, writesState: (name: string) => boolean): string | null;
 //# sourceMappingURL=watch-cycles.d.ts.map