@multiplatform.one/theme 7.83.0 → 7.83.2

package/dist/cjs/audit/constraintAudit.cjs

@@ -0,0 +1,567 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var constraintAudit_exports = {};
+__export(constraintAudit_exports, {
+  GAP_KNOB: () => GAP_KNOB,
+  GAP_LG_KNOB: () => GAP_LG_KNOB,
+  runConstraintAudit: () => runConstraintAudit
+});
+module.exports = __toCommonJS(constraintAudit_exports);
+var import_generateScale = require("../theme/scale/generateScale.cjs");
+var import_scaleInputs = require("../theme/scale/scaleInputs.cjs");
+function activeScaleTokens() {
+  const published = globalThis.__MPO_SCALE__;
+  return published?.tokens ?? (0, import_generateScale.generateScale)(import_scaleInputs.defaultScaleInputs).tokens;
+}
+function numericTokens(group) {
+  const out = {};
+  for (const [key, px] of Object.entries(group)) {
+    const stop = Number(key.replace(/^\$/, ""));
+    if (Number.isFinite(stop) && stop >= 0) out[stop] = px;
+  }
+  return out;
+}
+const scaleTokens = activeScaleTokens();
+const RADIUS_TOKENS = numericTokens(scaleTokens.radius);
+const SPACE_TOKENS = numericTokens(scaleTokens.space);
+const BORDER_RADIUS_KNOB = {
+  none: RADIUS_TOKENS[0],
+  small: RADIUS_TOKENS[2],
+  medium: RADIUS_TOKENS[4],
+  large: RADIUS_TOKENS[6],
+  full: RADIUS_TOKENS[12]
+};
+const OUTER_RADIUS_KNOB = {
+  none: RADIUS_TOKENS[0],
+  small: RADIUS_TOKENS[2],
+  medium: RADIUS_TOKENS[3],
+  large: RADIUS_TOKENS[4],
+  full: RADIUS_TOKENS[5]
+};
+const BORDER_WIDTH_KNOB = {
+  none: 0,
+  small: 0.5,
+  medium: 1,
+  large: 2
+};
+const GAP_KNOB = {
+  gapSm: SPACE_TOKENS[2],
+  gap: SPACE_TOKENS[3]
+};
+const GAP_LG_KNOB = {
+  gapLg: SPACE_TOKENS[5]
+};
+const PANEL_PADDING_KNOB = {
+  panelPadding: SPACE_TOKENS[4],
+  featurePadding: SPACE_TOKENS[6]
+};
+const FONT_WEIGHT_KNOB = {
+  regular: 400,
+  bold: 700
+};
+const VALID_BORDER_RADIUS_PX = /* @__PURE__ */new Set([...Object.values(BORDER_RADIUS_KNOB), ...Object.values(OUTER_RADIUS_KNOB)]);
+const VALID_BORDER_WIDTH = new Set(Object.values(BORDER_WIDTH_KNOB));
+const VALID_GAP_PX = /* @__PURE__ */new Set([0, ...Object.values(GAP_KNOB), ...Object.values(GAP_LG_KNOB)]);
+const VALID_PADDING_PX = /* @__PURE__ */new Set([0, ...Object.values(PANEL_PADDING_KNOB)]);
+const VALID_FONT_WEIGHT = new Set(Object.values(FONT_WEIGHT_KNOB));
+function runConstraintAudit(rootSelector) {
+  if (typeof document === "undefined") throw new Error("runConstraintAudit needs a DOM");
+  const _publishedScale = globalThis.__MPO_SCALE__;
+  const _scale = _publishedScale?.tokens;
+  const _radius = (key, px) => _scale?.radius?.[key] ?? px;
+  const _space = (key, px) => _scale?.space?.[`$${key}`] ?? px;
+  const _size = (key, px) => _scale?.size?.[`$${key}`] ?? px;
+  const _SPACE_1 = _space("1", 2);
+  const _SPACE_1_5 = _space("1.5", 4);
+  const _SPACE_2 = _space("2", 6);
+  const _SPACE_3 = _space("3", 12);
+  const _SIZE_0_5 = _size("0.5", 4);
+  const _CONTROL_GAPS = new Set(_publishedScale?.controlGaps ?? [3, 4, 5, 6, 7, 8, 9, 14]);
+  const _BORDER_RADIUS_KNOB = {
+    none: _radius("0", 0),
+    small: _radius("2", 4),
+    medium: _radius("4", 8),
+    large: _radius("6", 14),
+    full: _radius("12", 44)
+  };
+  const _CONTAINER_RADIUS_KNOB = {
+    none: _radius("0", 0),
+    small: _radius("4", 8),
+    medium: _radius("6", 14),
+    large: _radius("8", 20),
+    full: _radius("12", 44)
+  };
+  const _OUTER_RADIUS_KNOB = {
+    none: _radius("0", 0),
+    small: _radius("2", 4),
+    medium: _radius("3", 6),
+    large: _radius("4", 8),
+    full: _radius("5", 9)
+  };
+  const _BORDER_WIDTH_KNOB = {
+    none: 0,
+    small: 0.5,
+    medium: 1,
+    large: 2
+  };
+  const _GAP_KNOB = {
+    gapSm: _space("2", 6),
+    gap: _space("3", 12)
+  };
+  const _GAP_LG_KNOB = {
+    gapLg: _space("5", 21)
+  };
+  const _PANEL_PADDING_KNOB = {
+    panelPadding: _space("4", 16),
+    featurePadding: _space("6", 28)
+  };
+  const _FONT_WEIGHT_KNOB = {
+    light: 300,
+    // Inter body default weight
+    regular: 400,
+    bold: 700
+  };
+  const _VALID_RADIUS = /* @__PURE__ */new Set([...Object.values(_BORDER_RADIUS_KNOB), ...Object.values(_OUTER_RADIUS_KNOB), ...Object.values(_CONTAINER_RADIUS_KNOB), ...Object.values(_CONTAINER_RADIUS_KNOB).map(radius => Math.min(radius, _PANEL_PADDING_KNOB.panelPadding)), 1e3,
+  // Tamagui pill radius (Switch, RadioGroup.Item)
+  1e5
+  // Tamagui circular button radius (Button circular variant)
+  ]);
+  const _VALID_BORDER_WIDTH = new Set(Object.values(_BORDER_WIDTH_KNOB));
+  const _VALID_GAP = /* @__PURE__ */new Set([0, _SPACE_1, 3.9,
+  // Tamagui InputContainerFrame size-proportional gap
+  _SPACE_1_5, _SIZE_0_5,
+  // Tamagui button internals
+  ..._CONTROL_GAPS, ...Object.values(_GAP_KNOB), ...Object.values(_GAP_LG_KNOB)]);
+  const _VALID_PADDING = /* @__PURE__ */new Set([0, _SPACE_1, _SPACE_2,
+  // button padding at $size.$2
+  _SPACE_3,
+  // a fixed-token inset (chips, OwnInset rows)
+  ...Object.values(_PANEL_PADDING_KNOB)]);
+  const _VALID_FONT_WEIGHT = new Set(Object.values(_FONT_WEIGHT_KNOB));
+  const _FONT_FAMILY_KNOB = {
+    inter: "sans-serif ($body/$heading)",
+    georgia: "serif",
+    "ibm plex mono": "mono",
+    "ui-monospace": "mono",
+    monospace: "mono",
+    "roboto slab": "slab",
+    rockwell: "slab (fallback)",
+    nunito: "rounded",
+    "varela round": "rounded (fallback)",
+    "roboto condensed": "condensed",
+    "arial narrow": "condensed (fallback)",
+    "dancing script": "cursive",
+    pacifico: "cursive (fallback)",
+    caveat: "handwriting",
+    "patrick hand": "handwriting (fallback)",
+    silkscreen: "pixel",
+    "press start 2p": "pixel (fallback)",
+    unifrakturcook: "blackletter",
+    fraktur: "blackletter (fallback)",
+    futura: "geometric",
+    poppins: "geometric (fallback)",
+    "century gothic": "geometric (fallback)"
+  };
+  const _SYSTEM_FONTS = /* @__PURE__ */new Set(["-apple-system", "system-ui", "blinkmacsystemfont", "segoe ui", "roboto", "helvetica", "arial", "sans-serif", "serif", "cursive", "comic sans ms", "courier new", "times new roman", "times"]);
+  function _reverseRadius(px) {
+    if (px === 1e3) return "pill";
+    if (px === 1e5) return "circular";
+    for (const [k, v] of Object.entries(_BORDER_RADIUS_KNOB)) {
+      if (v === px) return k;
+    }
+    for (const [k, v] of Object.entries(_OUTER_RADIUS_KNOB)) {
+      if (v === px) return `${k} (outer)`;
+    }
+    for (const [k, v] of Object.entries(_CONTAINER_RADIUS_KNOB)) {
+      if (v === px) return `${k} (container)`;
+      if (Math.min(v, _PANEL_PADDING_KNOB.panelPadding) === px) return `${k} (container cap)`;
+    }
+    return "off-scale";
+  }
+  function _reverseBorderWidth(px) {
+    for (const [k, v] of Object.entries(_BORDER_WIDTH_KNOB)) {
+      if (v === px) return k;
+    }
+    return "off-scale";
+  }
+  function _reverseGap(px) {
+    if (px === 0) return "none";
+    for (const [k, v] of Object.entries(_GAP_KNOB)) {
+      if (v === px) return k;
+    }
+    for (const [k, v] of Object.entries(_GAP_LG_KNOB)) {
+      if (v === px) return `${k} (lg)`;
+    }
+    if (px === _SPACE_1) return `space-token(${px}px)`;
+    if (px === 3.9) return "input-internal(3.9px)";
+    if (px === _SPACE_1_5 || px === _SIZE_0_5 || _CONTROL_GAPS.has(px)) return `size-token(${px}px)`;
+    return "off-scale";
+  }
+  function _reversePadding(px) {
+    if (px === 0) return "none";
+    for (const [k, v] of Object.entries(_PANEL_PADDING_KNOB)) {
+      if (v === px) return k;
+    }
+    if (px === _SPACE_1) return `space-token(${px}px)`;
+    if (px === _SPACE_2 || px === _SPACE_3) return `size-token(${px}px)`;
+    return "off-scale";
+  }
+  function _reverseFontWeight(w) {
+    for (const [k, v] of Object.entries(_FONT_WEIGHT_KNOB)) {
+      if (v === w) return k;
+    }
+    return "off-scale";
+  }
+  function _reverseFontFamily(computed) {
+    const first = computed.split(",")[0].trim().replace(/^['"]|['"]$/g, "").toLowerCase();
+    if (!first) return {
+      knob: "empty",
+      offScale: true
+    };
+    const knob = _FONT_FAMILY_KNOB[first];
+    if (knob) return {
+      knob,
+      offScale: false
+    };
+    if (_SYSTEM_FONTS.has(first)) return {
+      knob: `system (${first})`,
+      offScale: false
+    };
+    return {
+      knob: "off-scale",
+      offScale: true
+    };
+  }
+  function _checkInlineColors(el) {
+    const htmlEl = el;
+    if (!htmlEl.style) return null;
+    const colorProps = ["color", "backgroundColor", "borderColor"];
+    for (const prop of colorProps) {
+      const val = htmlEl.style[prop];
+      if (!val || val === "inherit" || val === "transparent" || val === "currentColor") continue;
+      if (val.startsWith("var(")) continue;
+      return {
+        property: prop,
+        value: val
+      };
+    }
+    return null;
+  }
+  function parsePx(raw) {
+    if (!raw || raw === "" || raw === "normal" || raw === "auto") return null;
+    const first = raw.split(" ")[0];
+    const n = parseFloat(first);
+    if (isNaN(n)) return null;
+    return Math.round(n * 100) / 100;
+  }
+  function isPercentageBorderRadius(el) {
+    const inline = el.style?.borderRadius ?? "";
+    if (inline.includes("%")) return true;
+    return false;
+  }
+  function elementLabel(el) {
+    const tag = el.tagName.toLowerCase();
+    const generatedId = /^(?:_r_[0-9a-z]+_|:r[0-9a-z]+:|«r[0-9a-z]+»)$/.test(el.id);
+    const id = el.id && !generatedId ? `#${el.id}` : "";
+    const classes = Array.from(el.classList).filter(c => c.length > 3 && !c.startsWith("_") && !/^[_a-z0-9]{1,8}-/.test(c) && !/^\d/.test(c)).slice(0, 3).join(".");
+    const cls = classes ? `.${classes}` : "";
+    const role = el.getAttribute("role") ? `[role=${el.getAttribute("role")}]` : "";
+    const testId = el.getAttribute("data-testid") ? `[data-testid=${el.getAttribute("data-testid")}]` : "";
+    return `${tag}${id}${cls}${role}${testId}` || tag;
+  }
+  function elementKey(el, scope2) {
+    const path = [];
+    for (let node = el; node; node = node.parentElement) {
+      const siblings = node.parentElement ? Array.from(node.parentElement.children).filter(sibling => sibling.tagName === node.tagName) : [node];
+      path.unshift(`${node.tagName.toLowerCase()}:nth-of-type(${siblings.indexOf(node) + 1})`);
+      if (node === scope2) break;
+    }
+    return path.join(" > ");
+  }
+  function isPainted(el) {
+    const ownStyle = getComputedStyle(el);
+    if (ownStyle.visibility === "hidden" || ownStyle.visibility === "collapse") return false;
+    for (let node = el; node; node = node.parentElement) {
+      const style = getComputedStyle(node);
+      if (style.display === "none" || node !== el && style.contentVisibility === "hidden" || Number.parseFloat(style.opacity) === 0) return false;
+    }
+    return true;
+  }
+  function auditProp(value, validSet, reverseFn, propName, violations) {
+    if (value === null || value === 0) return void 0;
+    const knob = reverseFn(value);
+    const offScale = !validSet.has(value);
+    if (offScale) {
+      violations.push(`${propName}: ${value}px is off-scale (no matching token)`);
+    }
+    return {
+      value,
+      unit: "px",
+      knob,
+      offScale
+    };
+  }
+  function readPreset() {
+    const root = document.documentElement;
+    return root.dataset.preset ?? document.cookie.split("; ").find(c => c.startsWith("mp.preset="))?.split("=")[1] ?? "unknown";
+  }
+  function readScheme() {
+    const root = document.documentElement;
+    if (root.classList.contains("t_dark")) return "dark";
+    if (root.classList.contains("t_light")) return "light";
+    return root.style.colorScheme || "unknown";
+  }
+  const SKIP_TAGS = /* @__PURE__ */new Set(["script", "style", "link", "meta", "head", "html", "title", "noscript", "br", "hr", "col", "colgroup", "caption", "source", "track", "wbr", "area", "map", "param", "embed", "object", "base", "canvas", "audio", "video", "picture", "figure"]);
+  const DEVTOOLS_SELECTORS = ["#tanstack_devtools", "[data-testid=tanstack_devtools]"];
+  const devtoolsRoots = DEVTOOLS_SELECTORS.flatMap(s => Array.from(document.querySelectorAll(s)));
+  const scope = rootSelector ? document.querySelector(rootSelector) : document;
+  if (!scope) throw new Error(`Constraint audit scope not found: ${rootSelector}`);
+  const allElements = [...(typeof Element !== "undefined" && scope instanceof Element ? [scope] : []), ...Array.from(scope.querySelectorAll("*"))];
+  const candidates = allElements.filter(el => {
+    const tag = el.tagName.toLowerCase();
+    if (SKIP_TAGS.has(tag)) return false;
+    if (el.namespaceURI === "http://www.w3.org/2000/svg" && tag !== "svg") return false;
+    if (!isPainted(el)) return false;
+    if (devtoolsRoots.some(root => root.contains(el))) return false;
+    return true;
+  });
+  const auditedElements = [];
+  const violationElements = [];
+  for (const el of candidates) {
+    const style = getComputedStyle(el);
+    const tag = el.tagName.toLowerCase();
+    const entry = {
+      label: elementLabel(el),
+      key: elementKey(el, scope),
+      tag,
+      id: el.id || "",
+      classes: Array.from(el.classList).filter(c => c.length > 3 && !/^[_a-z][a-z0-9]{0,6}-/.test(c)).slice(0, 5),
+      violations: []
+    };
+    let hasAnyProp = false;
+    const containerName = el.getAttribute("data-constraint-container");
+    const ownsInset = containerName === "Card" || containerName === "PageSection";
+    const stackedRow = containerName === "StackedRow";
+    const ownInset = containerName === "OwnInset";
+    const capContainer = containerName === "Card" ? ["content", "elevated"].includes(el.getAttribute("data-tier") ?? "") : containerName === "PageSection" || containerName === "TextArea" || stackedRow || ownInset;
+    if (containerName !== null && containerName !== "Card" && !capContainer) {
+      entry.violations.push(`data-constraint-container: "${containerName}" is not a container the cap audit knows`);
+    }
+    const binaryPart = el.getAttribute("data-radius-resolution") === "BINARY";
+    const corners = ["borderTopLeftRadius", "borderTopRightRadius", "borderBottomRightRadius", "borderBottomLeftRadius"];
+    const stackPosition = el.getAttribute("data-stack-position") ?? "";
+    const outerCorners = {
+      only: corners,
+      first: ["borderTopLeftRadius", "borderTopRightRadius"],
+      middle: [],
+      last: ["borderBottomRightRadius", "borderBottomLeftRadius"]
+    };
+    const stackOuter = Object.hasOwn(outerCorners, stackPosition) ? outerCorners[stackPosition] : void 0;
+    if (stackedRow && !stackOuter) {
+      entry.violations.push(`data-stack-position: "${stackPosition}" is not a StackedRow position (only, first, middle, last)`);
+    }
+    if (capContainer) {
+      const radiusKnob = el.getAttribute("data-radius-knob") ?? "";
+      const radiusMap = containerName === "TextArea" ? _BORDER_RADIUS_KNOB : _CONTAINER_RADIUS_KNOB;
+      const radiusStop = Object.hasOwn(radiusMap, radiusKnob) ? radiusMap[radiusKnob] : void 0;
+      const paddingSides = ["paddingTop", "paddingRight", "paddingBottom", "paddingLeft"];
+      const measuredInsets = paddingSides.map(prop => parsePx(style[prop]));
+      const inset = ownInset ? measuredInsets.some(v => v === null) ? void 0 : Math.min(...measuredInsets) : _PANEL_PADDING_KNOB.panelPadding;
+      if (ownsInset) {
+        for (const [index, prop] of paddingSides.entries()) {
+          const value = measuredInsets[index];
+          const offScale = inset === void 0 || value !== inset;
+          entry[prop] = {
+            value: value ?? 0,
+            unit: "px",
+            knob: `${containerName} panelPadding`,
+            offScale
+          };
+          if (offScale) entry.violations.push(`${prop}: ${style[prop]} does not match ${containerName} panelPadding (${inset ?? "unknown"}px)`);
+        }
+      }
+      const cap = radiusStop === void 0 || inset === void 0 || stackedRow && !stackOuter || ownsInset && measuredInsets.some(v => v === null) ? void 0 : Math.min(radiusStop, inset, ...(ownsInset ? measuredInsets : []));
+      for (const prop of corners) {
+        const raw = style[prop];
+        const inner = stackedRow && stackOuter !== void 0 && !stackOuter.includes(prop);
+        const expected = inner ? 0 : cap;
+        const axes = raw.trim().split(/\s+/);
+        const offScale = expected === void 0 || axes.some(axis => !/^\d+(?:\.\d+)?(?:px)?$/.test(axis) || parsePx(axis) !== expected);
+        const result = {
+          value: parsePx(raw) ?? 0,
+          unit: "px",
+          knob: inner ? `${containerName} ${stackPosition} inner corner 0` : ownInset ? `${containerName} min(radius:${radiusKnob}, own padding)` : `${containerName} min(radius:${radiusKnob}, panelPadding)`,
+          offScale
+        };
+        entry[prop] = result;
+        if (offScale) entry.violations.push(inner ? `${prop}: ${raw} is an inner corner of a ${stackPosition} StackedRow (0px)` : `${prop}: ${raw} does not match ${containerName} cap (${expected ?? "unknown"}px)`);
+      }
+      entry.borderRadius = {
+        ...entry.borderTopLeftRadius,
+        offScale: corners.some(prop => entry[prop]?.offScale)
+      };
+      hasAnyProp = true;
+    } else if (binaryPart) {
+      const box = el;
+      const half = Math.min(box.offsetWidth, box.offsetHeight) / 2;
+      const measuredCorners = corners.map(prop => style[prop].trim().split(/\s+/));
+      if (measuredCorners.some(axes => axes.some(axis => parsePx(axis) !== 0))) {
+        for (const [index, prop] of corners.entries()) {
+          const raw = style[prop];
+          const offScale = measuredCorners[index].some(axis => {
+            if (!/^\d+(?:\.\d+)?(?:px)?$/.test(axis)) return true;
+            const value = parsePx(axis) ?? 0;
+            return value !== 0 && Math.abs(value - half) > 0.5;
+          });
+          entry[prop] = {
+            value: parsePx(raw) ?? 0,
+            unit: "px",
+            knob: "BINARY 0 | h/2",
+            offScale
+          };
+          if (offScale) entry.violations.push(`${prop}: ${raw} is neither 0 nor BINARY h/2 (${half}px)`);
+        }
+        entry.borderRadius = {
+          ...entry.borderTopLeftRadius,
+          offScale: corners.some(prop => entry[prop]?.offScale)
+        };
+        hasAnyProp = true;
+      }
+    } else if (!isPercentageBorderRadius(el)) {
+      const br = parsePx(style.borderTopLeftRadius || style.borderRadius);
+      if (br !== null && br > 0) {
+        entry.borderRadius = auditProp(br, _VALID_RADIUS, _reverseRadius, "borderRadius", entry.violations);
+        if (entry.borderRadius) hasAnyProp = true;
+      }
+    }
+    const bwRaw = style.borderTopWidth;
+    const bw = parsePx(bwRaw);
+    if (bw !== null && bw > 0) {
+      entry.borderWidth = auditProp(bw, _VALID_BORDER_WIDTH, _reverseBorderWidth, "borderWidth", entry.violations);
+      if (entry.borderWidth) hasAnyProp = true;
+    }
+    const rowGap = parsePx(style.rowGap);
+    const colGap = parsePx(style.columnGap);
+    if (rowGap !== null && rowGap > 0) {
+      entry.rowGap = auditProp(rowGap, _VALID_GAP, _reverseGap, "rowGap", entry.violations);
+      if (entry.rowGap) hasAnyProp = true;
+    }
+    if (colGap !== null && colGap > 0 && colGap !== rowGap) {
+      entry.columnGap = auditProp(colGap, _VALID_GAP, _reverseGap, "columnGap", entry.violations);
+      if (entry.columnGap) hasAnyProp = true;
+    }
+    if (!(capContainer && ownsInset) && (entry.borderRadius || entry.borderWidth)) {
+      const sides = [["paddingTop", style.paddingTop], ["paddingRight", style.paddingRight], ["paddingBottom", style.paddingBottom], ["paddingLeft", style.paddingLeft]];
+      for (const [prop, raw] of sides) {
+        const val = parsePx(raw);
+        if (val !== null && val > 0) {
+          const result = auditProp(val, _VALID_PADDING, _reversePadding, prop, entry.violations);
+          if (result) {
+            entry[prop] = result;
+            hasAnyProp = true;
+          }
+        }
+      }
+    }
+    const fw = parsePx(style.fontWeight);
+    const weightKnob = el.getAttribute("data-font-weight-knob");
+    if (fw !== null && (fw !== 400 || weightKnob !== null)) {
+      const configuredHeading = (/^H[1-6]$/.test(el.tagName) || el.getAttribute("role") === "heading" || Array.from(el.classList).some(name => /^font_heading(?:Serif|Mono|Slab|Rounded|Condensed|Cursive|Handwriting|Pixel|Blackletter|Geometric)?$/.test(name))) && [600, 700, 800].includes(fw);
+      const configuredLabel = el.tagName === "LABEL" && [500, 700].includes(fw);
+      const expected = weightKnob !== null && ["regular", "bold"].includes(weightKnob) ? _FONT_WEIGHT_KNOB[weightKnob] : void 0;
+      const offScale = weightKnob !== null ? expected === void 0 || fw !== expected : !_VALID_FONT_WEIGHT.has(fw) && !configuredHeading && !configuredLabel;
+      const knob = weightKnob !== null ? `fontWeight:${weightKnob}` : configuredHeading ? "configured heading (@tamagui/config/v5)" : configuredLabel ? "label role (LC-152)" : _reverseFontWeight(fw);
+      entry.fontWeight = {
+        value: fw,
+        unit: "",
+        knob,
+        offScale
+      };
+      if (offScale) entry.violations.push(`fontWeight: ${fw} does not match ${weightKnob !== null ? knob : "a configured typography weight"}`);
+      hasAnyProp = true;
+    }
+    const TEXT_TAGS = /* @__PURE__ */new Set(["h1", "h2", "h3", "h4", "h5", "h6", "p", "span", "a", "button", "input", "textarea", "label", "select", "li", "td", "th", "dt", "dd", "figcaption", "blockquote", "pre", "code"]);
+    if (TEXT_TAGS.has(tag) || el.childNodes.length === 1 && el.childNodes[0].nodeType === 3) {
+      const parentStyle = el.parentElement ? getComputedStyle(el.parentElement) : null;
+      const elFontFamily = style.fontFamily;
+      if (elFontFamily && (!parentStyle || elFontFamily !== parentStyle.fontFamily)) {
+        const ffResult = _reverseFontFamily(elFontFamily);
+        if (ffResult.offScale) {
+          entry.fontFamily = {
+            value: elFontFamily,
+            knob: ffResult.knob,
+            offScale: true
+          };
+          entry.violations.push(`fontFamily: "${elFontFamily.split(",")[0].trim()}" is not a registered font token`);
+          hasAnyProp = true;
+        } else {
+          entry.fontFamily = {
+            value: elFontFamily,
+            knob: ffResult.knob,
+            offScale: false
+          };
+          hasAnyProp = true;
+        }
+      }
+    }
+    const colorBypass = _checkInlineColors(el);
+    if (colorBypass) {
+      entry.inlineColor = {
+        value: `${colorBypass.property}: ${colorBypass.value}`,
+        knob: "off-scale (hardcoded)",
+        offScale: true
+      };
+      entry.violations.push(`inlineColor: ${colorBypass.property}="${colorBypass.value}" bypasses theme tokens`);
+      hasAnyProp = true;
+    }
+    if (hasAnyProp || entry.violations.length > 0) {
+      auditedElements.push(entry);
+      if (entry.violations.length > 0) {
+        violationElements.push(entry);
+      }
+    }
+  }
+  const summary = {
+    totalElements: candidates.length,
+    auditedElements: auditedElements.length,
+    totalViolations: violationElements.length,
+    byProperty: {
+      borderRadius: violationElements.filter(e => e.borderRadius?.offScale).length,
+      borderWidth: violationElements.filter(e => e.borderWidth?.offScale).length,
+      gap: violationElements.filter(e => e.rowGap?.offScale || e.columnGap?.offScale).length,
+      padding: violationElements.filter(e => e.paddingTop?.offScale || e.paddingRight?.offScale || e.paddingBottom?.offScale || e.paddingLeft?.offScale).length,
+      fontWeight: violationElements.filter(e => e.fontWeight?.offScale).length,
+      fontFamily: violationElements.filter(e => e.fontFamily?.offScale).length,
+      inlineColor: violationElements.filter(e => e.inlineColor?.offScale).length
+    }
+  };
+  return {
+    url: window.location.href,
+    timestamp: (/* @__PURE__ */new Date()).toISOString(),
+    preset: readPreset(),
+    scheme: readScheme(),
+    summary,
+    violations: violationElements,
+    elements: auditedElements
+  };
+}