@velarscript/web 0.31.0 → 0.32.0

package/dist/analysis/look/tokens.d.ts

@@ -0,0 +1,75 @@
+/**
+ * D103 — the design-token reference: what `token()` has to be at the site that
+ * writes it, and the migration off the `color("var(--x)")` passthrough that
+ * used to be the only spelling a Look value let through unchecked.
+ *
+ * D115 P4 R3b. The compiler cannot see a design system's values, so the
+ * reference itself is the whole of what there is to check; every rule here is
+ * about the written name.
+ */
+import { type DiagnosticEdit } from "@velarscript/compiler";
+import { type Expression } from "@velarscript/compiler/extension";
+import { type LookValueSite } from "../look-sites.ts";
+import { type LookAnalysisHost } from "./host.ts";
+/**
+ * D103 rules 1 and 5 — what a checked token reference has to be at the site
+ * that writes it.
+ *
+ * The compiler cannot see a design system's values: no token stylesheet is an
+ * input to this compile, and the whole point of the contract is that the
+ * theme swaps values under the same names. So the reference itself is the
+ * only thing there is to check, and it is checked completely — a literal
+ * name, spelled as a CSS custom property identifier, and nothing else in the
+ * call. A computed name would leave a Look value with no checked part at all,
+ * which is the surface D50 rule 92 says is worse than none.
+ */
+export declare function checkLookTokenCall(host: LookAnalysisHost, expression: Extract<Expression, {
+    kind: "CallExpression";
+}>): void;
+/**
+ * D103 rule 4 — the migration off the one passthrough that used to work.
+ *
+ * The rewrite carries the `token` import when the module does not already
+ * have one, because a fix that leaves a module naming an unimported builder
+ * is not mechanical. A `var(--x, fallback)` reference has no rewrite: rule 5
+ * closed the contract against per-site fallbacks, so the message says that
+ * rather than offering a migration that would silently drop the fallback.
+ */
+export declare function reportLookColorVarReference(host: LookAnalysisHost, expression: Extract<Expression, {
+    kind: "CallExpression";
+}>, argument: Expression): void;
+/** The one edit that gives this module a `token` import, in the shape D103's migration needs. */
+export declare function lookTokenImportEdit(host: LookAnalysisHost): DiagnosticEdit;
+/** Whether this value is written as a call to the module's `token` builder, alias included. */
+export declare function isLookTokenCall(host: LookAnalysisHost, value: Expression): boolean;
+/** How this module spells a call to the token builder, honouring an aliased import. */
+export declare function lookTokenCallText(host: LookAnalysisHost, referenced: string): {
+    readonly call: string;
+    readonly imported: boolean;
+};
+/**
+ * The edits that replace one written Look value with the checked token call,
+ * in the spelling of the site that wrote it.
+ *
+ * A `look:property="text"` directive is analyzed through a synthetic literal
+ * standing for the whole attribute, so the rewrite replaces the attribute:
+ * splicing a call between an attribute's quotes is not JSX, and a fix that
+ * produces a parse error is not a mechanical fix. The `look:property={...}`
+ * spelling carries a real expression whose span is the value alone, and is
+ * rewritten in place like a block entry.
+ */
+export declare function lookTokenRewrite(host: LookAnalysisHost, value: Expression, referenced: string, site: LookValueSite): readonly DiagnosticEdit[];
+/**
+ * D103 rule 4, free-text half — an advisory rather than a refusal.
+ *
+ * `fontFamily`, `backdropFilter` and the other free-text kinds accept
+ * arbitrary CSS text by construction, and a `var()` inside a larger value is
+ * a legitimate spelling with no single token to rewrite it to: the tail of a
+ * font stack, one layer of a filter list. Refusing there would refuse real
+ * CSS. What is advised is the narrow case where the *whole* value is one
+ * reference, because there `token("--name")` is the checked spelling of the
+ * same thing and the rewrite is unambiguous — which is the bar the `A`
+ * roster is written to.
+ */
+export declare function adviseLookTokenSpelling(host: LookAnalysisHost, name: string, value: Expression, site: LookValueSite): void;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/analysis/look/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../src/analysis/look/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,KAAK,cAAc,EAAkC,MAAM,uBAAuB,CAAC;AAC5F,OAAO,EAAE,KAAK,UAAU,EAAgB,MAAM,iCAAiC,CAAC;AAEhF,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGtD,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAElD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,GAAG,IAAI,CA8C5H;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,EAC3D,QAAQ,EAAE,UAAU,GACnB,IAAI,CAoBN;AAED,iGAAiG;AACjG,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,GAAG,cAAc,CAE1E;AAED,+FAA+F;AAC/F,wBAAgB,eAAe,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAGlF;AAED,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAGnI;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,SAAS,cAAc,EAAE,CAS9I;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAa1H"}

package/dist/analysis/look/tokens.js

@@ -0,0 +1,151 @@
+/**
+ * D103 — the design-token reference: what `token()` has to be at the site that
+ * writes it, and the migration off the `color("var(--x)")` passthrough that
+ * used to be the only spelling a Look value let through unchecked.
+ *
+ * D115 P4 R3b. The compiler cannot see a design system's values, so the
+ * reference itself is the whole of what there is to check; every rule here is
+ * about the written name.
+ */
+import { mechanicalEdits, mechanicalFix } from "@velarscript/compiler";
+import { spanIdentity } from "@velarscript/compiler/extension";
+import { isLookTokenName, isLookVarReference, LOOK_PROPERTY_VALUE_KINDS, LOOK_TOKEN_NAME_RULE, LOOK_TOKEN_NO_FALLBACK_GUIDANCE, lookTokenReference, lookVarReferenceName } from "../../look.js";
+import {} from "../look-sites.js";
+import { diagnostic } from "../web-types.js";
+import { lookBuilderImportEdit } from "./edits.js";
+import {} from "./host.js";
+/**
+ * D103 rules 1 and 5 — what a checked token reference has to be at the site
+ * that writes it.
+ *
+ * The compiler cannot see a design system's values: no token stylesheet is an
+ * input to this compile, and the whole point of the contract is that the
+ * theme swaps values under the same names. So the reference itself is the
+ * only thing there is to check, and it is checked completely — a literal
+ * name, spelled as a CSS custom property identifier, and nothing else in the
+ * call. A computed name would leave a Look value with no checked part at all,
+ * which is the surface D50 rule 92 says is worse than none.
+ */
+export function checkLookTokenCall(host, expression) {
+    const names = expression.argumentNames;
+    // `token(name="--x")` writes the same one argument the positional spelling
+    // does, so the name position is read from the signature the way every other
+    // builder's is rather than assumed to be index 0.
+    const position = names?.findIndex((entry) => entry === "name") ?? -1;
+    const nameIndex = position >= 0 ? position : names?.[0] === undefined || names[0] === null ? 0 : -1;
+    for (const [index, argument] of expression.arguments.entries()) {
+        if (index === nameIndex)
+            continue;
+        host.diagnostics.push(diagnostic("VEL5042", LOOK_TOKEN_NO_FALLBACK_GUIDANCE, argument.span));
+    }
+    const written = nameIndex >= 0 ? expression.arguments[nameIndex] : undefined;
+    if (!written)
+        return;
+    if (written.kind !== "LiteralExpression" || typeof written.value !== "string") {
+        host.diagnostics.push(diagnostic("VEL5042", `A design token reference names its custom property in the call: ${LOOK_TOKEN_NAME_RULE}. The compiler cannot see a design system's values, so the name is the whole of what it can check — a computed name, an interpolation, or a binding would leave the reference unchecked`, written.span));
+        return;
+    }
+    if (isLookTokenName(written.value)) {
+        // D103 rule 2: the reference is compile-time text, so it is folded here
+        // rather than left as a call the browser makes on every module load. The
+        // fold is stamped only on a call this check has just proved, which is
+        // what keeps the emitter structurally unable to write a name nothing
+        // validated. An aliased builder (`const t = token`) is not resolved here
+        // and keeps the runtime implementation, exactly as every other builder
+        // passed around as a value does.
+        if (expression.arguments.length === 1) {
+            host.extensionLiterals.set(spanIdentity(expression.span), lookTokenReference(written.value));
+        }
+        return;
+    }
+    // A name written without the `--` that makes it a custom property is the
+    // one near miss with a single spelling behind it, so it is migrated rather
+    // than only refused.
+    const prefixed = `--${written.value}`;
+    host.diagnostics.push(diagnostic("VEL5042", `Design token name '${written.value}' is not a CSS custom property identifier; ${LOOK_TOKEN_NAME_RULE}`, written.span, isLookTokenName(prefixed)
+        ? mechanicalFix(written.span, JSON.stringify(prefixed), `Use "${prefixed}"`)
+        : undefined));
+}
+/**
+ * D103 rule 4 — the migration off the one passthrough that used to work.
+ *
+ * The rewrite carries the `token` import when the module does not already
+ * have one, because a fix that leaves a module naming an unimported builder
+ * is not mechanical. A `var(--x, fallback)` reference has no rewrite: rule 5
+ * closed the contract against per-site fallbacks, so the message says that
+ * rather than offering a migration that would silently drop the fallback.
+ */
+export function reportLookColorVarReference(host, expression, argument) {
+    if (argument.kind !== "LiteralExpression" || typeof argument.value !== "string")
+        return;
+    if (!isLookVarReference(argument.value))
+        return;
+    const referenced = lookVarReferenceName(argument.value);
+    if (referenced === null) {
+        host.diagnostics.push(diagnostic("VEL5042", `A design token reference is written token("--name"), and it carries no fallback: ${LOOK_TOKEN_NO_FALLBACK_GUIDANCE}`, argument.span));
+        return;
+    }
+    const { call, imported } = lookTokenCallText(host, referenced);
+    const rewrite = { span: expression.span, text: call };
+    host.diagnostics.push(diagnostic("VEL5042", `Write a design token reference as ${call}; color("var(...)") passed the reference through as text nothing checked, and token() is the one checked spelling — legal in every Look property, not only the colour ones`, expression.span, mechanicalEdits(imported ? [rewrite] : [lookTokenImportEdit(host), rewrite], `Use ${call}`)));
+}
+/** The one edit that gives this module a `token` import, in the shape D103's migration needs. */
+export function lookTokenImportEdit(host) {
+    return lookBuilderImportEdit(host, ["token"]);
+}
+/** Whether this value is written as a call to the module's `token` builder, alias included. */
+export function isLookTokenCall(host, value) {
+    return value.kind === "CallExpression" && value.callee.kind === "IdentifierExpression"
+        && host.lookBuilderNames.get(value.callee.name) === "token";
+}
+/** How this module spells a call to the token builder, honouring an aliased import. */
+export function lookTokenCallText(host, referenced) {
+    const local = [...host.lookBuilderNames].find(([, builder]) => builder === "token")?.[0] ?? null;
+    return { call: `${local ?? "token"}(${JSON.stringify(referenced)})`, imported: local !== null };
+}
+/**
+ * The edits that replace one written Look value with the checked token call,
+ * in the spelling of the site that wrote it.
+ *
+ * A `look:property="text"` directive is analyzed through a synthetic literal
+ * standing for the whole attribute, so the rewrite replaces the attribute:
+ * splicing a call between an attribute's quotes is not JSX, and a fix that
+ * produces a parse error is not a mechanical fix. The `look:property={...}`
+ * spelling carries a real expression whose span is the value alone, and is
+ * rewritten in place like a block entry.
+ */
+export function lookTokenRewrite(host, value, referenced, site) {
+    const { call, imported } = lookTokenCallText(host, referenced);
+    const wholeAttribute = site.directive !== null
+        && value.span.start === site.entrySpan.start && value.span.end === site.entrySpan.end;
+    const edit = {
+        span: value.span,
+        text: wholeAttribute ? `${site.directive}:${site.property}={${call}}` : call,
+    };
+    return imported ? [edit] : [lookTokenImportEdit(host), edit];
+}
+/**
+ * D103 rule 4, free-text half — an advisory rather than a refusal.
+ *
+ * `fontFamily`, `backdropFilter` and the other free-text kinds accept
+ * arbitrary CSS text by construction, and a `var()` inside a larger value is
+ * a legitimate spelling with no single token to rewrite it to: the tail of a
+ * font stack, one layer of a filter list. Refusing there would refuse real
+ * CSS. What is advised is the narrow case where the *whole* value is one
+ * reference, because there `token("--name")` is the checked spelling of the
+ * same thing and the rewrite is unambiguous — which is the bar the `A`
+ * roster is written to.
+ */
+export function adviseLookTokenSpelling(host, name, value, site) {
+    const kind = LOOK_PROPERTY_VALUE_KINDS.get(name);
+    if (kind !== "text" && kind !== "filter" && kind !== "transform")
+        return;
+    if (value.kind !== "LiteralExpression" || typeof value.value !== "string")
+        return;
+    const referenced = lookVarReferenceName(value.value);
+    if (referenced === null)
+        return;
+    const { call } = lookTokenCallText(host, referenced);
+    host.advise("A12", `Look property '${name}' accepts free text, so this design token reference compiles — as text nothing checks. ${call} is the checked spelling of the same reference, and it is legal in every Look property. A var() inside a larger value, such as a font stack's fallback, has no single token to stand for it and is not advised`, value.span, mechanicalEdits(lookTokenRewrite(host, value, referenced, site), `Use ${call}`));
+}
+//# sourceMappingURL=tokens.js.map

package/dist/analysis/look/tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.js","sourceRoot":"","sources":["../../../src/analysis/look/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAuB,eAAe,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC5F,OAAO,EAAmB,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,+BAA+B,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAChM,OAAO,EAAsB,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAyB,MAAM,WAAW,CAAC;AAElD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAsB,EAAE,UAA2D;IACpH,MAAM,KAAK,GAAG,UAAU,CAAC,aAAa,CAAC;IACvC,2EAA2E;IAC3E,4EAA4E;IAC5E,kDAAkD;IAClD,MAAM,QAAQ,GAAG,KAAK,EAAE,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IACrE,MAAM,SAAS,GAAG,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,SAAS,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpG,KAAK,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,UAAU,CAAC,SAAS,CAAC,OAAO,EAAE,EAAE,CAAC;QAC/D,IAAI,KAAK,KAAK,SAAS;YAAE,SAAS;QAClC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,+BAA+B,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/F,CAAC;IACD,MAAM,OAAO,GAAG,SAAS,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7E,IAAI,CAAC,OAAO;QAAE,OAAO;IACrB,IAAI,OAAO,CAAC,IAAI,KAAK,mBAAmB,IAAI,OAAO,OAAO,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9E,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAC9B,SAAS,EACT,mEAAmE,oBAAoB,yLAAyL,EAChR,OAAO,CAAC,IAAI,CACb,CAAC,CAAC;QACH,OAAO;IACT,CAAC;IACD,IAAI,eAAe,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACnC,wEAAwE;QACxE,yEAAyE;QACzE,sEAAsE;QACtE,qEAAqE;QACrE,yEAAyE;QACzE,uEAAuE;QACvE,iCAAiC;QACjC,IAAI,UAAU,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;QAC/F,CAAC;QACD,OAAO;IACT,CAAC;IACD,yEAAyE;IACzE,2EAA2E;IAC3E,qBAAqB;IACrB,MAAM,QAAQ,GAAG,KAAK,OAAO,CAAC,KAAK,EAAE,CAAC;IACtC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAC9B,SAAS,EACT,sBAAsB,OAAO,CAAC,KAAK,8CAA8C,oBAAoB,EAAE,EACvG,OAAO,CAAC,IAAI,EACZ,eAAe,CAAC,QAAQ,CAAC;QACvB,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,QAAQ,QAAQ,GAAG,CAAC;QAC5E,CAAC,CAAC,SAAS,CACd,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,2BAA2B,CACzC,IAAsB,EACtB,UAA2D,EAC3D,QAAoB;IAEpB,IAAI,QAAQ,CAAC,IAAI,KAAK,mBAAmB,IAAI,OAAO,QAAQ,CAAC,KAAK,KAAK,QAAQ;QAAE,OAAO;IACxF,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO;IAChD,MAAM,UAAU,GAAG,oBAAoB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACxD,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;QACxB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAC9B,SAAS,EACT,oFAAoF,+BAA+B,EAAE,EACrH,QAAQ,CAAC,IAAI,CACd,CAAC,CAAC;QACH,OAAO;IACT,CAAC;IACD,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAC/D,MAAM,OAAO,GAAmB,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACtE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAC9B,SAAS,EACT,qCAAqC,IAAI,4KAA4K,EACrN,UAAU,CAAC,IAAI,EACf,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,IAAI,EAAE,CAAC,CAC5F,CAAC,CAAC;AACL,CAAC;AAED,iGAAiG;AACjG,MAAM,UAAU,mBAAmB,CAAC,IAAsB;IACxD,OAAO,qBAAqB,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;AAChD,CAAC;AAED,+FAA+F;AAC/F,MAAM,UAAU,eAAe,CAAC,IAAsB,EAAE,KAAiB;IACvE,OAAO,KAAK,CAAC,IAAI,KAAK,gBAAgB,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,sBAAsB;WACjF,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC;AAChE,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,iBAAiB,CAAC,IAAsB,EAAE,UAAkB;IAC1E,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,KAAK,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;IACjG,OAAO,EAAE,IAAI,EAAE,GAAG,KAAK,IAAI,OAAO,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,EAAE,CAAC;AAClG,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAsB,EAAE,KAAiB,EAAE,UAAkB,EAAE,IAAmB;IACjH,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAC/D,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,KAAK,IAAI;WACzC,KAAK,CAAC,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC;IACxF,MAAM,IAAI,GAAmB;QAC3B,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,SAAU,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI;KAC9E,CAAC;IACF,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAsB,EAAE,IAAY,EAAE,KAAiB,EAAE,IAAmB;IAClH,MAAM,IAAI,GAAG,yBAAyB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACjD,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,WAAW;QAAE,OAAO;IACzE,IAAI,KAAK,CAAC,IAAI,KAAK,mBAAmB,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ;QAAE,OAAO;IAClF,MAAM,UAAU,GAAG,oBAAoB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACrD,IAAI,UAAU,KAAK,IAAI;QAAE,OAAO;IAChC,MAAM,EAAE,IAAI,EAAE,GAAG,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IACrD,IAAI,CAAC,MAAM,CACT,KAAK,EACL,kBAAkB,IAAI,0FAA0F,IAAI,gNAAgN,EACpU,KAAK,CAAC,IAAI,EACV,eAAe,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,OAAO,IAAI,EAAE,CAAC,CAChF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,45 @@
+/**
+ * What a Look property's value is allowed to be: the string vocabulary each
+ * property publishes, the compile-time fold that answers for a `const`
+ * keyword, the unit a bare number is missing, and the filter spelling that has
+ * a builder behind it.
+ *
+ * D115 P4 R3b. `entries.ts` asks these questions of every entry it walks and
+ * `builders.ts` routes the transition builder's property argument through the
+ * same vocabulary, so one property has one answer wherever it is written.
+ */
+import { type Span } from "@velarscript/compiler";
+import { type Expression, type ValueType } from "@velarscript/compiler/extension";
+import { type LookValueSite } from "../look-sites.ts";
+import { type LookAnalysisHost } from "./host.ts";
+/**
+ * `subject` names the position in the message. It is the property itself
+ * everywhere except the `transition(...)` builder, whose first argument takes
+ * `transitionProperty`'s vocabulary but is not written as that property — a
+ * refusal that named the longhand there would name a spelling the author
+ * never wrote.
+ */
+export declare function validateLookStringVocabulary(host: LookAnalysisHost, name: string, value: Expression, subject?: string, site?: LookValueSite): boolean;
+/**
+ * D65 rule 168 closed the closed sets against misspelled literals, and D65
+ * item 3 makes a `const` string a first-class design token — so the two have
+ * to agree. A name or a record field that folds to a bare CSS keyword is
+ * checked exactly as the literal spelling of it is; anything that folds to
+ * composed CSS text (a builder result, a unit, a gradient) is not a keyword
+ * and is left to the type and to the builder's own checks.
+ */
+export declare function foldedLookKeyword(host: LookAnalysisHost, value: Expression): readonly string[] | null;
+/**
+ * LOK-D3: a bare number on a length property reaches CSS as a declaration the
+ * browser discards. The union already rejects it; this diagnostic replaces the
+ * union dump with the unit the author meant to write.
+ */
+export declare function reportLookNumberWithoutUnit(host: LookAnalysisHost, name: string, actual: ValueType, expected: ValueType, valueSpan: Span): boolean;
+/**
+ * A complete CSS filter function whose arguments fit the checked Look
+ * builders has one equivalent source spelling. The parser deliberately
+ * stops at the first function or argument grammar it cannot prove, leaving
+ * arbitrary CSS and externally defined filter functions as ordinary text.
+ */
+export declare function adviseLookFilterSpelling(host: LookAnalysisHost, name: string, value: Expression, site: LookValueSite): void;
+//# sourceMappingURL=values.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../../src/analysis/look/values.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAmB,KAAK,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAGlF,OAAO,EAAE,KAAK,aAAa,EAAwB,MAAM,kBAAkB,CAAC;AAI5E,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAGlD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,SAA4B,EAAE,IAAI,CAAC,EAAE,aAAa,GAAG,OAAO,CA8ExK;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,UAAU,GAAG,SAAS,MAAM,EAAE,GAAG,IAAI,CAKrG;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,GAAG,OAAO,CASlJ;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAe3H"}

package/dist/analysis/look/values.js

@@ -0,0 +1,148 @@
+/**
+ * What a Look property's value is allowed to be: the string vocabulary each
+ * property publishes, the compile-time fold that answers for a `const`
+ * keyword, the unit a bare number is missing, and the filter spelling that has
+ * a builder behind it.
+ *
+ * D115 P4 R3b. `entries.ts` asks these questions of every entry it walks and
+ * `builders.ts` routes the transition builder's property argument through the
+ * same vocabulary, so one property has one answer wherever it is written.
+ */
+import { mechanicalEdits } from "@velarscript/compiler";
+import {} from "@velarscript/compiler/extension";
+import { evaluateLookStaticExpression } from "../../look-static.js";
+import { LOOK_PARTIAL_KEYWORD_PROPERTIES, LOOK_PROPERTY_KEYWORDS, LOOK_PROPERTY_VALUE_KINDS, LOOK_SHARED_METRIC_KEYWORDS, LOOK_UNITLESS_PROPERTIES, lookOwnKeywords, lookVarReferenceName } from "../../look.js";
+import { mentionsLookUnitType } from "../look-sites.js";
+import { literalStringValues, lookColorKeywords, lookCssWideKeywords, lookFilterRewrite, lookMetricKeywords, lookVocabularyGuidance, lookVocabularyLead } from "../look-vocabulary-guidance.js";
+import { diagnostic } from "../web-types.js";
+import { localizeLookBuilderCall, lookBuilderRewrite } from "./edits.js";
+import {} from "./host.js";
+import { lookTokenCallText, lookTokenRewrite } from "./tokens.js";
+/**
+ * `subject` names the position in the message. It is the property itself
+ * everywhere except the `transition(...)` builder, whose first argument takes
+ * `transitionProperty`'s vocabulary but is not written as that property — a
+ * refusal that named the longhand there would name a spelling the author
+ * never wrote.
+ */
+export function validateLookStringVocabulary(host, name, value, subject = `Look property '${name}'`, site) {
+    const kind = LOOK_PROPERTY_VALUE_KINDS.get(name);
+    if (!kind || kind === "text" || kind === "filter" || kind === "transform" || kind === "animation")
+        return true;
+    const values = literalStringValues(value) ?? foldedLookKeyword(host, value);
+    if (values === null)
+        return true;
+    for (const text of values) {
+        const normalized = text.trim();
+        // D103 rule 4: this is the refusal the shell wave met — every metric,
+        // shadow and transition property turned a design token reference away and
+        // named `import css unsafe` as the only way out, which is how a product's
+        // whole visual layer ended up outside Look. The reference is still
+        // refused as free text, because free text is what it was; what changed is
+        // that the refusal now names the checked spelling of the same reference
+        // and rewrites to it.
+        const referenced = site && lookVarReferenceName(normalized);
+        if (referenced) {
+            const { call } = lookTokenCallText(host, referenced);
+            host.diagnostics.push(diagnostic("VEL5038", `${subject} does not accept the text '${normalized}'; write the design token reference as ${call}, which is checked and legal in every Look property`, value.span, mechanicalEdits(lookTokenRewrite(host, value, referenced, site), `Use ${call}`)));
+            return false;
+        }
+        if (kind === "metric" && /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:px|rem|em|vw|vh|vmin|vmax|%|fr|ms|s|deg|turn)$/u.test(normalized)) {
+            host.diagnostics.push(diagnostic("VEL5038", `Use the unit literal ${normalized}; quoted unit values are not part of Look`, value.span));
+            return false;
+        }
+        let accepted;
+        // A metric property is a unit value plus a keyword half: its own CSS
+        // keywords when it has a table -- `backgroundSize` takes lengths *and*
+        // cover and contain, the `<position>` properties take the placement words
+        // (D60 rule 150, D67 rule 172) -- and the shared sizing words when it has
+        // none. The two are alternatives rather than a union, for the reason D65
+        // rule 168 gave for the keyword kind: a shared list added on top of a
+        // real table decides values for a property it has never heard of, so
+        // `objectPosition = "min-content"` would compile and reach the browser as
+        // a declaration it discards.
+        const metricKeywords = LOOK_PROPERTY_KEYWORDS.get(name);
+        if (kind === "metric")
+            accepted = metricKeywords === undefined ? lookMetricKeywords.has(normalized) : metricKeywords.has(normalized);
+        else if (kind === "color" || kind === "background")
+            accepted = lookColorKeywords.has(normalized) || /^#[0-9a-f]{3,8}$/iu.test(normalized);
+        else if (kind === "image")
+            accepted = lookCssWideKeywords.has(normalized) || normalized === "none";
+        // D73 rule 187: every kind that decides a string keyword reads the
+        // property's own closed set, and look.ts refuses to load if one is
+        // missing. The 46-word shared list this replaces both admitted values the
+        // property never had and made the refusal describe a table that did not
+        // exist.
+        else
+            accepted = LOOK_PROPERTY_KEYWORDS.get(name)?.has(normalized) === true;
+        if (!accepted) {
+            // D67 rule 174, widened by D73 rule 187: every refusal now names the
+            // property's own values, because every one of these kinds has them. The
+            // lead says what the non-keyword half of the property is, so a reader
+            // who wanted a length, an angle or a builder is not sent looking through
+            // a keyword list for it.
+            const expected = kind === "metric"
+                ? lookVocabularyGuidance(name, normalized, metricKeywords === undefined ? LOOK_SHARED_METRIC_KEYWORDS : lookOwnKeywords(name), "write a unit value such as 16px, 1rem or 50%, or one of")
+                : kind === "color" || kind === "background"
+                    ? { text: "use a checked color() or color keyword", named: false }
+                    : kind === "image"
+                        ? { text: "use a checked image builder such as linearGradient() or asset()", named: false }
+                        : lookVocabularyGuidance(name, normalized, lookOwnKeywords(name), lookVocabularyLead(kind));
+            // D65 rule 169: a property whose CSS value space no set can hold says
+            // what it left out, so the boundary is legible where it is met.
+            const partial = expected.named ? undefined : LOOK_PARTIAL_KEYWORD_PROPERTIES.get(name);
+            host.diagnostics.push(diagnostic("VEL5038", `${subject} does not accept '${normalized}'; ${expected.text}${partial
+                ? `. ${partial}; use a module-level 'import css unsafe "./styles.css" before look' when that boundary is intentional`
+                : ""}`, value.span));
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * D65 rule 168 closed the closed sets against misspelled literals, and D65
+ * item 3 makes a `const` string a first-class design token — so the two have
+ * to agree. A name or a record field that folds to a bare CSS keyword is
+ * checked exactly as the literal spelling of it is; anything that folds to
+ * composed CSS text (a builder result, a unit, a gradient) is not a keyword
+ * and is left to the type and to the builder's own checks.
+ */
+export function foldedLookKeyword(host, value) {
+    if (value.kind !== "IdentifierExpression" && value.kind !== "MemberExpression")
+        return null;
+    const folded = evaluateLookStaticExpression(value, host.lookStatic.values);
+    if (folded?.kind !== "css" || !/^[A-Za-z][A-Za-z0-9-]*$/u.test(folded.value))
+        return null;
+    return [folded.value];
+}
+/**
+ * LOK-D3: a bare number on a length property reaches CSS as a declaration the
+ * browser discards. The union already rejects it; this diagnostic replaces the
+ * union dump with the unit the author meant to write.
+ */
+export function reportLookNumberWithoutUnit(host, name, actual, expected, valueSpan) {
+    if (host.expandAliases(actual).kind !== "number" || LOOK_UNITLESS_PROPERTIES.has(name))
+        return false;
+    if (!mentionsLookUnitType(expected))
+        return false;
+    host.diagnostics.push(diagnostic("VEL5038", `Look property '${name}' is a CSS length and requires a unit; write a unit value such as 16px, 1rem, or 50%`, valueSpan));
+    return true;
+}
+/**
+ * A complete CSS filter function whose arguments fit the checked Look
+ * builders has one equivalent source spelling. The parser deliberately
+ * stops at the first function or argument grammar it cannot prove, leaving
+ * arbitrary CSS and externally defined filter functions as ordinary text.
+ */
+export function adviseLookFilterSpelling(host, name, value, site) {
+    if (LOOK_PROPERTY_VALUE_KINDS.get(name) !== "filter")
+        return;
+    if (value.kind !== "LiteralExpression" || typeof value.value !== "string")
+        return;
+    const rewrite = lookFilterRewrite(value.value);
+    if (!rewrite)
+        return;
+    const localized = localizeLookBuilderCall(host, rewrite);
+    host.advise("A16", `Look property '${name}' accepts CSS filter text, but this complete filter list has the checked equivalent ${localized.call}`, value.span, mechanicalEdits(lookBuilderRewrite(host, value, localized.call, site, localized.missingImports), `Use ${localized.call}`));
+}
+//# sourceMappingURL=values.js.map

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

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

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

@@ -0,0 +1,47 @@
+/**
+ * A Look condition as the emitter will key it: the lowered atom each term
+ * becomes, the scope key a whole condition folds to, and what a module's Look
+ * declarations contribute to a property once every branch is read.
+ *
+ * D115 P4 R3a: the duplicate-property scope and the cascade both ask this, and
+ * neither asks it of the analyzer's state, so it is written once here.
+ */
+import { type Expression, type Program } from "@velarscript/compiler/extension";
+import { type WebLookExpression } from "../ast.ts";
+import { type LookStaticValue } from "../look-static.ts";
+/**
+ * VEL5045: the selector/runtime terms one Look condition may expand to. A
+ * conjunction multiplies its two sides, so nesting is what the cap is against.
+ * Both readings of a condition stop there — the terms folded below, and the
+ * count `look-sites.ts` takes — so neither can run away on a written nesting.
+ */
+export declare const LOOK_CONDITION_TERM_LIMIT = 32;
+/**
+ * One Look condition as the set of alternatives it lowers to, each alternative
+ * being the sorted atoms that must hold together. Two conditions share a
+ * duplicate-detection scope exactly when this rendering matches, so a condition
+ * written the other way round, negated into its complement, or spelled with its
+ * operands swapped lands in the scope its rule will actually occupy.
+ */
+export declare function lookConditionKey(expression: Expression, negated: boolean, staticValues: ReadonlyMap<string, LookStaticValue>): string;
+/**
+ * Every `const name = look:` in the module, wherever it is written. A name
+ * declared twice maps to null: two different Look literals under one name make
+ * the composition question unanswerable, so the check that reads this map
+ * declines rather than guessing which one an element received.
+ */
+export declare function collectLookDeclarations(program: Program): ReadonlyMap<string, WebLookExpression | null>;
+/**
+ * The properties one Look sets, each keyed by the target it sets them on so a
+ * `@before:` colour and an element colour stay two different decisions. The
+ * condition is deliberately not part of the key: two looks that set one
+ * property under conditions that can both hold are exactly the ambiguity this
+ * serves. A `...spread` of another look is followed, and the names followed are
+ * reported back, because composing is what makes two looks ordered rather than
+ * independent.
+ */
+export declare function lookContributions(look: WebLookExpression, looks: ReadonlyMap<string, WebLookExpression | null>, visited?: ReadonlySet<string>): {
+    readonly properties: ReadonlySet<string>;
+    readonly composed: ReadonlySet<string>;
+};
+//# sourceMappingURL=look-conditions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"look-conditions.d.ts","sourceRoot":"","sources":["../../src/analysis/look-conditions.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,OAAO,EAAkB,MAAM,iCAAiC,CAAC;AAChG,OAAO,EAA8B,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC/E,OAAO,EAA+C,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAItG;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAwC5C;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,GACjD,MAAM,CAGR;AA4BD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC,CAmBvG;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC,EACpD,OAAO,GAAE,WAAW,CAAC,MAAM,CAAa,GACvC;IAAE,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAAE,CAsBtF"}