@velarscript/web 0.30.1 → 0.32.0

package/dist/analysis/declarations.d.ts

@@ -0,0 +1,99 @@
+/**
+ * What a Web declaration means and what analyzing one does: the types a
+ * `component` and an `action` publish, the four reactive declarations
+ * (`state`, `computed`, `resource`, `action`), the module-level `import css
+ * unsafe`, the scope prescan's answer, and the demotion an imported derived
+ * name receives.
+ *
+ * D115 P4 R3c. Every one of these is reached from the analyzer's statement
+ * seams, which stay on the root as the dispatch over statement kinds; the arms
+ * themselves live here. `analyzeComponent` calls the same four declaration
+ * analyzers from a component body, which is why they are a module both the root
+ * and `components/` can call and why the import runs one way only:
+ * `components/` reads this module, and this module never reads `components/`.
+ */
+import { type Diagnostic, type Span } from "@velarscript/compiler";
+import { type Expression, type Statement, type TypeReference, type ValueType } from "@velarscript/compiler/extension";
+import { type WebActionDeclaration as ActionDeclaration, type WebComponentDeclaration as ComponentDeclaration, type WebComputedDeclaration as ComputedDeclaration, type WebResourceDeclaration as ResourceDeclaration, type WebStateDeclaration as StateDeclaration, type WebUnsafeCssDeclaration as UnsafeCssDeclaration } from "../ast.ts";
+import { type KeyedRebuildHost } from "./keyed-rebuild.ts";
+/**
+ * What the declaration analyzers ask of the analyzer that hosts them: the four
+ * span tables a declaration records itself in, the module's unsafe-CSS and
+ * resource inputs, and the base-analyzer operations declaring a name performs.
+ *
+ * It extends `KeyedRebuildHost` because a `computed` declaration is one of the
+ * two places a keyed-list rebuild is recorded, so analyzing a declaration
+ * really does need everything that advisory needs.
+ */
+export interface DeclarationAnalysisHost extends KeyedRebuildHost {
+    /** D71 rule 182: the declaration spans of every `computed` binding in scope. */
+    readonly computedBindingSpans: Set<string>;
+    /** Local names bound to an imported `export computed`, from the Web interface. */
+    readonly importedComputedNames: ReadonlySet<string>;
+    /** The resolved spans of those imports, so a local shadow of the name is not one. */
+    readonly importedComputedSpans: Set<string>;
+    /** The project resources this compile read, which is where an external unsafe stylesheet's text comes from. */
+    readonly resources: ReadonlyMap<string, string>;
+    /** D114 W: the declaration spans of every `resource` in scope. */
+    readonly resourceBindingSpans: Set<string>;
+    /** Each external stylesheet already given an order position, which is how a second import of one is recognised. */
+    readonly unsafeCssImports: Set<string>;
+    /** How many synchronous reactive bodies enclose the expression being inferred; a `computed` initializer is one. */
+    synchronousReactiveDepth: number;
+    readonly diagnostics: Diagnostic[];
+    analyzeFunctionDeclaration(statement: ActionDeclaration, className: null, method: boolean, declareSelf: boolean, forceAsynchronous: boolean, declarationKind: string): void;
+    declareBinding(name: string, mutable: boolean, type: ValueType, declarationSpan: Span): void;
+    inferExpression(expression: Expression, contextualType?: ValueType): ValueType;
+    inferredFunctionResult(statement: ActionDeclaration): ValueType;
+    isTopLevelScope(): boolean;
+    markDeclaredBindingReactive(name: string, kind: "state" | "prop"): void;
+    requireAssignable(actual: ValueType, expected: ValueType, valueSpan: Span): void;
+    requireSettledCollectionElement(initializer: Expression, declared: ValueType, annotated: boolean): void;
+    resolveAnnotation(reference: TypeReference | null): ValueType;
+    resolveValidatedAnnotation(reference: TypeReference | null): ValueType;
+    resolvedAsyncResult(type: ValueType): ValueType;
+    validateTypeReference(reference: TypeReference): boolean;
+}
+export declare function componentType(host: DeclarationAnalysisHost, statement: ComponentDeclaration): ValueType;
+/**
+ * A `state` declaration, at module scope and in a component body alike: the two
+ * arms are the same eight lines, so they are written once here.
+ */
+export declare function analyzeStateDeclaration(host: DeclarationAnalysisHost, statement: StateDeclaration): void;
+/**
+ * D71 rule 182: a derived value is reactive and read-only, which is exactly
+ * the reactive identity a component prop already carries — a bare read lowers
+ * through `.get()`, and nothing may write it. Registering that identity
+ * rather than `state` is what keeps `bind={doubled}` and every other writable
+ * position refusing a derived name for free.
+ */
+export declare function analyzeComputedDeclaration(host: DeclarationAnalysisHost, statement: ComputedDeclaration): void;
+export declare function analyzeResourceDeclaration(host: DeclarationAnalysisHost, statement: ResourceDeclaration): void;
+export declare function actionType(host: DeclarationAnalysisHost, statement: ActionDeclaration): ValueType;
+export declare function analyzeActionDeclaration(host: DeclarationAnalysisHost, statement: ActionDeclaration): void;
+/**
+ * LOK-D2 / D53: unsafe CSS is a module-level ordering declaration, whether its
+ * source is an external resource or an inline raw block. Nested inside a
+ * component or a function it used to pass every check, build, and then appear
+ * in no output at all.
+ */
+export declare function analyzeUnsafeCssDeclaration(host: DeclarationAnalysisHost, statement: UnsafeCssDeclaration): void;
+/** The three Web declarations a scope prescan has to see, so a later shadow of one is recognised. */
+export declare function webScopeDeclaration(statement: Statement): {
+    readonly name: string;
+    readonly span: Span;
+} | null;
+/**
+ * D71 rule 184: a cross-module `computed` travels through `reactiveExports`
+ * so its bare read lowers through `.get()` like an exported `state` — but it
+ * is not writable, and the imported binding must not inherit the writable
+ * identity that carries `bind={...}` and `event => name = ...`. The Web
+ * extension publishes which exported names are derived, so the import is
+ * demoted to the read-only reactive identity here.
+ *
+ * `markCore` is the base analyzer's own registration, which only the class can
+ * reach: this rule decides which identity the name receives and then hands the
+ * decision back.
+ */
+export declare function markWebBindingReactive(host: DeclarationAnalysisHost, name: string, kind: "state" | "prop", markCore: (name: string, kind: "state" | "prop") => void): void;
+//# sourceMappingURL=declarations.d.ts.map

package/dist/analysis/declarations.d.ts.map

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

package/dist/analysis/declarations.js

@@ -0,0 +1,176 @@
+/**
+ * What a Web declaration means and what analyzing one does: the types a
+ * `component` and an `action` publish, the four reactive declarations
+ * (`state`, `computed`, `resource`, `action`), the module-level `import css
+ * unsafe`, the scope prescan's answer, and the demotion an imported derived
+ * name receives.
+ *
+ * D115 P4 R3c. Every one of these is reached from the analyzer's statement
+ * seams, which stay on the root as the dispatch over statement kinds; the arms
+ * themselves live here. `analyzeComponent` calls the same four declaration
+ * analyzers from a component body, which is why they are a module both the root
+ * and `components/` can call and why the import runs one way only:
+ * `components/` reads this module, and this module never reads `components/`.
+ */
+import {} from "@velarscript/compiler";
+import { anyType, boolType, describeType, isInvalidType, nullType, optionalOf, spanIdentity, stringType, unknownType, } from "@velarscript/compiler/extension";
+import { isWebStatement, } from "../ast.js";
+import { webComponentConstructor } from "../types.js";
+import { recordDerivedKeyedListRebuild } from "./keyed-rebuild.js";
+import { containsCssImport, firstRelativeCssAssetAddress } from "./look-sites.js";
+import { diagnostic } from "./web-types.js";
+export function componentType(host, statement) {
+    const props = new Map(statement.parameters.map((parameter) => [parameter.name, host.resolveValidatedAnnotation(parameter.type)]));
+    if (!props.has("class"))
+        props.set("class", optionalOf(stringType));
+    if (!props.has("look"))
+        props.set("look", optionalOf({ kind: "named", name: "Look" }));
+    return webComponentConstructor(statement.name, props, new Set(statement.parameters.filter((parameter) => !parameter.defaultValue).map((parameter) => parameter.name)), statement.handleType ? host.resolveValidatedAnnotation(statement.handleType) : null);
+}
+/**
+ * A `state` declaration, at module scope and in a component body alike: the two
+ * arms are the same eight lines, so they are written once here.
+ */
+export function analyzeStateDeclaration(host, statement) {
+    const annotationValid = statement.type ? host.validateTypeReference(statement.type) : true;
+    const annotationContext = statement.type ? host.resolveValidatedAnnotation(statement.type) : null;
+    const actual = host.inferExpression(statement.initializer, annotationContext ?? unknownType);
+    const declared = annotationContext ?? actual;
+    if (annotationValid)
+        host.requireAssignable(actual, declared, statement.initializer.span);
+    host.requireSettledCollectionElement(statement.initializer, declared, annotationContext !== null);
+    host.declareBinding(statement.name, true, declared, statement.span);
+    host.markDeclaredBindingReactive(statement.name, "state");
+}
+/**
+ * D71 rule 182: a derived value is reactive and read-only, which is exactly
+ * the reactive identity a component prop already carries — a bare read lowers
+ * through `.get()`, and nothing may write it. Registering that identity
+ * rather than `state` is what keeps `bind={doubled}` and every other writable
+ * position refusing a derived name for free.
+ */
+export function analyzeComputedDeclaration(host, statement) {
+    const annotationValid = statement.type ? host.validateTypeReference(statement.type) : true;
+    const annotationContext = statement.type ? host.resolveValidatedAnnotation(statement.type) : null;
+    // The initializer re-runs on every dependency change, so it is a deferred
+    // read for the module-initialization-cycle classification, exactly like a
+    // watch subject.
+    host.synchronousReactiveDepth += 1;
+    const actual = host.inferExpression(statement.initializer, annotationContext ?? unknownType);
+    host.synchronousReactiveDepth -= 1;
+    const declared = annotationContext ?? actual;
+    if (annotationValid)
+        host.requireAssignable(actual, declared, statement.initializer.span);
+    host.declareBinding(statement.name, false, declared, statement.span);
+    host.markDeclaredBindingReactive(statement.name, "prop");
+    host.computedBindingSpans.add(spanIdentity(statement.span));
+    recordDerivedKeyedListRebuild(host, statement);
+}
+export function analyzeResourceDeclaration(host, statement) {
+    const annotated = statement.type ? host.resolveAnnotation(statement.type) : null;
+    const annotationValid = statement.type ? host.validateTypeReference(statement.type) : true;
+    const annotationContext = statement.type ? host.resolveValidatedAnnotation(statement.type) : null;
+    const expected = annotationContext ? { kind: "promise", value: annotationContext } : unknownType;
+    const actual = host.inferExpression(statement.initializer, expected);
+    let value = annotationContext ?? unknownType;
+    if (actual.kind === "promise") {
+        if (annotated && annotationValid)
+            host.requireAssignable(actual.value, annotated, statement.initializer.span);
+        else if (!statement.type)
+            value = actual.value;
+    }
+    else if (actual.kind === "any") {
+        value = annotationContext ?? anyType;
+    }
+    else if (!isInvalidType(actual)) {
+        host.diagnostics.push(diagnostic("VEL4016", `A resource initializer must return Promise<T>, received ${describeType(actual)}`, statement.initializer.span));
+    }
+    const fields = new Map([
+        ["value", value.kind === "null" ? nullType : optionalOf(value)],
+        ["loading", boolType],
+        ["ready", boolType],
+        ["error", optionalOf({ kind: "class", name: "Error" })],
+        ["reload", { kind: "function", parameters: [], requiredParameters: 0, result: { kind: "promise", value: nullType } }],
+    ]);
+    host.declareBinding(statement.name, false, { kind: "object", fields }, statement.span);
+    host.resourceBindingSpans.add(spanIdentity(statement.span));
+}
+export function actionType(host, statement) {
+    const declaredResult = host.resolvedAsyncResult(host.inferredFunctionResult(statement));
+    const rest = statement.parameters.find((parameter) => parameter.rest);
+    return {
+        kind: "action",
+        parameters: statement.parameters.filter((parameter) => !parameter.rest).map((parameter) => host.resolveValidatedAnnotation(parameter.type)),
+        parameterNames: statement.parameters.filter((parameter) => !parameter.rest).map((parameter) => parameter.name),
+        requiredParameters: statement.parameters.filter((parameter) => !parameter.rest && !parameter.defaultValue).length,
+        ...(rest ? { rest: host.resolveValidatedAnnotation(rest.type) } : {}),
+        result: { kind: "promise", value: declaredResult },
+    };
+}
+export function analyzeActionDeclaration(host, statement) {
+    host.declareBinding(statement.name, false, actionType(host, statement), statement.span);
+    host.analyzeFunctionDeclaration(statement, null, true, false, true, "Action");
+}
+/**
+ * LOK-D2 / D53: unsafe CSS is a module-level ordering declaration, whether its
+ * source is an external resource or an inline raw block. Nested inside a
+ * component or a function it used to pass every check, build, and then appear
+ * in no output at all.
+ */
+export function analyzeUnsafeCssDeclaration(host, statement) {
+    if (!host.isTopLevelScope()) {
+        host.diagnostics.push(diagnostic("VEL5037", "Unsafe CSS is module-level; move the declaration to the top of the module so its order against Look stays visible", statement.span));
+        return;
+    }
+    if (statement.source.kind === "external" && host.unsafeCssImports.has(statement.source.path)) {
+        host.diagnostics.push(diagnostic("VEL5037", `Unsafe CSS '${statement.source.path}' is imported more than once; each stylesheet must have one explicit order position`, statement.span));
+    }
+    if (statement.source.kind === "external")
+        host.unsafeCssImports.add(statement.source.path);
+    const source = statement.source.kind === "inline" ? statement.source.css : host.resources.get(statement.source.path);
+    const subject = statement.source.kind === "inline" ? "Inline unsafe CSS" : `Unsafe CSS '${statement.source.path}'`;
+    if (source && containsCssImport(source)) {
+        host.diagnostics.push(diagnostic("VEL5037", `${subject} contains @import; declare every stylesheet with 'import css unsafe' so project order remains visible`, statement.source.span));
+    }
+    if (source) {
+        const relativeAddress = firstRelativeCssAssetAddress(source);
+        if (relativeAddress)
+            host.diagnostics.push(diagnostic("VEL5037", `${subject} uses relative asset address ${relativeAddress.syntax}(${JSON.stringify(relativeAddress.value)}); use a project-public /path, data URL, fragment, or absolute URL so extracted asset ownership stays explicit`, statement.source.span));
+    }
+}
+/** The three Web declarations a scope prescan has to see, so a later shadow of one is recognised. */
+export function webScopeDeclaration(statement) {
+    if (!isWebStatement(statement))
+        return null;
+    return statement.kind === "ExtensionStatement:web:state" || statement.kind === "ExtensionStatement:web:computed"
+        || statement.kind === "ExtensionStatement:web:resource"
+        ? { name: statement.name, span: statement.span }
+        : null;
+}
+/**
+ * D71 rule 184: a cross-module `computed` travels through `reactiveExports`
+ * so its bare read lowers through `.get()` like an exported `state` — but it
+ * is not writable, and the imported binding must not inherit the writable
+ * identity that carries `bind={...}` and `event => name = ...`. The Web
+ * extension publishes which exported names are derived, so the import is
+ * demoted to the read-only reactive identity here.
+ *
+ * `markCore` is the base analyzer's own registration, which only the class can
+ * reach: this rule decides which identity the name receives and then hands the
+ * decision back.
+ */
+export function markWebBindingReactive(host, name, kind, markCore) {
+    // Only the import itself is demoted. A local `state` of the same name in a
+    // component or a block is a shadow that really is writable, and demoting it
+    // would compile its assignment as a plain store into the handle.
+    const imported = kind === "state" && host.isTopLevelScope() && host.importedComputedNames.has(name);
+    markCore(name, imported ? "prop" : kind);
+    if (!imported)
+        return;
+    const binding = host.lookup(name);
+    if (!binding)
+        return;
+    host.computedBindingSpans.add(spanIdentity(binding.span));
+    host.importedComputedSpans.add(spanIdentity(binding.span));
+}
+//# sourceMappingURL=declarations.js.map

package/dist/analysis/declarations.js.map

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

package/dist/analysis/inference.d.ts

@@ -0,0 +1,67 @@
+/**
+ * What the Web extension adds to expression inference, either side of the core
+ * walk: the shapes it refuses before the core sees them, the answers it has
+ * already computed and hands back instead of walking again, the Look length a
+ * builder call folds to, and the two reports a call earns once its type is
+ * known. The extension's own call and type-syntax rules — a component element
+ * called like a function, and `Component<Props, Handle>` — are here too.
+ *
+ * D115 P4 R3c. The dispatch itself stays on the analyzer: `inferExpression` and
+ * `inferExtensionExpression` are seams the core owns, and what they hand to the
+ * JSX, keyframes and Look walks is the one thing that is genuinely a dispatch.
+ * Everything on either side of it is a rule, and rules live here.
+ */
+import { type Span } from "@velarscript/compiler";
+import { type Expression, type ExtensionValueType, type TypeReference, type TypeSyntax, type ValueType } from "@velarscript/compiler/extension";
+import { type LookAnalysisHost } from "./look/host.ts";
+import { type ReactiveNamesHost } from "./reactivity/host.ts";
+import { type RetiredAccessorHost } from "./reactivity/retired-accessors.ts";
+/** The state the inference rules own: the probe cache, and the two module inputs a call is proved against. */
+export interface ExpressionInferenceHost {
+    /** The Look-arithmetic hints this walk records for the emitter, keyed by expression span. */
+    readonly extensionCalls: Map<string, string>;
+    /**
+     * Operands probed for Look arithmetic. The core analyzer re-requests one
+     * immediately after the probe declines, so the answer is parked here and
+     * consumed once — that is what keeps operand analysis single-run and operand
+     * diagnostics unrepeated.
+     */
+    readonly probedOperandTypes: Map<string, ValueType>;
+    /** The names this module declares as public configuration, from the program's own reading. Replaced per program. */
+    readonly publicConfigNames: ReadonlySet<string>;
+    /** D114 0.29.0 LC-D1: the manifest's `web.publicConfig`, or null when this compile read no project manifest. */
+    readonly webPublicConfig: Readonly<Record<string, unknown>> | null;
+    /** The module's source, which is what a component-call refusal quotes the arguments out of. */
+    readonly webSourceText: string;
+    fieldsOf(identity: string): ReadonlyMap<string, ValueType> | null;
+    typeError(message: string, errorSpan: Span): void;
+}
+/**
+ * The one face the inference rules read. It is an intersection because the
+ * rules on either side of the core walk really do reach three other groups: a
+ * call is checked as a Look builder call, a zero-argument call of a derived
+ * name is refused, and an identifier read is recorded for the D71 migration.
+ */
+export type InferenceHost = ExpressionInferenceHost & LookAnalysisHost & ReactiveNamesHost & RetiredAccessorHost;
+/**
+ * The Web shapes refused before the core analyzer sees the expression, in the
+ * order they are asked. `undefined` means nothing here claimed the expression
+ * and the extension dispatch continues.
+ */
+export declare function webExpressionShapeRefusals(host: InferenceHost, expression: Expression): ValueType | undefined;
+/** The two Web expressions that are a value rather than a walk: a misplaced Look hook, and a unit literal. */
+export declare function webExtensionValueType(host: InferenceHost, expression: Expression): ValueType | undefined;
+/**
+ * The answers the Web extension already holds for this expression, given back
+ * instead of walking it a second time. Null means the core walk should run.
+ */
+export declare function answeredBeforeInference(host: InferenceHost, expression: Expression): ValueType | null;
+/** The compile-time Look length a builder call folds to, or null when the call is not one. */
+export declare function foldedWebLength(host: InferenceHost, expression: Expression): ValueType | null;
+/** Infers one builder slot and parks the answer in the probe cache, so the call's own analysis reads it back. */
+export declare function probedSlotType(host: InferenceHost, argument: Expression): ValueType;
+/** The two reports a call earns once the core walk has answered its type. */
+export declare function reportInferredWebCall(host: InferenceHost, expression: Expression, result: ValueType): void;
+export declare function inferWebExtensionCall(host: InferenceHost, callee: ExtensionValueType, arguments_: readonly Expression[], argumentNames: readonly (string | null)[] | undefined, callSpan: Span): ValueType | undefined;
+export declare function validateWebExtensionTypeSyntax(host: InferenceHost, syntax: TypeSyntax, validate: (syntax: TypeSyntax) => boolean, resolve: (reference: TypeReference) => ValueType): boolean | undefined;
+//# sourceMappingURL=inference.d.ts.map

package/dist/analysis/inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inference.d.ts","sourceRoot":"","sources":["../../src/analysis/inference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAOL,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,SAAS,EACf,MAAM,iCAAiC,CAAC;AAMzC,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAMvD,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAoD,KAAK,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAG/H,8GAA8G;AAC9G,MAAM,WAAW,uBAAuB;IACtC,6FAA6F;IAC7F,QAAQ,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C;;;;;OAKG;IACH,QAAQ,CAAC,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACpD,oHAAoH;IACpH,QAAQ,CAAC,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAChD,gHAAgH;IAChH,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IACnE,+FAA+F;IAC/F,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC;IAClE,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC;CACnD;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,uBAAuB,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,mBAAmB,CAAC;AAEjH;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,CAoF7G;AAED,8GAA8G;AAC9G,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,CAWxG;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,GAAG,SAAS,GAAG,IAAI,CAwBrG;AAED,8FAA8F;AAC9F,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,GAAG,SAAS,GAAG,IAAI,CAG7F;AAED,iHAAiH;AACjH,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,GAAG,SAAS,CAInF;AAED,6EAA6E;AAC7E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CAO1G;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,SAAS,UAAU,EAAE,EACjC,aAAa,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,EACrD,QAAQ,EAAE,IAAI,GACb,SAAS,GAAG,SAAS,CAKvB;AAED,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,OAAO,EACzC,OAAO,EAAE,CAAC,SAAS,EAAE,aAAa,KAAK,SAAS,GAC/C,OAAO,GAAG,SAAS,CA8CrB"}

package/dist/analysis/inference.js

@@ -0,0 +1,236 @@
+/**
+ * What the Web extension adds to expression inference, either side of the core
+ * walk: the shapes it refuses before the core sees them, the answers it has
+ * already computed and hands back instead of walking again, the Look length a
+ * builder call folds to, and the two reports a call earns once its type is
+ * known. The extension's own call and type-syntax rules — a component element
+ * called like a function, and `Component<Props, Handle>` — are here too.
+ *
+ * D115 P4 R3c. The dispatch itself stays on the analyzer: `inferExpression` and
+ * `inferExtensionExpression` are seams the core owns, and what they hand to the
+ * JSX, keyframes and Look walks is the one thing that is genuinely a dispatch.
+ * Everything on either side of it is a rule, and rules live here.
+ */
+import {} from "@velarscript/compiler";
+import { boolType, describeType, expressionContainsDirectAwait, invalidType, spanIdentity, unknownType, } from "@velarscript/compiler/extension";
+import { isWebExpression, isWebJsx, isWebUnit } from "../ast.js";
+import { LOOK_ARITHMETIC_HINT, LOOK_UNIT_TYPES } from "../look.js";
+import { isWebComponentType, isWebNodeType, webComponentName, webNodeType } from "../types.js";
+import { componentCallRefusal } from "./component-guidance.js";
+import { checkLookBuilderCall } from "./look/builders.js";
+import {} from "./look/host.js";
+import { foldedLengthPercentage, isLookNumericType } from "./look-values.js";
+import { lookJoin, lookLiteralZero } from "./look-sites.js";
+import { lookSourceOf } from "./media-conditions.js";
+import { publicConfigDiagnostic } from "./public-config.js";
+import { calledComputedBinding } from "./reactivity/derived.js";
+import {} from "./reactivity/host.js";
+import { recordRetiredAccessorRead, RETIRED_ACCESSOR_TYPE } from "./reactivity/retired-accessors.js";
+import { diagnostic, webEventDeadFields, webEventTypeNames } from "./web-types.js";
+/**
+ * The Web shapes refused before the core analyzer sees the expression, in the
+ * order they are asked. `undefined` means nothing here claimed the expression
+ * and the extension dispatch continues.
+ */
+export function webExpressionShapeRefusals(host, expression) {
+    if (expression.kind === "CallExpression" && expression.callee.kind === "IdentifierExpression"
+        && expression.callee.name === "mount") {
+        const namedNode = expression.argumentNames?.findIndex((name) => name === "node") ?? -1;
+        const node = expression.arguments[namedNode >= 0 ? namedNode : 0];
+        if (node && expressionContainsDirectAwait(node, (value) => value.kind === "ExtensionExpression:web:jsx" ? false : undefined)) {
+            host.diagnostics.push(diagnostic("VEL4007", "mount constructs its root synchronously; await the root in a separate module binding before calling mount", node.span));
+        }
+    }
+    if (expression.kind === "UnaryExpression" && (expression.operator === "+" || expression.operator === "-")) {
+        const operand = host.inferExpression(expression.operand);
+        if (isLookNumericType(operand)) {
+            host.extensionCalls.set(spanIdentity(expression.span), LOOK_ARITHMETIC_HINT);
+            return operand;
+        }
+        host.probedOperandTypes.set(spanIdentity(expression.operand.span), operand);
+    }
+    // WEB-U15 / GRM-A3: '&&' rendering is the React habit. The lexer now starts
+    // JSX after 'and'/'or' so the shape parses and this rejection names the
+    // conditional-rendering spelling instead of leaking a bool type error.
+    if (expression.kind === "BinaryExpression" && (expression.operator === "and" || expression.operator === "or")
+        && (isWebJsx(expression.left) || isWebJsx(expression.right))) {
+        const rightIsElement = isWebJsx(expression.right);
+        const tag = rightIsElement ? expression.right.tag : isWebJsx(expression.left) ? expression.left.tag : "";
+        const condition = lookSourceOf(rightIsElement ? expression.left : expression.right);
+        host.inferExpression(expression.left);
+        host.inferExpression(expression.right);
+        host.diagnostics.push(diagnostic("VEL5029", `'${expression.operator}' combines bool values and cannot yield an element; render conditionally with '{${condition} ? <${tag || ">"} ... : null}'`, expression.span));
+        return invalidType;
+    }
+    if (expression.kind === "BinaryExpression" && ["+", "-", "*", "/"].includes(expression.operator)) {
+        const left = host.inferExpression(expression.left);
+        const right = host.inferExpression(expression.right);
+        if (!isLookNumericType(left) && !isLookNumericType(right)) {
+            host.probedOperandTypes.set(spanIdentity(expression.left.span), left);
+            host.probedOperandTypes.set(spanIdentity(expression.right.span), right);
+        }
+        else {
+            const additive = expression.operator === "+" || expression.operator === "-" ? lookJoin(left, right) : null;
+            const result = additive
+                ?? ((expression.operator === "*" || expression.operator === "/") && isLookNumericType(left) && right.kind === "number" ? left : null)
+                ?? (expression.operator === "*" && left.kind === "number" && isLookNumericType(right) ? right : null);
+            if (result) {
+                // LOK-U8: dividing a visual value by a literal zero produces a
+                // non-finite length that the runtime rejects on first construction.
+                if (expression.operator === "/" && lookLiteralZero(expression.right)) {
+                    host.diagnostics.push(diagnostic("VEL5042", "Look unit arithmetic cannot divide by zero", expression.span));
+                    return invalidType;
+                }
+                host.extensionCalls.set(spanIdentity(expression.span), LOOK_ARITHMETIC_HINT);
+                return result;
+            }
+            // The rejection is final: returning the invalid type keeps the Look
+            // property's own assignment error from co-reporting a union dump on the
+            // very expression that was already named (LOK-I1).
+            host.diagnostics.push(diagnostic("VEL5042", `Look unit arithmetic cannot apply '${expression.operator}' to ${describeType(left)} and ${describeType(right)}`, expression.span));
+            return invalidType;
+        }
+    }
+    // WEB-N2 / D47 rule 84: the event object is typed down to event semantics
+    // and deliberately carries no target, so `event.target.value` is a dead end
+    // that used to cascade into three unknown-access errors. The read is where
+    // the author wanted two-way binding, so it names that spelling and stops.
+    if (expression.kind === "MemberExpression" && !expression.optional && webEventDeadFields.has(expression.property)
+        && expression.object.kind === "IdentifierExpression") {
+        const binding = host.lookup(expression.object.name);
+        const expanded = binding ? host.expandAliases(binding.type) : null;
+        if (expanded?.kind === "named" && webEventTypeNames.has(expanded.name)) {
+            host.diagnostics.push(diagnostic("VEL5019", `A VelarScript event object carries typed event fields only and has no '${expression.property}': read the element's value through a two-way binding instead — 'bind:value={name}' binds a state name, and 'bind:value={form.field}' or 'bind:value={items[0]}' binds a writable path inside state`, expression.span));
+            return invalidType;
+        }
+    }
+    return undefined;
+}
+/** The two Web expressions that are a value rather than a walk: a misplaced Look hook, and a unit literal. */
+export function webExtensionValueType(host, expression) {
+    if (isWebExpression(expression) && expression.kind === "ExtensionExpression:web:look-hook") {
+        host.diagnostics.push(diagnostic("VEL5038", `Look hook '@${expression.name}' is only valid inside a Look condition`, expression.span));
+        return boolType;
+    }
+    if (isWebUnit(expression)) {
+        const type = LOOK_UNIT_TYPES.get(expression.unit);
+        if (type)
+            return { kind: "named", name: type };
+        return unknownType;
+    }
+    return undefined;
+}
+/**
+ * The answers the Web extension already holds for this expression, given back
+ * instead of walking it a second time. Null means the core walk should run.
+ */
+export function answeredBeforeInference(host, expression) {
+    // Operands probed for Look arithmetic are re-requested by the core analyzer immediately after the
+    // probe declines; reusing the probe result (consume-once) keeps operand analysis single-run so
+    // operand diagnostics are not reported twice.
+    const key = spanIdentity(expression.span);
+    const probed = host.probedOperandTypes.get(key);
+    if (probed !== undefined) {
+        host.probedOperandTypes.delete(key);
+        return probed;
+    }
+    if (expression.kind === "CallExpression" && expression.arguments.length === 0
+        && expression.callee.kind === "IdentifierExpression") {
+        host.plainCallSpans.set(spanIdentity(expression.callee.span), expression.span);
+        const called = calledComputedBinding(host, expression);
+        if (called)
+            return called;
+    }
+    if (expression.kind === "IdentifierExpression") {
+        const retired = recordRetiredAccessorRead(host, expression);
+        // The retired name is answered here rather than left to fall through as an
+        // unknown one: the author gets its migration and nothing else, and the
+        // call around it still type-checks against the signature it always had.
+        if (retired)
+            return RETIRED_ACCESSOR_TYPE;
+    }
+    return null;
+}
+/** The compile-time Look length a builder call folds to, or null when the call is not one. */
+export function foldedWebLength(host, expression) {
+    return expression.kind !== "CallExpression" ? null
+        : foldedLengthPercentage(expression, (name) => host.lookBuilderNames.get(name), (argument) => probedSlotType(host, argument), lookJoin);
+}
+/** Infers one builder slot and parks the answer in the probe cache, so the call's own analysis reads it back. */
+export function probedSlotType(host, argument) {
+    const inferred = host.inferExpression(argument);
+    host.probedOperandTypes.set(spanIdentity(argument.span), inferred);
+    return host.expandAliases(inferred);
+}
+/** The two reports a call earns once the core walk has answered its type. */
+export function reportInferredWebCall(host, expression, result) {
+    if (expression.kind !== "CallExpression")
+        return;
+    checkLookBuilderCall(host, expression);
+    // D114 0.29.0 LC-D1: the manifest this build bakes in, proved against the declared type.
+    const report = publicConfigDiagnostic(expression, result, host.publicConfigNames, host.webPublicConfig, { expandAliases: (type) => host.expandAliases(type), fieldsOf: (identity) => host.fieldsOf(identity), describeType });
+    if (report)
+        host.diagnostics.push(report);
+}
+export function inferWebExtensionCall(host, callee, arguments_, argumentNames, callSpan) {
+    if (!isWebComponentType(callee))
+        return undefined;
+    host.typeError(componentCallRefusal(webComponentName(callee), arguments_, argumentNames, host.webSourceText), callSpan);
+    for (const argument of arguments_)
+        host.inferExpression(argument);
+    return webNodeType;
+}
+export function validateWebExtensionTypeSyntax(host, syntax, validate, resolve) {
+    if (syntax.kind !== "GenericTypeSyntax" || syntax.name !== "Component")
+        return undefined;
+    let valid = true;
+    if (syntax.arguments.length < 1 || syntax.arguments.length > 2) {
+        host.typeError("Component<Props, Handle> requires a named prop signature and at most one Handle type", syntax.span);
+        valid = false;
+    }
+    const argumentsValid = syntax.arguments.map(validate).every(Boolean);
+    const signature = syntax.arguments[0];
+    if (!signature)
+        return false;
+    if (signature.kind !== "FunctionTypeSyntax") {
+        host.typeError("Component<Props, Handle> requires a named function signature such as Component<(title: string) -> WebNode, DialogHandle>", signature.span);
+        valid = false;
+    }
+    else {
+        const names = new Set();
+        for (const parameter of signature.parameters) {
+            if (!parameter.name) {
+                host.typeError("Every Component signature prop requires a name", parameter.span);
+                valid = false;
+            }
+            else if (names.has(parameter.name)) {
+                host.typeError(`Component signature prop '${parameter.name}' is declared more than once`, parameter.span);
+                valid = false;
+            }
+            else
+                names.add(parameter.name);
+            if (parameter.rest) {
+                host.typeError("Component signatures use named props and cannot declare a rest parameter", parameter.span);
+                valid = false;
+            }
+        }
+        const result = resolve({ syntax: signature.result, span: signature.result.span });
+        if (!isWebNodeType(result)) {
+            host.typeError(`A Component signature must return WebNode, received ${describeType(result)}`, signature.result.span);
+            valid = false;
+        }
+    }
+    const handleSyntax = syntax.arguments[1];
+    if (handleSyntax && argumentsValid) {
+        const handle = host.expandAliases(resolve({ syntax: handleSyntax, span: handleSyntax.span }));
+        const fields = handle.kind === "object"
+            ? handle.fields
+            : handle.kind === "named" ? host.fieldsOf(handle.identity ?? handle.name) : null;
+        if (!fields) {
+            host.typeError(`A Component Handle must be a concrete record type, received ${describeType(handle)}`, handleSyntax.span);
+            valid = false;
+        }
+    }
+    return valid && argumentsValid;
+}
+//# sourceMappingURL=inference.js.map