@safe-ugc-ui/validator 0.3.0 → 0.4.0

package/dist/index.js

@@ -260,7 +260,6 @@ function validateNodes(views) {
 }
 
 // src/value-types.ts
-import { isRef, isExpr } from "@safe-ugc-ui/types";
 var STATIC_ONLY_STYLE_PROPERTIES = /* @__PURE__ */ new Set([
   // Position / layout
   "position",
@@ -268,12 +267,16 @@ var STATIC_ONLY_STYLE_PROPERTIES = /* @__PURE__ */ new Set([
   "right",
   "bottom",
   "left",
+  // Overflow
+  "overflow",
+  // Stacking
+  "zIndex"
+]);
+var STRUCTURED_OBJECT_STYLE_PROPERTIES = /* @__PURE__ */ new Set([
   // Transform
   "transform",
   // Gradient
   "backgroundGradient",
-  // Overflow
-  "overflow",
   // Borders
   "border",
   "borderTop",
@@ -281,46 +284,8 @@ var STATIC_ONLY_STYLE_PROPERTIES = /* @__PURE__ */ new Set([
   "borderBottom",
   "borderLeft",
   // Shadow
-  "boxShadow",
-  // Stacking
-  "zIndex"
+  "boxShadow"
 ]);
-function validateNodeFields(node, ctx, errors) {
-  const nodeType = node.type;
-  if (nodeType === "Image" || nodeType === "Avatar") {
-    const src = node.src;
-    if (src !== void 0 && isExpr(src)) {
-      errors.push(
-        createError(
-          "EXPR_NOT_ALLOWED",
-          `${nodeType}.src does not allow $expr bindings.`,
-          `${ctx.path}.src`
-        )
-      );
-    }
-  }
-  if (nodeType === "Icon") {
-    const name = node.name;
-    if (name !== void 0 && isRef(name)) {
-      errors.push(
-        createError(
-          "REF_NOT_ALLOWED",
-          "Icon.name does not allow $ref bindings.",
-          `${ctx.path}.name`
-        )
-      );
-    }
-    if (name !== void 0 && isExpr(name)) {
-      errors.push(
-        createError(
-          "EXPR_NOT_ALLOWED",
-          "Icon.name does not allow $expr bindings.",
-          `${ctx.path}.name`
-        )
-      );
-    }
-  }
-}
 function validateNodeStyle(node, ctx, errors) {
   const style = node.style;
   if (!style) {
@@ -330,12 +295,21 @@ function validateNodeStyle(node, ctx, errors) {
     if (value === void 0) {
       continue;
     }
-    if (STATIC_ONLY_STYLE_PROPERTIES.has(prop)) {
-      if (isRef(value) || isExpr(value)) {
+    if (typeof value === "object" && value !== null && "$ref" in value && typeof value.$ref === "string") {
+      if (STATIC_ONLY_STYLE_PROPERTIES.has(prop)) {
         errors.push(
           createError(
             "DYNAMIC_NOT_ALLOWED",
-            `Style property "${prop}" must be a static literal; $ref and $expr are not allowed.`,
+            `Style property "${prop}" must be a static literal; $ref is not allowed.`,
+            `${ctx.path}.style.${prop}`
+          )
+        );
+      }
+      if (STRUCTURED_OBJECT_STYLE_PROPERTIES.has(prop)) {
+        errors.push(
+          createError(
+            "DYNAMIC_NOT_ALLOWED",
+            `Style property "${prop}" must be an object literal; use $ref only inside its nested fields.`,
             `${ctx.path}.style.${prop}`
           )
         );
@@ -346,7 +320,6 @@ function validateNodeStyle(node, ctx, errors) {
 function validateValueTypes(views) {
   const errors = [];
   traverseCard(views, (node, ctx) => {
-    validateNodeFields(node, ctx, errors);
     validateNodeStyle(node, ctx, errors);
   });
   return errors;
@@ -377,8 +350,7 @@ import {
   TRANSITION_DELAY_MAX,
   TRANSITION_MAX_COUNT,
   ALLOWED_TRANSITION_PROPERTIES,
-  isRef as isRef2,
-  isExpr as isExpr2
+  isRef
 } from "@safe-ugc-ui/types";
 var COLOR_PROPERTIES = /* @__PURE__ */ new Set(["backgroundColor", "color"]);
 var LENGTH_PROPERTIES = /* @__PURE__ */ new Set([
@@ -434,7 +406,7 @@ function isLiteralString(value) {
   return typeof value === "string";
 }
 function isDynamic(value) {
-  return isRef2(value) || isExpr2(value);
+  return isRef(value);
 }
 function isValidColor(value) {
   const lower = value.toLowerCase();
@@ -479,7 +451,7 @@ function collectDangerousCssErrors(value, path, errors) {
     }
     return;
   }
-  if (isRef2(value) || isExpr2(value)) {
+  if (isRef(value)) {
     return;
   }
   if (Array.isArray(value)) {
@@ -524,7 +496,66 @@ function validateShadowObject(shadow, path, errors) {
   }
 }
 var STYLE_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/;
-function validateSingleStyle(style, stylePath, errors) {
+function reportStyleRefError(rawRef, stylePath, cardStyles, errors) {
+  const trimmedRef = rawRef.trim();
+  if (!STYLE_NAME_PATTERN.test(trimmedRef)) {
+    errors.push(
+      createError(
+        "INVALID_STYLE_REF",
+        `$style value "${rawRef}" is invalid; must match /^[A-Za-z][A-Za-z0-9_-]*$/ at "${stylePath}.$style"`,
+        `${stylePath}.$style`
+      )
+    );
+    return void 0;
+  }
+  if (!cardStyles || !(trimmedRef in cardStyles)) {
+    errors.push(
+      createError(
+        "STYLE_REF_NOT_FOUND",
+        `$style references "${trimmedRef}" which is not defined in card.styles at "${stylePath}.$style"`,
+        `${stylePath}.$style`
+      )
+    );
+    return void 0;
+  }
+  return trimmedRef;
+}
+function resolveStyleRef(style, stylePath, cardStyles, errors) {
+  if (typeof style.$style !== "string") {
+    return style;
+  }
+  const trimmedRef = reportStyleRefError(style.$style, stylePath, cardStyles, errors);
+  if (!trimmedRef || !cardStyles) {
+    return void 0;
+  }
+  return mergeStyleWithRef(cardStyles[trimmedRef], style);
+}
+function collectNestedStyleRefErrors(value, path, errors) {
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      collectNestedStyleRefErrors(value[i], `${path}[${i}]`, errors);
+    }
+    return;
+  }
+  if (typeof value !== "object" || value === null) {
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const childPath = `${path}.${key}`;
+    if (key === "$style") {
+      errors.push(
+        createError(
+          "STYLE_CIRCULAR_REF",
+          `$style cannot be used inside card.styles definitions at "${childPath}"`,
+          childPath
+        )
+      );
+      continue;
+    }
+    collectNestedStyleRefErrors(child, childPath, errors);
+  }
+}
+function validateSingleStyle(style, stylePath, errors, cardStyles, allowHoverStyleRefs = true) {
   const STRUCTURED_FIELDS = /* @__PURE__ */ new Set(["transition", "hoverStyle"]);
   for (const key of Object.keys(style)) {
     if (!STRUCTURED_FIELDS.has(key) && FORBIDDEN_STYLE_PROPERTIES.includes(key)) {
@@ -809,16 +840,16 @@ function validateSingleStyle(style, stylePath, errors) {
           )
         );
       }
-      if ("$style" in hoverObj) {
-        errors.push(
-          createError(
-            "INVALID_STYLE_REF",
-            `$style is not allowed inside hoverStyle at "${hoverPath}.$style"`,
-            `${hoverPath}.$style`
-          )
+      const mergedHoverStyle = allowHoverStyleRefs ? resolveStyleRef(hoverObj, hoverPath, cardStyles, errors) : hoverObj;
+      if (mergedHoverStyle) {
+        validateSingleStyle(
+          mergedHoverStyle,
+          hoverPath,
+          errors,
+          cardStyles,
+          allowHoverStyleRefs
         );
       }
-      validateSingleStyle(hoverObj, hoverPath, errors);
     }
   }
   if ("transition" in style && style.transition != null) {
@@ -906,16 +937,8 @@ function validateStyles(views, cardStyles) {
           )
         );
       }
-      if ("$style" in styleEntry) {
-        errors.push(
-          createError(
-            "STYLE_CIRCULAR_REF",
-            `$style cannot be used inside card.styles definitions at "${entryPath}.$style"`,
-            `${entryPath}.$style`
-          )
-        );
-      }
-      validateSingleStyle(styleEntry, entryPath, errors);
+      collectNestedStyleRefErrors(styleEntry, entryPath, errors);
+      validateSingleStyle(styleEntry, entryPath, errors, void 0, false);
     }
   }
   traverseCard(views, (node, ctx) => {
@@ -924,33 +947,9 @@ function validateStyles(views, cardStyles) {
       return;
     }
     const stylePath = `${ctx.path}.style`;
-    if ("$style" in style && typeof style.$style === "string") {
-      const rawRef = style.$style;
-      const trimmedRef = rawRef.trim();
-      if (!STYLE_NAME_PATTERN.test(trimmedRef)) {
-        errors.push(
-          createError(
-            "INVALID_STYLE_REF",
-            `$style value "${rawRef}" is invalid; must match /^[A-Za-z][A-Za-z0-9_-]*$/ at "${stylePath}.$style"`,
-            `${stylePath}.$style`
-          )
-        );
-        return;
-      }
-      if (!cardStyles || !(trimmedRef in cardStyles)) {
-        errors.push(
-          createError(
-            "STYLE_REF_NOT_FOUND",
-            `$style references "${trimmedRef}" which is not defined in card.styles at "${stylePath}.$style"`,
-            `${stylePath}.$style`
-          )
-        );
-        return;
-      }
-      const mergedStyle = mergeStyleWithRef(cardStyles[trimmedRef], style);
-      validateSingleStyle(mergedStyle, stylePath, errors);
-    } else {
-      validateSingleStyle(style, stylePath, errors);
+    const mergedStyle = resolveStyleRef(style, stylePath, cardStyles, errors);
+    if (mergedStyle) {
+      validateSingleStyle(mergedStyle, stylePath, errors, cardStyles);
     }
   });
   return errors;
@@ -959,7 +958,7 @@ function validateStyles(views, cardStyles) {
 // src/security.ts
 import {
   PROTOTYPE_POLLUTION_SEGMENTS,
-  isRef as isRef3
+  isRef as isRef2
 } from "@safe-ugc-ui/types";
 var FORBIDDEN_URL_PREFIXES = [
   "http://",
@@ -972,7 +971,7 @@ function scanForRefs(obj, path, errors) {
   if (obj === null || obj === void 0 || typeof obj !== "object") {
     return;
   }
-  if (isRef3(obj)) {
+  if (isRef2(obj)) {
     const refStr = obj.$ref;
     const segments = refStr.split(/[.\[]/);
     for (const segment of segments) {
@@ -1109,12 +1108,11 @@ function validateSecurity(card) {
     delete nodeFields.type;
     delete nodeFields.style;
     delete nodeFields.children;
-    delete nodeFields.condition;
     if (type === "Image" || type === "Avatar") {
       const src = node.src;
       if (typeof src === "string") {
         checkSrcValue(src, type, `${path}.src`, errors);
-      } else if (isRef3(src)) {
+      } else if (isRef2(src)) {
         if (state) {
           const resolved = resolveRefFromState(
             src.$ref,
@@ -1207,8 +1205,7 @@ import {
   MAX_OVERFLOW_AUTO_COUNT,
   MAX_STACK_NESTING,
   PROTOTYPE_POLLUTION_SEGMENTS as PROTOTYPE_POLLUTION_SEGMENTS2,
-  isRef as isRef4,
-  isExpr as isExpr3
+  isRef as isRef3
 } from "@safe-ugc-ui/types";
 function utf8ByteLength(str) {
   let bytes = 0;
@@ -1269,7 +1266,7 @@ function countTemplateMetrics(template, cardStyles) {
   result.nodes = 1;
   if (node.type === "Text") {
     const content = node.content;
-    if (typeof content === "string" && !isRef4(content) && !isExpr3(content)) {
+    if (typeof content === "string" && !isRef3(content)) {
       result.textBytes = utf8ByteLength(content);
     }
   }
@@ -1325,7 +1322,7 @@ function validateLimits(card) {
     nodeCount++;
     if (node.type === "Text") {
       const content = node.content;
-      if (typeof content === "string" && !isRef4(content) && !isExpr3(content)) {
+      if (typeof content === "string" && !isRef3(content)) {
         textContentBytes += utf8ByteLength(content);
       }
     }
@@ -1460,428 +1457,6 @@ function validateLimits(card) {
   return errors;
 }
 
-// src/expr-constraints.ts
-import {
-  EXPR_MAX_LENGTH,
-  EXPR_MAX_TOKENS,
-  EXPR_MAX_NESTING,
-  EXPR_MAX_CONDITION_NESTING,
-  EXPR_MAX_REF_DEPTH,
-  EXPR_MAX_ARRAY_INDEX,
-  EXPR_MAX_STRING_LITERAL,
-  EXPR_MAX_FRACTIONAL_DIGITS,
-  isRef as isRef5,
-  isExpr as isExpr4
-} from "@safe-ugc-ui/types";
-var FORBIDDEN_KEYWORDS = [
-  "typeof",
-  "instanceof",
-  "new",
-  "delete",
-  "function",
-  "return",
-  "var",
-  "let",
-  "const"
-];
-var FORBIDDEN_KEYWORD_SET = new Set(FORBIDDEN_KEYWORDS);
-var PROTOTYPE_POLLUTION_SEGMENTS3 = /* @__PURE__ */ new Set([
-  "__proto__",
-  "constructor",
-  "prototype"
-]);
-function tokenize(expr, path) {
-  const tokens = [];
-  const errors = [];
-  let i = 0;
-  while (i < expr.length) {
-    if (/\s/.test(expr[i])) {
-      i++;
-      continue;
-    }
-    if (i + 2 < expr.length) {
-      const three = expr.slice(i, i + 3);
-      if (three === "===" || three === "!==") {
-        tokens.push({ type: "comparison", value: three, position: i });
-        i += 3;
-        continue;
-      }
-    }
-    if (i + 1 < expr.length) {
-      const two = expr.slice(i, i + 2);
-      if (two === "==" || two === "!=" || two === "<=" || two === ">=") {
-        tokens.push({ type: "comparison", value: two, position: i });
-        i += 2;
-        continue;
-      }
-      if (two === "&&" || two === "||") {
-        tokens.push({ type: "logic_keyword", value: two, position: i });
-        i += 2;
-        continue;
-      }
-    }
-    if (expr[i] === "'" || expr[i] === '"') {
-      const quote = expr[i];
-      let j = i + 1;
-      while (j < expr.length && expr[j] !== quote) {
-        if (expr[j] === "\\" && j + 1 < expr.length) {
-          j += 2;
-        } else {
-          j++;
-        }
-      }
-      const innerValue = expr.slice(i + 1, j);
-      tokens.push({ type: "string", value: innerValue, position: i });
-      i = j + 1;
-      continue;
-    }
-    if (/[0-9]/.test(expr[i]) || expr[i] === "-" && i + 1 < expr.length && /[0-9]/.test(expr[i + 1]) && isNegativeSign(tokens)) {
-      let j = i;
-      if (expr[j] === "-") j++;
-      while (j < expr.length && /[0-9]/.test(expr[j])) j++;
-      if (j < expr.length && expr[j] === ".") {
-        j++;
-        while (j < expr.length && /[0-9]/.test(expr[j])) j++;
-      }
-      const numStr = expr.slice(i, j);
-      const dotIdx = numStr.indexOf(".");
-      if (dotIdx !== -1) {
-        const fractionalPart = numStr.slice(dotIdx + 1);
-        if (fractionalPart.length > EXPR_MAX_FRACTIONAL_DIGITS) {
-          errors.push(
-            createError(
-              "EXPR_INVALID_TOKEN",
-              `Number literal "${numStr}" at position ${i} has ${fractionalPart.length} fractional digits, maximum is ${EXPR_MAX_FRACTIONAL_DIGITS}.`,
-              path
-            )
-          );
-        }
-      }
-      tokens.push({ type: "number", value: numStr, position: i });
-      i = j;
-      continue;
-    }
-    if (expr[i] === "$" || /[a-zA-Z_]/.test(expr[i])) {
-      let j = i;
-      if (expr[j] === "$") j++;
-      while (j < expr.length && /[\w]/.test(expr[j])) j++;
-      const word = expr.slice(i, j);
-      if (word === "true" || word === "false") {
-        tokens.push({ type: "boolean", value: word, position: i });
-      } else if (word === "and" || word === "or" || word === "not") {
-        tokens.push({ type: "logic_keyword", value: word, position: i });
-      } else if (word === "if" || word === "then" || word === "else") {
-        tokens.push({ type: "condition_keyword", value: word, position: i });
-      } else {
-        tokens.push({ type: "identifier", value: word, position: i });
-      }
-      i = j;
-      continue;
-    }
-    const ch = expr[i];
-    if ("+-*/%".includes(ch)) {
-      tokens.push({ type: "arithmetic", value: ch, position: i });
-      i++;
-      continue;
-    }
-    if (ch === "<" || ch === ">") {
-      tokens.push({ type: "comparison", value: ch, position: i });
-      i++;
-      continue;
-    }
-    if ("().[]".includes(ch)) {
-      tokens.push({ type: "separator", value: ch, position: i });
-      i++;
-      continue;
-    }
-    if (ch === "!") {
-      tokens.push({ type: "comparison", value: ch, position: i });
-      i++;
-      continue;
-    }
-    errors.push(
-      createError(
-        "EXPR_INVALID_TOKEN",
-        `Unrecognized character "${ch}" at position ${i} in expression.`,
-        path
-      )
-    );
-    i++;
-  }
-  for (let t = 0; t < tokens.length; t++) {
-    const tok = tokens[t];
-    if (tok.value === "===" || tok.value === "!==" || (tok.value === "&&" || tok.value === "||")) {
-      errors.push(
-        createError(
-          "EXPR_FORBIDDEN_TOKEN",
-          `Forbidden operator "${tok.value}" at position ${tok.position}. Use "==" / "!=" or "and" / "or" instead.`,
-          path
-        )
-      );
-    }
-    if (tok.value === "!") {
-      errors.push(
-        createError(
-          "EXPR_FORBIDDEN_TOKEN",
-          `Forbidden operator "!" at position ${tok.position}. Use "not" instead.`,
-          path
-        )
-      );
-    }
-    if (tok.type === "identifier" && FORBIDDEN_KEYWORD_SET.has(tok.value)) {
-      errors.push(
-        createError(
-          "EXPR_FORBIDDEN_TOKEN",
-          `Forbidden keyword "${tok.value}" at position ${tok.position}.`,
-          path
-        )
-      );
-    }
-    if (tok.type === "identifier" && !tok.value.startsWith("$") && !FORBIDDEN_KEYWORD_SET.has(tok.value)) {
-      errors.push(
-        createError(
-          "EXPR_FORBIDDEN_TOKEN",
-          `Identifier "${tok.value}" at position ${tok.position} must start with "$". Use "$${tok.value}" for variable references.`,
-          path
-        )
-      );
-    }
-    if (tok.type === "identifier") {
-      const next = tokens[t + 1];
-      if (next && next.type === "separator" && next.value === "(") {
-        errors.push(
-          createError(
-            "EXPR_FUNCTION_CALL",
-            `Function call pattern detected: "${tok.value}(" at position ${tok.position}. Function calls are not allowed.`,
-            path
-          )
-        );
-      }
-    }
-  }
-  return { tokens, errors };
-}
-function isNegativeSign(tokens) {
-  if (tokens.length === 0) return true;
-  const prev = tokens[tokens.length - 1];
-  if (prev.type === "arithmetic" || prev.type === "comparison" || prev.type === "logic_keyword" || prev.type === "condition_keyword") {
-    return true;
-  }
-  if (prev.type === "separator" && (prev.value === "(" || prev.value === "[")) {
-    return true;
-  }
-  return false;
-}
-function scanForDynamicValues(obj, basePath, callback) {
-  if (obj === null || obj === void 0 || typeof obj !== "object") {
-    return;
-  }
-  if (isRef5(obj) || isExpr4(obj)) {
-    callback(obj, basePath);
-    return;
-  }
-  if (Array.isArray(obj)) {
-    for (let i = 0; i < obj.length; i++) {
-      scanForDynamicValues(obj[i], `${basePath}[${i}]`, callback);
-    }
-  } else {
-    for (const [key, value] of Object.entries(obj)) {
-      scanForDynamicValues(value, `${basePath}.${key}`, callback);
-    }
-  }
-}
-function validateRef(refValue, path) {
-  const errors = [];
-  if (refValue.length > 500) {
-    errors.push(
-      createError(
-        "REF_TOO_LONG",
-        `$ref value exceeds maximum length of 500 characters (got ${refValue.length}).`,
-        path
-      )
-    );
-  }
-  const segments = refValue.split(".");
-  if (segments.length > EXPR_MAX_REF_DEPTH) {
-    errors.push(
-      createError(
-        "EXPR_REF_DEPTH_EXCEEDED",
-        `$ref path depth ${segments.length} exceeds maximum of ${EXPR_MAX_REF_DEPTH}.`,
-        path
-      )
-    );
-  }
-  const arrayIndexPattern = /\[(\d+)\]/g;
-  let match;
-  while ((match = arrayIndexPattern.exec(refValue)) !== null) {
-    const index = parseInt(match[1], 10);
-    if (index > EXPR_MAX_ARRAY_INDEX) {
-      errors.push(
-        createError(
-          "EXPR_ARRAY_INDEX_EXCEEDED",
-          `Array index ${index} in $ref exceeds maximum of ${EXPR_MAX_ARRAY_INDEX}.`,
-          path
-        )
-      );
-    }
-  }
-  for (const segment of segments) {
-    const cleanSegment = segment.replace(/\[\d+\]/g, "");
-    if (PROTOTYPE_POLLUTION_SEGMENTS3.has(cleanSegment)) {
-      errors.push(
-        createError(
-          "PROTOTYPE_POLLUTION",
-          `$ref path contains forbidden segment "${cleanSegment}".`,
-          path
-        )
-      );
-    }
-  }
-  return errors;
-}
-function validateExpr(exprValue, path) {
-  const errors = [];
-  if (exprValue.length > EXPR_MAX_LENGTH) {
-    errors.push(
-      createError(
-        "EXPR_TOO_LONG",
-        `Expression exceeds maximum length of ${EXPR_MAX_LENGTH} characters (got ${exprValue.length}).`,
-        path
-      )
-    );
-  }
-  const { tokens, errors: tokenErrors } = tokenize(exprValue, path);
-  errors.push(...tokenErrors);
-  if (tokens.length > EXPR_MAX_TOKENS) {
-    errors.push(
-      createError(
-        "EXPR_TOO_MANY_TOKENS",
-        `Expression has ${tokens.length} tokens, exceeding maximum of ${EXPR_MAX_TOKENS}.`,
-        path
-      )
-    );
-  }
-  for (const tok of tokens) {
-    if (tok.type === "string" && tok.value.length > EXPR_MAX_STRING_LITERAL) {
-      errors.push(
-        createError(
-          "EXPR_STRING_LITERAL_TOO_LONG",
-          `String literal at position ${tok.position} has ${tok.value.length} characters, exceeding maximum of ${EXPR_MAX_STRING_LITERAL}.`,
-          path
-        )
-      );
-    }
-  }
-  let parenDepth = 0;
-  let maxParenDepth = 0;
-  let ifCount = 0;
-  for (const tok of tokens) {
-    if (tok.type === "separator" && tok.value === "(") {
-      parenDepth++;
-      if (parenDepth > maxParenDepth) {
-        maxParenDepth = parenDepth;
-      }
-    } else if (tok.type === "separator" && tok.value === ")") {
-      parenDepth--;
-    } else if (tok.type === "condition_keyword" && tok.value === "if") {
-      ifCount++;
-    }
-  }
-  if (maxParenDepth > EXPR_MAX_NESTING) {
-    errors.push(
-      createError(
-        "EXPR_NESTING_TOO_DEEP",
-        `Expression parenthesis nesting depth ${maxParenDepth} exceeds maximum of ${EXPR_MAX_NESTING}.`,
-        path
-      )
-    );
-  }
-  if (ifCount > EXPR_MAX_CONDITION_NESTING) {
-    errors.push(
-      createError(
-        "EXPR_CONDITION_NESTING_TOO_DEEP",
-        `Expression has ${ifCount} nested if-conditions, exceeding maximum of ${EXPR_MAX_CONDITION_NESTING}.`,
-        path
-      )
-    );
-  }
-  for (let t = 0; t < tokens.length; t++) {
-    const tok = tokens[t];
-    if (tok.type === "identifier" && tok.value.startsWith("$")) {
-      let depth = 1;
-      let j = t + 1;
-      while (j + 1 < tokens.length) {
-        if (tokens[j].type === "separator" && tokens[j].value === "." && tokens[j + 1].type === "identifier") {
-          depth++;
-          j += 2;
-        } else {
-          break;
-        }
-      }
-      if (depth > EXPR_MAX_REF_DEPTH) {
-        errors.push(
-          createError(
-            "EXPR_REF_DEPTH_EXCEEDED",
-            `Variable reference "${tok.value}" has path depth ${depth}, exceeding maximum of ${EXPR_MAX_REF_DEPTH}.`,
-            path
-          )
-        );
-      }
-    }
-  }
-  for (let t = 0; t + 2 < tokens.length; t++) {
-    if (tokens[t].type === "separator" && tokens[t].value === "[" && tokens[t + 1].type === "number" && tokens[t + 2].type === "separator" && tokens[t + 2].value === "]") {
-      const indexValue = parseFloat(tokens[t + 1].value);
-      if (indexValue > EXPR_MAX_ARRAY_INDEX) {
-        errors.push(
-          createError(
-            "EXPR_ARRAY_INDEX_EXCEEDED",
-            `Array index ${indexValue} in expression exceeds maximum of ${EXPR_MAX_ARRAY_INDEX}.`,
-            path
-          )
-        );
-      }
-    }
-  }
-  return errors;
-}
-function validateExprConstraints(views) {
-  const errors = [];
-  traverseCard(views, (node, context) => {
-    const nodeFields = { ...node };
-    delete nodeFields.type;
-    delete nodeFields.style;
-    delete nodeFields.children;
-    delete nodeFields.condition;
-    scanForDynamicValues(nodeFields, context.path, (value, valuePath) => {
-      if (isRef5(value)) {
-        errors.push(...validateRef(value.$ref, valuePath));
-      } else if (isExpr4(value)) {
-        errors.push(...validateExpr(value.$expr, valuePath));
-      }
-    });
-    if (node.style) {
-      scanForDynamicValues(node.style, `${context.path}.style`, (value, valuePath) => {
-        if (isRef5(value)) {
-          errors.push(...validateRef(value.$ref, valuePath));
-        } else if (isExpr4(value)) {
-          errors.push(...validateExpr(value.$expr, valuePath));
-        }
-      });
-    }
-    if (node.condition !== void 0) {
-      scanForDynamicValues(node.condition, `${context.path}.condition`, (value, valuePath) => {
-        if (isRef5(value)) {
-          errors.push(...validateRef(value.$ref, valuePath));
-        } else if (isExpr4(value)) {
-          errors.push(...validateExpr(value.$expr, valuePath));
-        }
-      });
-    }
-  });
-  return errors;
-}
-
 // src/index.ts
 function utf8ByteLength2(str) {
   let bytes = 0;
@@ -1915,7 +1490,6 @@ function runAllChecks(input) {
     cardStyles
   }));
   errors.push(...validateLimits({ state: obj.state, views, cardStyles }));
-  errors.push(...validateExprConstraints(views));
   return errors;
 }
 function validate(input) {
@@ -1958,7 +1532,6 @@ export {
   traverseNode,
   validResult,
   validate,
-  validateExprConstraints,
   validateLimits,
   validateNodes,
   validateRaw,