@rettangoli/check 0.0.1

package/src/reporters/sarif.js

@@ -0,0 +1,213 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import {
+  DIAGNOSTIC_CATALOG_VERSION,
+  getDiagnosticCatalogEntry,
+} from "../diagnostics/catalog.js";
+
+const toPosixPath = (value = "") => String(value).replaceAll(path.sep, "/");
+
+const mapLevel = (severity = "error") => (severity === "warn" ? "warning" : "error");
+
+const compareDiagnostics = (left = {}, right = {}) => {
+  const leftLine = Number.isInteger(left.line) ? left.line : 0;
+  const rightLine = Number.isInteger(right.line) ? right.line : 0;
+  const leftColumn = Number.isInteger(left.column) ? left.column : 0;
+  const rightColumn = Number.isInteger(right.column) ? right.column : 0;
+
+  return (
+    String(left.code || "").localeCompare(String(right.code || ""))
+    || mapLevel(left.severity).localeCompare(mapLevel(right.severity))
+    || String(left.filePath || "").localeCompare(String(right.filePath || ""))
+    || leftLine - rightLine
+    || leftColumn - rightColumn
+    || String(left.message || "").localeCompare(String(right.message || ""))
+  );
+};
+
+const normalizeDiagnostics = (diagnostics = []) => {
+  return [...(Array.isArray(diagnostics) ? diagnostics : [])].sort(compareDiagnostics);
+};
+
+const toRuleMap = (diagnostics = []) => {
+  const codes = [...new Set(
+    normalizeDiagnostics(diagnostics)
+      .map((diagnostic) => String(diagnostic?.code || "RTGL-CHECK-UNKNOWN")),
+  )];
+
+  return codes.map((code) => {
+    const catalog = getDiagnosticCatalogEntry(code);
+    return {
+      id: code,
+      shortDescription: {
+        text: catalog.title,
+      },
+      fullDescription: {
+        text: catalog.description,
+      },
+      helpUri: catalog.docsPath,
+      defaultConfiguration: {
+        level: mapLevel(catalog.defaultSeverity),
+      },
+      properties: {
+        category: catalog.family,
+        namespaceValid: catalog.namespaceValid,
+        tags: Array.isArray(catalog.tags) ? catalog.tags : [],
+      },
+    };
+  });
+};
+
+const toSarifPhysicalLocation = ({ cwd, location = {} }) => {
+  const relPath = location.filePath && location.filePath !== "unknown"
+    ? toPosixPath(path.relative(cwd, location.filePath))
+    : "unknown";
+
+  const region = {};
+  if (Number.isInteger(location.line) && location.line > 0) {
+    region.startLine = location.line;
+  }
+  if (Number.isInteger(location.column) && location.column > 0) {
+    region.startColumn = location.column;
+  }
+  if (Number.isInteger(location.endLine) && location.endLine > 0) {
+    region.endLine = location.endLine;
+  }
+  if (Number.isInteger(location.endColumn) && location.endColumn > 0) {
+    region.endColumn = location.endColumn;
+  }
+
+  return {
+    artifactLocation: {
+      uri: relPath || "unknown",
+    },
+    ...(Object.keys(region).length > 0 ? { region } : {}),
+  };
+};
+
+const toRelatedLocations = ({ cwd, diagnostic = {} }) => {
+  const related = Array.isArray(diagnostic.related) ? diagnostic.related : [];
+  return related
+    .filter((location) => location && typeof location === "object")
+    .map((location, index) => ({
+      id: index + 1,
+      message: {
+        text: location.message || "related location",
+      },
+      physicalLocation: toSarifPhysicalLocation({ cwd, location }),
+    }));
+};
+
+const toCodeFlows = (diagnostic = {}) => {
+  const trace = Array.isArray(diagnostic.trace)
+    ? diagnostic.trace
+      .map((entry) => String(entry || "").trim())
+      .filter(Boolean)
+    : [];
+  if (trace.length === 0) {
+    return undefined;
+  }
+
+  return [
+    {
+      threadFlows: [
+        {
+          locations: trace.map((entry) => ({
+            location: {
+              message: {
+                text: entry,
+              },
+            },
+          })),
+        },
+      ],
+    },
+  ];
+};
+
+const toPartialFingerprints = (diagnostic = {}) => {
+  const source = [
+    String(diagnostic.code || "RTGL-CHECK-UNKNOWN"),
+    mapLevel(diagnostic.severity),
+    String(diagnostic.filePath || "unknown"),
+    Number.isInteger(diagnostic.line) ? diagnostic.line : 0,
+    Number.isInteger(diagnostic.column) ? diagnostic.column : 0,
+    String(diagnostic.message || ""),
+  ].join("|");
+
+  return {
+    primaryLocationLineHash: createHash("sha1").update(source).digest("hex"),
+  };
+};
+
+const toSarifResult = ({ cwd, diagnostic = {} }) => {
+  const code = diagnostic.code || "RTGL-CHECK-UNKNOWN";
+  const relatedLocations = toRelatedLocations({ cwd, diagnostic });
+  const codeFlows = toCodeFlows(diagnostic);
+  const catalog = getDiagnosticCatalogEntry(code);
+
+  return {
+    ruleId: code,
+    level: mapLevel(diagnostic.severity),
+    message: {
+      text: diagnostic.message || code,
+    },
+    locations: [
+      {
+        physicalLocation: toSarifPhysicalLocation({
+          cwd,
+          location: diagnostic,
+        }),
+      },
+    ],
+    partialFingerprints: toPartialFingerprints(diagnostic),
+    ...(relatedLocations.length > 0 ? { relatedLocations } : {}),
+    ...(codeFlows ? { codeFlows } : {}),
+    properties: {
+      category: catalog.family,
+      docsPath: catalog.docsPath,
+      ...(diagnostic.fix ? {
+        autofix: {
+          kind: diagnostic.fix.kind,
+          safe: diagnostic.fix.safe !== false,
+          confidence: diagnostic.fix.confidence,
+          description: diagnostic.fix.description,
+        },
+      } : {}),
+    },
+  };
+};
+
+export const formatSarifReport = ({ result }) => {
+  const diagnostics = normalizeDiagnostics(result.diagnostics);
+  const rules = toRuleMap(diagnostics);
+  const sarif = {
+    $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "@rettangoli/check",
+            informationUri: "https://github.com/yuusoft-org/rettangoli",
+            rules,
+          },
+        },
+        automationDetails: {
+          id: "rtgl-check/default",
+        },
+        results: diagnostics.map((diagnostic) => toSarifResult({
+          cwd: result.cwd,
+          diagnostic,
+        })),
+        properties: {
+          componentCount: result.componentCount,
+          registryTagCount: result.registryTagCount,
+          diagnosticCatalogVersion: DIAGNOSTIC_CATALOG_VERSION,
+        },
+      },
+    ],
+  };
+
+  return JSON.stringify(sarif, null, 2);
+};

package/src/reporters/text.js

@@ -0,0 +1,145 @@
+import path from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+
+const formatLocation = ({ cwd, filePath, line, column }) => {
+  const relPath = filePath === "unknown" ? "unknown" : path.relative(cwd, filePath);
+  if (!line) {
+    return relPath;
+  }
+  if (!column) {
+    return `${relPath}:${line}`;
+  }
+  return `${relPath}:${line}:${column}`;
+};
+
+const readFileLines = (filePath, cache = new Map()) => {
+  if (!filePath || filePath === "unknown") {
+    return null;
+  }
+  if (cache.has(filePath)) {
+    return cache.get(filePath);
+  }
+
+  if (!existsSync(filePath)) {
+    cache.set(filePath, null);
+    return null;
+  }
+
+  const lines = readFileSync(filePath, "utf8").split("\n");
+  cache.set(filePath, lines);
+  return lines;
+};
+
+const formatCodeFrame = ({ diag, fileLines }) => {
+  if (!Number.isInteger(diag.line) || !Array.isArray(fileLines)) {
+    return [];
+  }
+  const lineIndex = diag.line - 1;
+  if (lineIndex < 0 || lineIndex >= fileLines.length) {
+    return [];
+  }
+
+  const start = Math.max(0, lineIndex - 1);
+  const end = Math.min(fileLines.length - 1, lineIndex + 1);
+  const frameLines = ["  codeframe:"];
+  for (let index = start; index <= end; index += 1) {
+    const marker = index === lineIndex ? ">" : " ";
+    frameLines.push(`  ${marker} ${String(index + 1).padStart(4, " ")} | ${fileLines[index]}`);
+    if (index === lineIndex && Number.isInteger(diag.column) && diag.column > 0) {
+      frameLines.push(`       | ${" ".repeat(Math.max(0, diag.column - 1))}^`);
+    }
+  }
+
+  return frameLines;
+};
+
+export const formatTextReport = ({ result, warnAsError = false }) => {
+  const lines = [];
+  const { summary } = result;
+  const fileCache = new Map();
+
+  lines.push(`[Check] Scanned ${result.componentCount} component(s); registry tags: ${result.registryTagCount}.`);
+  lines.push(`[Check] Errors: ${summary.bySeverity.error}, Warnings: ${summary.bySeverity.warn}.`);
+
+  if (summary.byCode.length > 0) {
+    lines.push("[Check] By code:");
+    summary.byCode.forEach(({ code, count }) => {
+      lines.push(`- ${code}: ${count}`);
+    });
+  }
+
+  if (result.diagnostics.length > 0) {
+    lines.push("[Check] Diagnostics:");
+    result.diagnostics.forEach((diag) => {
+      const severity = warnAsError && diag.severity === "warn" ? "error" : diag.severity;
+      lines.push(`${diag.code} [${severity}] ${diag.message} [${formatLocation({
+        cwd: result.cwd,
+        filePath: diag.filePath,
+        line: diag.line,
+        column: diag.column,
+      })}]`);
+      if (Array.isArray(diag.trace) && diag.trace.length > 0) {
+        diag.trace.forEach((traceEntry) => {
+          lines.push(`  trace: ${traceEntry}`);
+        });
+      }
+      if (Array.isArray(diag.related) && diag.related.length > 0) {
+        diag.related.forEach((relatedLocation) => {
+          lines.push(`  related: ${relatedLocation.message || "context"} [${formatLocation({
+            cwd: result.cwd,
+            filePath: relatedLocation.filePath || "unknown",
+            line: relatedLocation.line,
+            column: relatedLocation.column,
+          })}]`);
+        });
+      }
+      if (diag.fix && diag.fix.safe !== false) {
+        const confidence = Number.isFinite(diag.fix.confidence) ? ` (${Math.round(diag.fix.confidence * 100)}%)` : "";
+        lines.push(`  fix: ${diag.fix.description || "autofix available"}${confidence}`);
+      }
+
+      const frame = formatCodeFrame({
+        diag,
+        fileLines: readFileLines(diag.filePath, fileCache),
+      });
+      if (frame.length > 0) {
+        lines.push(...frame);
+      }
+    });
+  }
+
+  if (result.diagnostics.length === 0) {
+    lines.push("[Check] No issues found.");
+  }
+
+  if (result.autofix) {
+    lines.push(
+      `[Autofix] mode=${result.autofix.mode || "off"}, candidates=${result.autofix.candidateCount}, applied=${result.autofix.appliedCount}, skipped=${result.autofix.skippedCount}, dryRun=${result.autofix.dryRun ? "yes" : "no"}, patchOutput=${result.autofix.patchOutput ? "yes" : "no"}.`,
+    );
+    if (result.autofix.patchOutput && Array.isArray(result.autofix.patches) && result.autofix.patches.length > 0) {
+      lines.push("[Autofix] Patches:");
+      result.autofix.patches.forEach((patch) => {
+        lines.push(`- ${patch.code}: ${patch.description} [${formatLocation({
+          cwd: result.cwd,
+          filePath: patch.filePath,
+          line: patch.line,
+        })}]`);
+        if (typeof patch.patch === "string" && patch.patch) {
+          patch.patch.split("\n").forEach((patchLine) => {
+            lines.push(`  ${patchLine}`);
+          });
+        }
+      });
+    } else if (result.autofix.dryRun && Array.isArray(result.autofix.patches) && result.autofix.patches.length > 0) {
+      result.autofix.patches.forEach((patch) => {
+        lines.push(`- ${patch.code}: ${patch.description} [${formatLocation({
+          cwd: result.cwd,
+          filePath: patch.filePath,
+          line: patch.line,
+        })}]`);
+      });
+    }
+  }
+
+  return lines.join("\n");
+};

package/src/rules/compatibility.js

@@ -0,0 +1,318 @@
+import { toCamelCase, toKebabCase } from "../utils/case.js";
+import { resolveExpressionPathType } from "../core/scopeGraph.js";
+import { parseNamedExportedFunctions } from "../core/exportedFunctions.js";
+import {
+  areTypesCompatible,
+  inferLiteralLatticeType,
+  inferSchemaNodePrimitiveType,
+  schemaNodeToLatticeType,
+} from "../types/lattice.js";
+
+const normalizeBindingName = (bindingName = "") => {
+  if (bindingName.startsWith(":")) return { sourceType: "prop", name: bindingName.slice(1) };
+  if (bindingName.startsWith("?")) return { sourceType: "boolean-attr", name: bindingName.slice(1) };
+  if (bindingName.startsWith(".")) return { sourceType: "legacy-prop", name: bindingName.slice(1) };
+  if (bindingName.startsWith("@")) return { sourceType: "event", name: bindingName.slice(1) };
+  return { sourceType: "attr", name: bindingName };
+};
+
+const getContractPropSchema = ({ contract, propName }) => {
+  if (!(contract?.propTypes instanceof Map) || !propName) {
+    return null;
+  }
+  const candidates = [propName, toCamelCase(propName), toKebabCase(propName)];
+  for (let index = 0; index < candidates.length; index += 1) {
+    const candidate = candidates[index];
+    if (contract.propTypes.has(candidate)) {
+      return contract.propTypes.get(candidate);
+    }
+  }
+  return null;
+};
+
+const hasPropDefaultValue = ({ contract, propName }) => {
+  const schema = getContractPropSchema({ contract, propName });
+  return Boolean(
+    schema
+    && typeof schema === "object"
+    && !Array.isArray(schema)
+    && Object.prototype.hasOwnProperty.call(schema, "default")
+  );
+};
+
+const getContractEventSchema = ({ contract, eventName }) => {
+  if (!(contract?.eventTypes instanceof Map) || !eventName) {
+    return null;
+  }
+  return contract.eventTypes.get(eventName) || null;
+};
+
+const toSchemaRequiredKeys = (schemaNode) => {
+  if (!schemaNode || typeof schemaNode !== "object" || Array.isArray(schemaNode)) {
+    return [];
+  }
+  if (!Array.isArray(schemaNode.required)) {
+    return [];
+  }
+  return [...new Set(
+    schemaNode.required
+      .filter((key) => typeof key === "string" && key.trim() === key && key.length > 0),
+  )].sort((left, right) => left.localeCompare(right));
+};
+
+const isValidSymbolName = (value = "") => /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(value);
+
+const isValidHandlerName = (value = "") => (
+  isValidSymbolName(value)
+  && value.startsWith("handle")
+);
+
+const latticeTypeToText = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (!value || typeof value !== "object") {
+    return "unknown";
+  }
+  if (value.kind === "union" && Array.isArray(value.options)) {
+    const labels = value.options.map((option) => latticeTypeToText(option));
+    return [...new Set(labels)].join(" | ");
+  }
+  return String(value.kind || "unknown");
+};
+
+const inferAttributeExpressionType = ({ model, attribute }) => {
+  if (!attribute || typeof attribute !== "object") {
+    return "unknown";
+  }
+
+  const firstExpression = Array.isArray(attribute.expressions) ? attribute.expressions[0] : null;
+  if (typeof firstExpression === "string" && firstExpression.trim()) {
+    const pathType = resolveExpressionPathType({
+      model,
+      expression: firstExpression,
+      localSchemaTypes: new Map(),
+    });
+    if (pathType?.resolved) {
+      return inferSchemaNodePrimitiveType(pathType.resolved);
+    }
+    return "unknown";
+  }
+
+  return inferLiteralLatticeType(attribute.valueText).kind;
+};
+
+export const runCompatibilityRules = ({ models = [], registry = new Map() }) => {
+  const diagnostics = [];
+
+  models.forEach((model) => {
+    const exportedHandlerFunctions = parseNamedExportedFunctions({
+      sourceText: model?.handlers?.sourceText || "",
+      filePath: model?.handlers?.filePath || model?.files?.handlers || "unknown.handlers.js",
+    });
+    const templateNodes = Array.isArray(model?.view?.templateAst?.nodes)
+      ? model.view.templateAst.nodes
+      : [];
+    const nodeByKey = new Map();
+    templateNodes.forEach((node) => {
+      nodeByKey.set(`${node?.range?.line || 0}::${node?.rawKey || ""}`, node);
+    });
+
+    model?.view?.selectorBindings?.forEach((bindingLine) => {
+      const tagName = bindingLine?.tagName;
+      if (!tagName || !tagName.includes("-")) {
+        return;
+      }
+
+      const contract = registry.get(tagName);
+      if (!contract) {
+        return;
+      }
+
+      const astNode = nodeByKey.get(`${bindingLine.line || 0}::${bindingLine.rawKey || ""}`);
+      const astAttributes = Array.isArray(astNode?.attributes) ? astNode.attributes : [];
+      const provided = new Set();
+
+      (bindingLine.bindingNames || []).forEach((bindingName) => {
+        const normalized = normalizeBindingName(String(bindingName || "").trim());
+        if (!normalized.name || normalized.sourceType === "event") {
+          return;
+        }
+        provided.add(normalized.name);
+        provided.add(toCamelCase(normalized.name));
+        provided.add(toKebabCase(normalized.name));
+      });
+
+      const missingRequired = [...(contract.requiredProps || [])].filter((requiredProp) => (
+        !provided.has(requiredProp)
+        && !provided.has(toCamelCase(requiredProp))
+        && !provided.has(toKebabCase(requiredProp))
+        && !hasPropDefaultValue({ contract, propName: requiredProp })
+      ));
+      if (missingRequired.length > 0) {
+        diagnostics.push({
+          code: "RTGL-CHECK-COMPAT-001",
+          severity: "error",
+          filePath: bindingLine.filePath || model?.view?.filePath || "unknown",
+          line: bindingLine.line,
+          message: `${model.componentKey}: missing required prop(s) [${missingRequired.join(", ")}] for '${tagName}'.`,
+        });
+      }
+
+      if (contract.events instanceof Set && contract.events.size > 0) {
+        astAttributes.forEach((attribute) => {
+          if (attribute?.sourceType !== "event" || !attribute?.name) {
+            return;
+          }
+          if (contract.events.has(attribute.name)) {
+            return;
+          }
+          diagnostics.push({
+            code: "RTGL-CHECK-COMPAT-002",
+            severity: "error",
+            filePath: bindingLine.filePath || model?.view?.filePath || "unknown",
+            line: attribute?.range?.line || bindingLine.line,
+            column: attribute?.range?.column,
+            endLine: attribute?.range?.endLine,
+            endColumn: attribute?.range?.endColumn,
+            message: `${model.componentKey}: unsupported event '${attribute.name}' on '${tagName}'.`,
+          });
+        });
+      }
+
+      astAttributes.forEach((attribute) => {
+        if (attribute?.sourceType === "event" && attribute?.name) {
+          const rawHandlerSymbol = String(attribute.valueText || "").trim();
+          if (!rawHandlerSymbol) {
+            return;
+          }
+
+          if (!isValidHandlerName(rawHandlerSymbol)) {
+            diagnostics.push({
+              code: "RTGL-CHECK-HANDLER-003",
+              severity: "error",
+              filePath: bindingLine.filePath || model?.view?.filePath || "unknown",
+              line: attribute?.range?.line || bindingLine.line,
+              column: attribute?.range?.column,
+              endLine: attribute?.range?.endLine,
+              endColumn: attribute?.range?.endColumn,
+              message: `${model.componentKey}: invalid handler '${rawHandlerSymbol}' for event '${attribute.name}' on '${tagName}'. Handler names must start with 'handle'.`,
+            });
+            return;
+          }
+
+          if (!model?.handlers?.exports?.has(rawHandlerSymbol)) {
+            diagnostics.push({
+              code: "RTGL-CHECK-COMPAT-005",
+              severity: "error",
+              filePath: bindingLine.filePath || model?.view?.filePath || "unknown",
+              line: attribute?.range?.line || bindingLine.line,
+              column: attribute?.range?.column,
+              endLine: attribute?.range?.endLine,
+              endColumn: attribute?.range?.endColumn,
+              message: `${model.componentKey}: handler '${rawHandlerSymbol}' for event '${attribute.name}' on '${tagName}' is missing in .handlers.js exports.`,
+            });
+            return;
+          }
+
+          const eventSchema = getContractEventSchema({
+            contract,
+            eventName: attribute.name,
+          });
+          const requiredPayloadKeys = toSchemaRequiredKeys(eventSchema);
+          if (requiredPayloadKeys.length === 0) {
+            return;
+          }
+
+          const handlerMeta = exportedHandlerFunctions.get(rawHandlerSymbol);
+          if (!handlerMeta) {
+            return;
+          }
+          if (handlerMeta.paramCount < 2) {
+            diagnostics.push({
+              code: "RTGL-CHECK-COMPAT-006",
+              severity: "error",
+              filePath: bindingLine.filePath || model?.view?.filePath || "unknown",
+              line: attribute?.range?.line || bindingLine.line,
+              column: attribute?.range?.column,
+              endLine: attribute?.range?.endLine,
+              endColumn: attribute?.range?.endColumn,
+              message: `${model.componentKey}: handler '${rawHandlerSymbol}' for event '${attribute.name}' on '${tagName}' must accept a payload parameter for required payload keys [${requiredPayloadKeys.join(", ")}].`,
+            });
+            return;
+          }
+
+          if (handlerMeta.secondParam?.kind !== "object") {
+            return;
+          }
+          if (handlerMeta.secondParam?.hasRest) {
+            return;
+          }
+
+          const payloadKeys = new Set(handlerMeta.secondParam.objectKeys || []);
+          const missingPayloadKeys = requiredPayloadKeys.filter((key) => !payloadKeys.has(key));
+          if (missingPayloadKeys.length === 0) {
+            return;
+          }
+
+          diagnostics.push({
+            code: "RTGL-CHECK-COMPAT-006",
+            severity: "error",
+            filePath: bindingLine.filePath || model?.view?.filePath || "unknown",
+            line: attribute?.range?.line || bindingLine.line,
+            column: attribute?.range?.column,
+            endLine: attribute?.range?.endLine,
+            endColumn: attribute?.range?.endColumn,
+            message: `${model.componentKey}: handler '${rawHandlerSymbol}' for event '${attribute.name}' on '${tagName}' does not cover required payload key(s) [${missingPayloadKeys.join(", ")}].`,
+          });
+          return;
+        }
+
+        if (attribute?.sourceType === "prop" && attribute?.name) {
+          const schema = getContractPropSchema({
+            contract,
+            propName: attribute.name,
+          });
+          const expectedType = schemaNodeToLatticeType(schema);
+          const actualType = inferAttributeExpressionType({ model, attribute });
+          if (!areTypesCompatible({ expected: expectedType, actual: actualType })) {
+            diagnostics.push({
+              code: "RTGL-CHECK-COMPAT-004",
+              severity: "error",
+              filePath: bindingLine.filePath || model?.view?.filePath || "unknown",
+              line: attribute?.range?.line || bindingLine.line,
+              column: attribute?.range?.column,
+              endLine: attribute?.range?.endLine,
+              endColumn: attribute?.range?.endColumn,
+              message: `${model.componentKey}: prop binding ':${attribute.name}' is incompatible with '${tagName}' expected type '${latticeTypeToText(expectedType)}' but resolved '${actualType}'.`,
+            });
+          }
+        }
+
+        if (attribute?.sourceType !== "boolean-attr" || !attribute?.name) {
+          return;
+        }
+        const schema = getContractPropSchema({
+          contract,
+          propName: attribute.name,
+        });
+        const schemaType = schemaNodeToLatticeType(schema);
+        if (areTypesCompatible({ expected: schemaType, actual: "boolean" })) {
+          return;
+        }
+        diagnostics.push({
+          code: "RTGL-CHECK-COMPAT-003",
+          severity: "error",
+          filePath: bindingLine.filePath || model?.view?.filePath || "unknown",
+          line: attribute?.range?.line || bindingLine.line,
+          column: attribute?.range?.column,
+          endLine: attribute?.range?.endLine,
+          endColumn: attribute?.range?.endColumn,
+          message: `${model.componentKey}: boolean binding '?${attribute.name}' is incompatible with '${tagName}' prop type '${latticeTypeToText(schemaType)}'.`,
+        });
+      });
+    });
+  });
+
+  return diagnostics;
+};

package/src/rules/constants.js

@@ -0,0 +1,22 @@
+import { isObjectRecord } from "./shared.js";
+
+export const runConstantsRules = ({ models = [] }) => {
+  const diagnostics = [];
+
+  models.forEach((model) => {
+    if (!model.constants.filePath) {
+      return;
+    }
+
+    if (!isObjectRecord(model.constants.yaml)) {
+      diagnostics.push({
+        code: "RTGL-CHECK-CONSTANTS-001",
+        severity: "error",
+        filePath: model.constants.filePath,
+        message: `${model.componentKey}: .constants.yaml must contain a YAML object at the root.`,
+      });
+    }
+  });
+
+  return diagnostics;
+};