@velarscript/web 0.31.0 → 0.33.0

package/dist/analysis/program-passes.js

@@ -0,0 +1,149 @@
+/**
+ * One Web module analyzed end to end: the tables the whole-program rules are
+ * read out of, the two refusals that are decided before the core walk starts,
+ * and the three reports that can only be written once it has ended.
+ *
+ * D115 P4 R3c. The sequence is one function because the *order* is the rule —
+ * the Look and reactive tables have to exist before any statement is walked, the
+ * two module-level refusals land at their declarations rather than at a later
+ * use, and each closing report needs the whole module's evidence. The core walk
+ * itself stays on the analyzer, which is the only thing that can reach it, and
+ * arrives here as `analyzeCore`.
+ */
+import {} from "@velarscript/compiler";
+import {} from "@velarscript/compiler/extension";
+import { BROWSER_TEST_MODULE, BROWSER_TEST_SOURCE_SUFFIX, browserTestImportGuidance } from "../browser-test.js";
+import { collectLookStaticScope } from "../look-static.js";
+import {} from "../ast.js";
+import { WEB_OWNED_TYPE_NAMES } from "../types.js";
+import { adviseKeyedListRebuilds, collectModuleFunctions } from "./keyed-rebuild.js";
+import { collectLookDeclarations } from "./look-conditions.js";
+import { collectLookBuilderNames, collectLookImportSite } from "./look-sites.js";
+import { collectPublicConfigNames } from "./public-config.js";
+import { collectDerivedReactiveNames, collectReactiveDerivations, collectReactiveStateNames } from "./reactive-names.js";
+import { reportRetiredComputedFunction } from "./reactivity/retired-accessors.js";
+import { collectReactiveWriters } from "./watch-cycles.js";
+import { diagnostic } from "./web-types.js";
+export function analyzeWebProgram(host, program, analyzeCore) {
+    host.lookStatic = collectLookStaticScope(program, host.importedLookStaticValues);
+    host.lookBuilderNames = collectLookBuilderNames(program);
+    host.publicConfigNames = collectPublicConfigNames(program);
+    host.lookImport = collectLookImportSite(program);
+    host.lookDeclarations = collectLookDeclarations(program);
+    for (const name of collectDerivedReactiveNames(program))
+        host.derivedReactiveNames.add(name);
+    reportBrowserTestImports(host, program);
+    rejectWebOwnedTypeNames(host, program);
+    host.keyedListSources.clear();
+    host.keyedListRebuilds.length = 0;
+    host.moduleFunctions = collectModuleFunctions(program);
+    host.reactiveWriters = collectReactiveWriters(program);
+    host.reactiveDerivations = collectReactiveDerivations(program);
+    host.reactiveStateNames = collectReactiveStateNames(program);
+    analyzeCore(program);
+    reportStaticJsxKeys(host);
+    reportRetiredComputedFunction(host);
+    adviseKeyedListRebuilds(host);
+    return host.diagnostics;
+}
+/**
+ * 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.
+ */
+export function reportBrowserTestImports(host, program) {
+    if ((host.webModulePath ?? "").endsWith(BROWSER_TEST_SOURCE_SUFFIX))
+        return;
+    for (const statement of program.body) {
+        if (statement.kind !== "ImportDeclaration" && statement.kind !== "ReExportDeclaration")
+            continue;
+        if (statement.source !== BROWSER_TEST_MODULE)
+            continue;
+        host.diagnostics.push(diagnostic("VEL5062", browserTestImportGuidance(), statement.sourceSpan));
+    }
+}
+/**
+ * D72 rule 186: a Web module publishes its own type names, and a user
+ * declaration of one used to be accepted at the declaration and then lose at
+ * every use — `type Event:` compiled, and `describe({kind: "charge"})` was
+ * told it could not assign to `Event`, naming a type the author had just
+ * written. D51 rule 109 already settled where that refusal belongs: at the
+ * declaration, which is the only place a rename is cheap.
+ *
+ * The names come from the extension's own published table, so adding a type
+ * to `WEB_OWNED_TYPE_NAMES` extends this protection with it. The last time
+ * this family was repaired by listing names instead of deriving them, the
+ * list drifted; D57 rule 135 is the same repair on the Core roster.
+ *
+ * Core now says the same sentence about its own built-in type names —
+ * `builtinTypeNameDeclarationMessage` in packages/compiler/src/analyzer.ts,
+ * reported as VEL3007. The rosters differ; the wording is meant to read
+ * alike, so a change to either sentence belongs in both.
+ *
+ * `Duration` is on both rosters — Core owns it as a primitive and
+ * `velar/look` republishes it — so a Web module used to report it twice. This
+ * refusal is the more specific of the two, because it names the surface the
+ * author is writing against, so it marks the name refused and Core's stays
+ * unsaid. The mark is Core's own hook, which is what lets this pass take
+ * precedence without either side learning the other's roster.
+ */
+export function rejectWebOwnedTypeNames(host, program) {
+    const reject = (name, errorSpan, noun) => {
+        if (!WEB_OWNED_TYPE_NAMES.has(name))
+            return;
+        host.markTypeNameRefused(name);
+        host.diagnostics.push(diagnostic("VEL5065", `'${name}' is a Web type name, so it cannot also name ${/^[aeiou]/iu.test(noun) ? "an" : "a"} ${noun}; every use of it in a Web module resolves to the built-in. Rename this declaration`, errorSpan));
+    };
+    for (const statement of program.body) {
+        switch (statement.kind) {
+            case "TypeDeclaration":
+            case "TypeAliasDeclaration":
+                reject(statement.name, statement.span, "type");
+                break;
+            case "ClassDeclaration":
+                reject(statement.name, statement.span, "class");
+                break;
+            case "EnumDeclaration":
+                reject(statement.name, statement.span, "enum");
+                break;
+            case "ExternModuleDeclaration":
+                for (const declaration of statement.classes)
+                    reject(declaration.name, declaration.span, "extern class");
+                break;
+            case "ImportDeclaration":
+                // A standard-module import of the name under itself *is* the built-in
+                // — `import {Color, Length} from "velar/look"` is how a module names
+                // the published types — so only a binding that would make the name
+                // mean something else is refused.
+                if (statement.source.startsWith("velar/")) {
+                    for (const specifier of statement.specifiers) {
+                        if (specifier.local !== specifier.imported)
+                            reject(specifier.local, statement.span, "import alias");
+                    }
+                    break;
+                }
+                for (const specifier of statement.specifiers) {
+                    reject(specifier.local, statement.span, specifier.local === specifier.imported ? "imported name" : "import alias");
+                }
+                break;
+            default:
+                break;
+        }
+    }
+}
+/**
+ * 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.
+ */
+export function reportStaticJsxKeys(host) {
+    for (const { element, attribute } of host.staticJsxKeys) {
+        if (host.honoredJsxKeys.has(element) || host.reportedJsxKeys.has(element))
+            continue;
+        host.diagnostics.push(diagnostic("VEL5050", `This JSX key has no effect: '<${element.tag}>' is rendered in a fixed position, and keys reuse children by identity only inside 'items.map(item => <Row key={item.id} />)' — remove the key, or render this element from a keyed .map()`, attribute.span));
+    }
+}
+//# sourceMappingURL=program-passes.js.map

package/dist/analysis/program-passes.js.map

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

package/dist/analysis/reactivity/bindings.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Which declaration a name resolves to, and what follows from the answer: the
+ * three binding-identity questions, the root a mutation lands on, and the
+ * prop-specific wording a mutation of an explicitly readonly prop earns.
+ *
+ * D115 P4 R3c. Every question here is asked of the *binding* a name resolves
+ * to, never of the spelling, which is why they all start at `lookup` — a local
+ * `state` may shadow a derived or imported name, and the shadow is ordinary
+ * writable state.
+ */
+import { type Expression, type Statement } from "@velarscript/compiler/extension";
+import { type ReactiveNamesHost } from "./host.ts";
+/**
+ * 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.
+ */
+export declare function isComputedBinding(host: ReactiveNamesHost, name: string): boolean;
+/**
+ * True when `name` resolves to a `resource` declaration. Asked of the binding
+ * rather than of the spelling, for the reason `isComputedBinding` is: a local
+ * `state` may shadow a resource's name, and the shadow is not a resource.
+ */
+export declare function isResourceBinding(host: ReactiveNamesHost, name: string): boolean;
+export declare function isImportedComputedBinding(host: ReactiveNamesHost, name: string): boolean;
+export declare function writableStateName(host: ReactiveNamesHost, name: string): boolean;
+export declare function directReadonlyPropMutation(host: ReactiveNamesHost, statement: Statement): string | null;
+export declare function rootBindingName(expression: Expression): string | null;
+/**
+ * D74: the readonly refusals the core raised while this statement was analyzed,
+ * restated so they name the prop and the author's own contract. The cursor is
+ * the diagnostic count taken before the core walked the statement, so only what
+ * this statement earned is rewritten.
+ */
+export declare function restateReadonlyPropMutation(host: ReactiveNamesHost, firstDiagnostic: number, readonlyProp: string | null): void;
+//# sourceMappingURL=bindings.d.ts.map

package/dist/analysis/reactivity/bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindings.d.ts","sourceRoot":"","sources":["../../../src/analysis/reactivity/bindings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAgB,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAChG,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAGhF;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAGhF;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAGxF;AAID,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhF;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,iBAAiB,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CAavG;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CASrE;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAU/H"}

package/dist/analysis/reactivity/bindings.js

@@ -0,0 +1,88 @@
+/**
+ * Which declaration a name resolves to, and what follows from the answer: the
+ * three binding-identity questions, the root a mutation lands on, and the
+ * prop-specific wording a mutation of an explicitly readonly prop earns.
+ *
+ * D115 P4 R3c. Every question here is asked of the *binding* a name resolves
+ * to, never of the spelling, which is why they all start at `lookup` — a local
+ * `state` may shadow a derived or imported name, and the shadow is ordinary
+ * writable state.
+ */
+import { spanIdentity } from "@velarscript/compiler/extension";
+import {} from "./host.js";
+/**
+ * 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.
+ */
+export function isComputedBinding(host, name) {
+    const binding = host.lookup(name);
+    return binding !== null && host.computedBindingSpans.has(spanIdentity(binding.span));
+}
+/**
+ * True when `name` resolves to a `resource` declaration. Asked of the binding
+ * rather than of the spelling, for the reason `isComputedBinding` is: a local
+ * `state` may shadow a resource's name, and the shadow is not a resource.
+ */
+export function isResourceBinding(host, name) {
+    const binding = host.lookup(name);
+    return binding !== null && host.resourceBindingSpans.has(spanIdentity(binding.span));
+}
+export function isImportedComputedBinding(host, name) {
+    const binding = host.lookup(name);
+    return binding !== null && host.importedComputedSpans.has(spanIdentity(binding.span));
+}
+// A name refers to writable reactive state only when ordinary lexical lookup
+// still resolves it to the state binding; a shadowing local wins instead.
+export function writableStateName(host, name) {
+    return host.reactiveBindingKind(name) === "state";
+}
+export function directReadonlyPropMutation(host, statement) {
+    let target = null;
+    if (statement.kind === "AssignmentStatement" && statement.target.kind !== "IdentifierExpression") {
+        target = statement.target;
+    }
+    else if (statement.kind === "ExpressionStatement" && statement.expression.kind === "CallExpression"
+        && statement.expression.callee.kind === "MemberExpression") {
+        target = statement.expression.callee.object;
+    }
+    if (!target)
+        return null;
+    const name = rootBindingName(target);
+    if (!name)
+        return null;
+    const binding = host.lookup(name);
+    return binding && host.explicitReadonlyPropBindings.get(name) === binding.span.start ? name : null;
+}
+export function rootBindingName(expression) {
+    if (expression.kind === "IdentifierExpression")
+        return expression.name;
+    if (expression.kind === "MemberExpression" || expression.kind === "IndexExpression") {
+        return rootBindingName(expression.object);
+    }
+    if (expression.kind === "CallExpression" && expression.callee.kind === "MemberExpression") {
+        return rootBindingName(expression.callee.object);
+    }
+    return null;
+}
+/**
+ * D74: the readonly refusals the core raised while this statement was analyzed,
+ * restated so they name the prop and the author's own contract. The cursor is
+ * the diagnostic count taken before the core walked the statement, so only what
+ * this statement earned is rewritten.
+ */
+export function restateReadonlyPropMutation(host, firstDiagnostic, readonlyProp) {
+    if (!readonlyProp)
+        return;
+    for (let index = firstDiagnostic; index < host.diagnostics.length; index += 1) {
+        const item = host.diagnostics[index];
+        if ((item.code !== "VEL3002" && item.code !== "VEL4001") || !/read-?only|readonly/iu.test(item.message))
+            continue;
+        host.diagnostics[index] = {
+            ...item,
+            message: `Cannot mutate prop '${readonlyProp}': this component's author explicitly declared it 'readonly'. ${item.message}`,
+        };
+    }
+}
+//# sourceMappingURL=bindings.js.map

package/dist/analysis/reactivity/bindings.js.map

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

package/dist/analysis/reactivity/derived.d.ts

@@ -0,0 +1,39 @@
+/**
+ * What a derived value refuses and what a derived read is: the call that should
+ * have been a bare read, the assignment that has no location to land on, and the
+ * reading that decides whether a name really resolves to a reactive derivation
+ * here.
+ *
+ * D115 P4 R3c. The three sit above `bindings.ts` because each of them starts by
+ * asking which declaration a name resolves to and then says what follows.
+ */
+import { type Expression, type Statement, type ValueType } from "@velarscript/compiler/extension";
+import { type ReactiveNamesHost } from "./host.ts";
+/**
+ * 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.
+ */
+export declare function calledComputedBinding(host: ReactiveNamesHost, expression: Extract<Expression, {
+    readonly kind: "CallExpression";
+}>): ValueType | null;
+/**
+ * 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.
+ */
+export declare function rejectComputedAssignment(host: ReactiveNamesHost, statement: Extract<Statement, {
+    readonly kind: "AssignmentStatement";
+}>): boolean;
+/**
+ * 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.
+ */
+export declare function derivedReactiveRead(host: ReactiveNamesHost, name: string): boolean;
+//# sourceMappingURL=derived.d.ts.map

package/dist/analysis/reactivity/derived.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived.d.ts","sourceRoot":"","sources":["../../../src/analysis/reactivity/derived.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAiB,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAGjH,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,iBAAiB,EACvB,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,GACnE,SAAS,GAAG,IAAI,CAmBlB;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,iBAAiB,EACvB,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAA;CAAE,CAAC,GACtE,OAAO,CAaT;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAOlF"}

package/dist/analysis/reactivity/derived.js

@@ -0,0 +1,80 @@
+/**
+ * What a derived value refuses and what a derived read is: the call that should
+ * have been a bare read, the assignment that has no location to land on, and the
+ * reading that decides whether a name really resolves to a reactive derivation
+ * here.
+ *
+ * D115 P4 R3c. The three sit above `bindings.ts` because each of them starts by
+ * asking which declaration a name resolves to and then says what follows.
+ */
+import { isInvalidType } from "@velarscript/compiler/extension";
+import { diagnostic } from "../web-types.js";
+import { isComputedBinding, isImportedComputedBinding } from "./bindings.js";
+import {} from "./host.js";
+/**
+ * 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.
+ */
+export function calledComputedBinding(host, expression) {
+    if (expression.callee.kind !== "IdentifierExpression")
+        return null;
+    const name = expression.callee.name;
+    if (!isComputedBinding(host, name))
+        return null;
+    const type = host.inferExpression(expression.callee);
+    // A derived value that *is* a function is called on purpose; only a
+    // non-callable one makes the parentheses a mistake.
+    const expanded = host.expandAliases(type);
+    if (expanded.kind === "function" || expanded.kind === "intrinsic" || expanded.kind === "any" || isInvalidType(expanded))
+        return null;
+    host.diagnostics.push({
+        code: "VEL5063",
+        message: `'${name}' is a computed value, not a reader: it is read bare like state, so write '${name}' rather than '${name}()'`,
+        span: expression.span,
+        fix: {
+            title: `Read '${name}' bare`,
+            edits: [{ span: { start: expression.callee.span.end, end: expression.span.end }, text: "" }],
+        },
+    });
+    return type;
+}
+/**
+ * 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.
+ */
+export function rejectComputedAssignment(host, statement) {
+    if (statement.target.kind !== "IdentifierExpression")
+        return false;
+    const name = statement.target.name;
+    if (!isComputedBinding(host, name))
+        return false;
+    host.diagnostics.push(diagnostic("VEL5063", isImportedComputedBinding(host, name)
+        ? `'${name}' is a computed value derived in the module it comes from, so it has no location here to assign. Export a 'state' — or an action that writes one — and change that instead`
+        : `'${name}' is a computed value: it is recomputed from what it reads and is never assigned. Assign the state it reads, or declare it 'state ${name} = ...' if this value is written directly`, statement.target.span));
+    host.inferExpression(statement.value);
+    return true;
+}
+/**
+ * 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.
+ */
+export function derivedReactiveRead(host, name) {
+    if (!host.derivedReactiveNames.has(name))
+        return false;
+    const binding = host.lookup(name);
+    if (!binding)
+        return false;
+    const type = host.expandAliases(binding.type);
+    if (type.kind === "function" || type.kind === "action")
+        return type.parameters.length === 0 && !type.rest;
+    return type.kind === "object" && (type.fields.has("reload") || type.fields.has("pending"));
+}
+//# sourceMappingURL=derived.js.map

package/dist/analysis/reactivity/derived.js.map

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

package/dist/analysis/reactivity/host.d.ts

@@ -0,0 +1,38 @@
+/**
+ * What the reactive-name rules ask of the analyzer that hosts them: the span
+ * tables that say which declaration a name resolves to, and the analyzer
+ * operations those rules perform.
+ *
+ * D115 P4 R3c. The tables are `private` on the analyzer, so the object
+ * satisfying this interface is built inside that class and nowhere else
+ * (TS2341, D114 line 512). The retired-accessor migration declares its own
+ * `RetiredAccessorHost` beside its rules, because the tables it reads are the
+ * ones it fills itself and it shares none of these.
+ */
+import { type Diagnostic, type Span } from "@velarscript/compiler";
+import { type Expression, type ValueType } from "@velarscript/compiler/extension";
+export interface ReactiveNamesHost {
+    /**
+     * 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.
+     */
+    readonly computedBindingSpans: ReadonlySet<string>;
+    /** Every name in this module whose read is reactive without the binding being a state/prop reference. */
+    readonly derivedReactiveNames: ReadonlySet<string>;
+    /** D74: only props whose authors wrote a readonly contract receive prop-specific guidance. Replaced per component. */
+    readonly explicitReadonlyPropBindings: ReadonlyMap<string, number>;
+    /** The resolved spans of imported `export computed` bindings, so a local shadow of the name is not one. */
+    readonly importedComputedSpans: ReadonlySet<string>;
+    /** D114 W: the declaration spans of every `resource` in scope, kept the way `computedBindingSpans` is. */
+    readonly resourceBindingSpans: ReadonlySet<string>;
+    readonly diagnostics: Diagnostic[];
+    expandAliases(type: ValueType): ValueType;
+    inferExpression(expression: Expression, contextualType?: ValueType): ValueType;
+    lookup(name: string): {
+        readonly span: Span;
+        readonly type: ValueType;
+    } | null;
+    reactiveBindingKind(name: string): "state" | "prop" | null;
+}
+//# sourceMappingURL=host.d.ts.map

package/dist/analysis/reactivity/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../../src/analysis/reactivity/host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAElF,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACnD,yGAAyG;IACzG,QAAQ,CAAC,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACnD,sHAAsH;IACtH,QAAQ,CAAC,4BAA4B,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnE,2GAA2G;IAC3G,QAAQ,CAAC,qBAAqB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACpD,0GAA0G;IAC1G,QAAQ,CAAC,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAEnD,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,CAAC;IACnC,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC;IAC1C,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,cAAc,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IAC/E,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;KAAE,GAAG,IAAI,CAAC;IAC/E,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC;CAC5D"}

package/dist/analysis/reactivity/host.js

@@ -0,0 +1,14 @@
+/**
+ * What the reactive-name rules ask of the analyzer that hosts them: the span
+ * tables that say which declaration a name resolves to, and the analyzer
+ * operations those rules perform.
+ *
+ * D115 P4 R3c. The tables are `private` on the analyzer, so the object
+ * satisfying this interface is built inside that class and nowhere else
+ * (TS2341, D114 line 512). The retired-accessor migration declares its own
+ * `RetiredAccessorHost` beside its rules, because the tables it reads are the
+ * ones it fills itself and it shares none of these.
+ */
+import {} from "@velarscript/compiler";
+import {} from "@velarscript/compiler/extension";
+//# sourceMappingURL=host.js.map

package/dist/analysis/reactivity/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","sourceRoot":"","sources":["../../../src/analysis/reactivity/host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAA8B,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAmC,MAAM,iCAAiC,CAAC"}

package/dist/analysis/reactivity/retired-accessors.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The retired 'computed(...)' accessor: the intrinsic a call around it is still
+ * typed by, and the shape of one declaration held for the migration message.
+ *
+ * D115 P4 R3a: a frozen table and a record shape, read by the analyzer and by
+ * the intrinsic that types the call, so they read as a module.
+ *
+ * D115 P4 R3c: the migration pass itself joins them — what one declaration
+ * records, what one read records, and the one message per site the whole-program
+ * report writes — over a `RetiredAccessorHost`.
+ */
+import { type Diagnostic, type Span } from "@velarscript/compiler";
+import { type Expression, type Statement, type ValueType } from "@velarscript/compiler/extension";
+/**
+ * `computed(...)` the function is answered with the signature it always had, so
+ * a call written around it still type-checks instead of collapsing into an
+ * unknown one — that is what keeps the one message about the declaration form
+ * the only thing the author reads. `reactive.computed` itself is gone; this one
+ * derives no reactivity and is never emitted, because every site that produces
+ * it also produces an error. It stays an intrinsic only so the reader it
+ * returns carries the callback's own result: an annotated declaration —
+ * `const one: () -> number = computed(() => 1)` — would otherwise read a
+ * second, spurious assignability error on top of it.
+ */
+/**
+ * What the D71 migration off `computed(...)` the function asks: the four tables
+ * it fills while the module is walked and reads once the walk has ended, and
+ * the lookup that tells a global accessor apart from a binding of the name.
+ */
+export interface RetiredAccessorHost {
+    /** Callee spans already claimed by a recognised `const x = computed(...)` declaration. */
+    readonly migratedComputedCallees: Set<string>;
+    /** Callee span identity -> call span, for every zero-argument call of a plain name. */
+    readonly plainCallSpans: Map<string, Span>;
+    readonly retiredAccessorDeclarations: Map<string, RetiredAccessorDeclaration>;
+    readonly retiredAccessorReads: Map<string, Span[]>;
+    readonly retiredComputedReferences: Map<string, {
+        readonly name: string;
+        readonly span: Span;
+    }>;
+    readonly diagnostics: Diagnostic[];
+    lookup(name: string): {
+        readonly span: Span;
+        readonly type: ValueType;
+    } | null;
+}
+export declare const RETIRED_ACCESSOR_INTRINSIC = "reactive.retired-accessor";
+export declare const RETIRED_ACCESSOR_TYPE: ValueType;
+export interface RetiredAccessorDeclaration {
+    readonly name: string;
+    readonly exported: boolean;
+    /** The named function the argument reads through, when it is one — `computed(readA)`. */
+    readonly readName: string | null;
+    readonly declarationSpan: Span;
+    readonly callSpan: Span;
+    /** The `() => E` body span, or null when the argument is not that shape. */
+    readonly bodySpan: Span | null;
+}
+/**
+ * D71 rule 183: `computed(...)` the function — the shape Vue and the signals
+ * libraries teach — is not how a derived value is written here; the `computed`
+ * declaration is. The declaration is recorded before the core walks the module
+ * so its reads can be matched against it — the rewrite that removes the call
+ * parentheses is only offered when every read is a plain `x()`.
+ */
+export declare function recordRetiredAccessorDeclaration(host: RetiredAccessorHost, statement: Extract<Statement, {
+    readonly kind: "VariableDeclaration";
+}>): void;
+/** Returns true when the name is one of the retired accessor globals this pass owns. */
+export declare function recordRetiredAccessorRead(host: RetiredAccessorHost, expression: Extract<Expression, {
+    readonly kind: "IdentifierExpression";
+}>): boolean;
+/**
+ * D71 migration: one message per site, and a mechanical rewrite only where
+ * the compile can prove the rewrite. Where the
+ * accessor is used as a value there is no second spelling left to offer, so
+ * that site is told to declare the value and write an ordinary `def` where a
+ * callable is what the caller wants — and it gets no edit, because moving a
+ * reader out of a value position is the author's decision.
+ */
+export declare function reportRetiredComputedFunction(host: RetiredAccessorHost): void;
+//# sourceMappingURL=retired-accessors.d.ts.map

package/dist/analysis/reactivity/retired-accessors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retired-accessors.d.ts","sourceRoot":"","sources":["../../../src/analysis/reactivity/retired-accessors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAA6B,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAI7H;;;;;;;;;;GAUG;AACH;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,0FAA0F;IAC1F,QAAQ,CAAC,uBAAuB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9C,uFAAuF;IACvF,QAAQ,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC3C,QAAQ,CAAC,2BAA2B,EAAE,GAAG,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;IAC9E,QAAQ,CAAC,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IACnD,QAAQ,CAAC,yBAAyB,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;KAAE,CAAC,CAAC;IAEhG,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,CAAC;IACnC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;KAAE,GAAG,IAAI,CAAC;CAChF;AAED,eAAO,MAAM,0BAA0B,8BAA8B,CAAC;AAEtE,eAAO,MAAM,qBAAqB,EAAE,SAOlC,CAAC;AAEH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,yFAAyF;IACzF,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,eAAe,EAAE,IAAI,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;CAChC;AAED;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,mBAAmB,EACzB,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAA;CAAE,CAAC,GACtE,IAAI,CAsBN;AAED,wFAAwF;AACxF,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,mBAAmB,EACzB,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAA;CAAE,CAAC,GACzE,OAAO,CAgBT;AAED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAgC7E"}