stimeo-ui 0.15.0 → 0.17.0

package/dist/inspector/cli.js

@@ -3,9 +3,6 @@ import { relative, join, dirname, extname } from 'path';
 import process from 'process';
 import { fileURLToPath } from 'url';
 
-// src/inspector/cli.ts
-
-// src/inspector/announcer_rules.ts
 var ANNOUNCER_IDENTIFIER = "stimeo--announcer";
 var ANNOUNCING_CONTROLLERS = [
   "stimeo--auto-submit",
@@ -69,7 +66,30 @@ function announcerSeatingDiagnostic(sources) {
   };
 }
 
-// src/utils/declared_value.ts
+function matchesNumberBounds(value, bounds) {
+  if (!Number.isFinite(value)) {
+    const direction = value === Infinity ? "positive" : value === -Infinity ? "negative" : null;
+    if (direction === null) return false;
+    if (bounds.allowInfinity !== "both" && bounds.allowInfinity !== direction) return false;
+  }
+  if (bounds.min !== void 0 && value < bounds.min) return false;
+  if (bounds.max !== void 0 && value > bounds.max) return false;
+  if (bounds.exclusiveMin !== void 0 && value <= bounds.exclusiveMin) return false;
+  if (bounds.integer && !Number.isInteger(value)) return false;
+  if (bounds.allowedValues !== void 0 && !bounds.allowedValues.includes(value)) return false;
+  return true;
+}
+function decodeNumberValue(raw) {
+  return Number(raw.replace(/_/g, ""));
+}
+
+function toFiniteNumber(raw) {
+  if (typeof raw !== "number" && typeof raw !== "string") return null;
+  if (typeof raw === "string" && raw.trim().length === 0) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : null;
+}
+
 function parseDeclared(raw, parse, fallback) {
   try {
     return parse(raw);
@@ -93,7 +113,6 @@ function parseJsonObject(raw) {
   return parsed;
 }
 
-// src/inspector/html_parser.ts
 var ERB_ELEMENT_TAG = "#erb";
 var VOID_ELEMENTS = /* @__PURE__ */ new Set([
   "area",
@@ -342,7 +361,6 @@ function walk(root, visit) {
   }
 }
 
-// src/inspector/ruby_scan.ts
 var SPACE = /* @__PURE__ */ new Set([" ", "	", "\n", "\r", "\f"]);
 var IDENT_START = /[A-Za-z_]/;
 var IDENT_CHAR = /[A-Za-z0-9_]/;
@@ -581,7 +599,6 @@ function heredocEnd(code, bodyStart, identifier) {
   return code.length;
 }
 
-// src/inspector/ruby_hash.ts
 function readDataOption(source, base) {
   const code = maskHeredocs(source);
   const attrs = [];
@@ -786,7 +803,6 @@ function skipValue(code, start) {
   return code.length;
 }
 
-// src/inspector/erb.ts
 var ERB_TAG = /<%[\s\S]*?%>/g;
 function neutralizeErb(source) {
   return source.replace(ERB_TAG, (match) => match.replace(/[^\n]/g, " "));
@@ -810,7 +826,6 @@ function erbElements(source) {
       tag: ERB_ELEMENT_TAG,
       attrs: option.attrs.map((attr) => toParsedAttr(attr, index)),
       start: tag.start,
-      // The token a reader can act on is the delimiter that opens the call.
       sourceLength: tag.codeStart - tag.start,
       end,
       container: end > tag.end,
@@ -849,7 +864,6 @@ function readErbTags(source) {
     }
     let close = raw.length - 2;
     if (raw[close - 1] === "-") close--;
-    if (close < open) close = open;
     tags.push({
       start,
       end: start + raw.length,
@@ -975,17 +989,28 @@ function identifierEnd(code, start) {
   return end;
 }
 
-// src/inspector/extract.ts
 var NAMESPACE_PREFIX = "stimeo--";
 function dasherize(value) {
   return value.replace(/([A-Z])/g, (_match, char) => `-${char.toLowerCase()}`);
 }
-function controllerIdentifiers(dataControllerValue) {
+function attributeTokens(value) {
+  const tokens = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const token of dataControllerValue.split(/\s+/)) {
-    if (token.startsWith(NAMESPACE_PREFIX)) seen.add(token);
+  const pattern = /\S+/g;
+  for (let match = pattern.exec(value); match; match = pattern.exec(value)) {
+    if (seen.has(match[0])) continue;
+    seen.add(match[0]);
+    tokens.push({ name: match[0], start: match.index });
   }
-  return [...seen];
+  return tokens;
+}
+function controllerIdentifiers(dataControllerValue) {
+  return controllerIdentifierTokens(dataControllerValue).map((token) => token.name);
+}
+function controllerIdentifierTokens(dataControllerValue) {
+  return attributeTokens(dataControllerValue).filter(
+    (token) => token.name.startsWith(NAMESPACE_PREFIX)
+  );
 }
 function parseTargetAttr(attrName) {
   const match = /^data-(stimeo--[a-z0-9][a-z0-9-]*)-target$/.exec(attrName);
@@ -1027,7 +1052,7 @@ function defaultEventFor(host) {
 }
 function actionDescriptors(dataActionValue, host) {
   const descriptors = [];
-  for (const descriptor of dataActionValue.split(/\s+/)) {
+  for (const { name: descriptor, start } of attributeTokens(dataActionValue)) {
     const hash = descriptor.indexOf("#");
     if (hash === -1) continue;
     let lhs = descriptor.slice(0, hash);
@@ -1043,7 +1068,14 @@ function actionDescriptors(dataActionValue, host) {
     }
     if (!lhs.startsWith(NAMESPACE_PREFIX)) continue;
     const method = /^[a-zA-Z_$][\w$]*/.exec(descriptor.slice(hash + 1))?.[0] ?? "";
-    descriptors.push({ identifier: lhs, method, eventType });
+    descriptors.push({
+      identifier: lhs,
+      identifierStart: start + (arrow === -1 ? 0 : arrow + 2),
+      method,
+      methodStart: start + hash + 1,
+      eventType,
+      eventStart: start
+    });
   }
   return descriptors;
 }
@@ -1051,7 +1083,6 @@ function isStimeoDataAttr(attrName) {
   return attrName.startsWith(`data-${NAMESPACE_PREFIX}`);
 }
 
-// src/inspector/types.ts
 var DIAGNOSTIC_CODES = [
   "unknown-controller",
   "unknown-target",
@@ -1059,9 +1090,11 @@ var DIAGNOSTIC_CODES = [
   "invalid-value",
   "unknown-action-controller",
   "unknown-action-method",
+  "unknown-action-event",
   "orphan-target",
   "missing-required-target",
   "missing-conditional-target",
+  "invalid-template-root",
   "missing-required-action",
   "missing-action-completion",
   "missing-action-event",
@@ -1077,11 +1110,13 @@ var DIAGNOSTIC_CODES = [
   "cardinality-violation",
   "forbidden-aria",
   "missing-announcer",
+  "missing-action-param",
+  "invalid-action-param",
+  "confusable-action-param",
   "unknown-ignore-code"
 ];
 
-// src/inspector/check.ts
-function isInside(node, ancestor) {
+function isDescendantOf(node, ancestor) {
   for (let current = node.parent; current; current = current.parent) {
     if (current === ancestor) return true;
   }
@@ -1174,11 +1209,13 @@ function checkSource(source, manifest) {
   const unnamedTargets = [];
   const targetsUnreadable = (container, scope, identifier) => {
     for (const node of unresolved) {
-      if (isWithin(node, container) && findOwner(node, identifier) === scope) return true;
+      if (isSelfOrDescendantOf(node, container) && findOwner(node, identifier) === scope)
+        return true;
     }
     for (const { node, identifier: hidden } of unnamedTargets) {
       if (hidden !== identifier) continue;
-      if (isWithin(node, container) && findOwner(node, identifier) === scope) return true;
+      if (isSelfOrDescendantOf(node, container) && findOwner(node, identifier) === scope)
+        return true;
     }
     return false;
   };
@@ -1237,7 +1274,7 @@ function checkSource(source, manifest) {
     const nodes = targetNodes.get(scope)?.get(identifier)?.get(condition.target) ?? [];
     const container = condition.within === "scope" ? scope : element;
     let held = 0;
-    for (const node of nodes) if (isWithin(node, container)) held += 1;
+    for (const node of nodes) if (isSelfOrDescendantOf(node, container)) held += 1;
     if (condition.min !== void 0 && held < condition.min) return false;
     if (condition.max !== void 0 && held > condition.max) return false;
     return true;
@@ -1274,9 +1311,9 @@ function checkSource(source, manifest) {
     const authoredValueIdentifiers = /* @__PURE__ */ new Set();
     for (const attr of node.attrs) {
       if (attr.name === IGNORE_ATTR) {
-        for (const token of attr.value.split(/\s+/).filter((t) => t.length > 0)) {
-          if (!DIAGNOSTIC_CODES.includes(token)) {
-            const best = nearestName(token, DIAGNOSTIC_CODES);
+        for (const token of attributeTokens(attr.value)) {
+          if (!DIAGNOSTIC_CODES.includes(token.name)) {
+            const best = nearestName(token.name, DIAGNOSTIC_CODES);
             push(
               diagnostics,
               "unknown-ignore-code",
@@ -1291,7 +1328,7 @@ function checkSource(source, manifest) {
         continue;
       }
       if (attr.name === FRAGMENT_ATTR) {
-        const identifiers = attr.value.split(/\s+/).filter((token) => token.length > 0);
+        const identifiers = attributeTokens(attr.value);
         if (identifiers.length === 0) {
           report(
             node,
@@ -1302,13 +1339,13 @@ function checkSource(source, manifest) {
           );
         }
         for (const identifier of identifiers) {
-          if (!(identifier in known)) {
-            const best = nearestName(identifier, knownIdentifiers);
+          if (!(identifier.name in known)) {
+            const best = nearestName(identifier.name, knownIdentifiers);
             report(
               node,
               "unknown-controller",
               "error",
-              `Fragment declaration references unknown Stimeo controller "${identifier}".`,
+              `Fragment declaration references unknown Stimeo controller "${identifier.name}".`,
               attr,
               asDidYouMean(best),
               tokenFix(attr, identifier, best)
@@ -1318,7 +1355,8 @@ function checkSource(source, manifest) {
         continue;
       }
       if (attr.name === "data-controller") {
-        for (const identifier of controllerIdentifiers(attr.value)) {
+        for (const token of controllerIdentifierTokens(attr.value)) {
+          const identifier = token.name;
           if (identifier in known) {
             scopes.push({ node, identifier });
           } else {
@@ -1330,7 +1368,7 @@ function checkSource(source, manifest) {
               `Unknown Stimeo controller "${identifier}".`,
               attr,
               asDidYouMean(best),
-              tokenFix(attr, identifier, best)
+              tokenFix(attr, token, best)
             );
           }
         }
@@ -1350,24 +1388,27 @@ function checkSource(source, manifest) {
           );
           continue;
         }
-        const targetName = isDynamicValue(attr) ? "" : attr.value.trim();
-        if (targetName.length > 0 && !controller.targets.includes(targetName)) {
-          const best = nearestName(targetName, controller.targets);
+        const declared = isDynamicValue(attr) ? [] : attributeTokens(attr.value);
+        for (const token of declared) {
+          if (controller.targets.includes(token.name)) continue;
+          const best = nearestName(token.name, controller.targets);
           report(
             node,
             "unknown-target",
             "error",
-            `Unknown target "${targetName}" for "${targetIdentifier}". Known targets: ${list(controller.targets)}.`,
+            `Unknown target "${token.name}" for "${targetIdentifier}". Known targets: ${list(controller.targets)}.`,
             attr,
             asDidYouMean(best),
-            tokenFix(attr, targetName, best)
+            tokenFix(attr, token, best)
           );
         }
         const owner = findOwner(node, targetIdentifier);
         if (owner) {
-          if (targetName.length > 0) {
-            recordPresence(owner, targetIdentifier, targetName);
-            recordTargetNode(owner, targetIdentifier, targetName, node);
+          if (declared.length > 0) {
+            for (const token of declared) {
+              recordPresence(owner, targetIdentifier, token.name);
+              recordTargetNode(owner, targetIdentifier, token.name, node);
+            }
           } else if (isDynamicValue(attr)) {
             unnamedTargets.push({ node, identifier: targetIdentifier });
           }
@@ -1431,7 +1472,15 @@ function checkSource(source, manifest) {
           tag: node.tag,
           inputType: node.attrs.find((a) => a.name === "type")?.value
         };
-        for (const { identifier, method, eventType } of actionDescriptors(attr.value, host)) {
+        const paramsChecked = /* @__PURE__ */ new Set();
+        for (const {
+          identifier,
+          identifierStart,
+          method,
+          methodStart,
+          eventType,
+          eventStart
+        } of actionDescriptors(attr.value, host)) {
           const controller = known[identifier];
           if (controller && method.length > 0) {
             const owner = findOwner(node, identifier);
@@ -1456,7 +1505,7 @@ function checkSource(source, manifest) {
               `Action references unknown Stimeo controller "${identifier}".`,
               attr,
               asDidYouMean(best),
-              tokenFix(attr, identifier, best)
+              tokenFix(attr, { name: identifier, start: identifierStart }, best)
             );
           } else if (method.length > 0 && !controller.actions.includes(method)) {
             const best = nearestName(method, controller.actions);
@@ -1467,11 +1516,138 @@ function checkSource(source, manifest) {
               `Unknown action "${method}" for "${identifier}". Known actions: ${list(controller.actions)}.`,
               attr,
               asDidYouMean(best),
-              tokenFix(attr, method, best)
+              tokenFix(attr, { name: method, start: methodStart }, best)
+            );
+          }
+          if (controller && method.length > 0 && !paramsChecked.has(`${identifier}#${method}`)) {
+            paramsChecked.add(`${identifier}#${method}`);
+            checkActionParams(node, attr, identifier, method, controller);
+          }
+          if (!isDynamicValue(attr)) {
+            const emitted = /^(stimeo--[a-z0-9-]+):(.+)$/.exec(eventType);
+            const source2 = emitted ? known[emitted[1]] : void 0;
+            const name = emitted?.[2];
+            if (source2 && name !== void 0 && !source2.events.includes(name)) {
+              const best = nearestName(name, source2.events);
+              report(
+                node,
+                "unknown-action-event",
+                "error",
+                `Unknown event "${name}" for "${emitted?.[1]}". Known events: ${list(source2.events)}.`,
+                attr,
+                asDidYouMean(best),
+                tokenFix(attr, { name, start: eventStart + eventType.length - name.length }, best)
+              );
+            }
+          }
+        }
+      }
+    }
+    function checkActionParams(element, action, identifier, method, controller) {
+      const rules = controller.actionParams.filter((rule) => rule.action === method);
+      if (rules.length === 0) return;
+      const readable = !isDynamicValue(action) && element.origin === "markup" && !element.opaque;
+      const expected = new Map(
+        rules.map((rule) => [`data-${identifier}-${dasherize(rule.param)}-param`, rule])
+      );
+      for (const [attrName, rule] of expected) {
+        const written = element.attrs.find((candidate) => candidate.name === attrName);
+        if (!written) {
+          if (!rule.required || !readable) continue;
+          const confusable = confusableParamAttr(element, attrName, rule.param);
+          report(
+            element,
+            "missing-action-param",
+            "error",
+            confusable ? `"${identifier}#${method}" reads its "${rule.param}" param, and "${confusable.name}" is not the attribute Stimulus builds it from.` : `"${identifier}#${method}" reads its "${rule.param}" param, which nothing on this element supplies.`,
+            confusable ?? action,
+            rule.suggestion
+          );
+          continue;
+        }
+        if (isDynamicValue(written)) continue;
+        const value = written.value;
+        if (value.length === 0) {
+          if (!readable) continue;
+          if (rule.numeric && !rule.required) {
+            report(
+              element,
+              "invalid-action-param",
+              "error",
+              `"${value}" is not a finite "${rule.param}" this action reads.`,
+              written,
+              rule.suggestion
+            );
+            continue;
+          }
+          if (!rule.required) continue;
+          report(
+            element,
+            "missing-action-param",
+            "error",
+            `"${identifier}#${method}" reads its "${rule.param}" param, and "${attrName}" carries no value.`,
+            written,
+            rule.suggestion
+          );
+          continue;
+        }
+        if (rule.numeric || rule.integer) {
+          const numeric = toFiniteNumber(decodeActionParamLiteral(value));
+          if (numeric === null || rule.integer && !Number.isInteger(numeric)) {
+            report(
+              element,
+              "invalid-action-param",
+              "error",
+              `"${value}" is not an "${rule.param}" this action reads. It accepts ${rule.integer ? "a whole number" : "a finite number"}.`,
+              written,
+              rule.suggestion
             );
+            continue;
           }
         }
+        if (!rule.allowedValues || rule.allowedValues.includes(value)) continue;
+        const best = nearestName(value, rule.allowedValues);
+        report(
+          element,
+          "invalid-action-param",
+          "error",
+          `"${value}" is not a "${rule.param}" this action reads. It accepts ${list(rule.allowedValues)}.`,
+          written,
+          asDidYouMean(best) ?? rule.suggestion,
+          best !== void 0 && written.valueStart !== void 0 ? {
+            start: written.valueStart,
+            end: written.valueStart + written.value.length,
+            text: best,
+            title: `Replace with "${best}"`
+          } : void 0
+        );
       }
+      if (!readable) return;
+      for (const candidate of element.attrs) {
+        if (!candidate.name.startsWith(`data-${identifier}-`)) continue;
+        if (expected.has(candidate.name)) continue;
+        if (parseTargetAttr(candidate.name) || candidate.name.endsWith("-value")) continue;
+        const best = [...expected.keys()].find((name) => namesTheParam(candidate.name, name));
+        if (best === void 0) continue;
+        report(
+          element,
+          "confusable-action-param",
+          "warning",
+          `"${candidate.name}" is not an attribute Stimulus reads. Action params are named "<param>-param".`,
+          candidate,
+          `Did you mean ${best}?`
+        );
+      }
+    }
+    function namesTheParam(written, attrName) {
+      if (written === attrName) return false;
+      return `${written}-param` === attrName || nearestName(written, [attrName]) !== void 0;
+    }
+    function confusableParamAttr(element, attrName, param) {
+      const bare = `data-${dasherize(param)}`;
+      return element.attrs.find(
+        (candidate) => candidate.name === bare || namesTheParam(candidate.name, attrName)
+      );
     }
     for (const identifier of authoredValueIdentifiers) {
       const controller = known[identifier];
@@ -1532,19 +1708,30 @@ function checkSource(source, manifest) {
       const owners = nodesOf(rule.whenPresent);
       const hosts = rule.requireSameHost;
       const sharesHost = (target, selectors) => {
-        const ownerHosts = owners.map((owner) => nearestHost(owner, selectors));
-        if (ownerHosts.some((host) => !host)) return true;
+        const hostOf = (el) => nearestHost(el, selectors);
+        const ownerHosts = owners.map(hostOf).filter((host) => host !== null && host !== void 0);
         const candidates = nodesOf(target);
-        if (candidates.length === 0) return false;
-        return candidates.some((el) => {
-          const host = nearestHost(el, selectors);
-          return host ? ownerHosts.includes(host) : true;
-        });
+        return ownerHosts.every(
+          (ownerHost) => candidates.some((el) => {
+            const host = hostOf(el);
+            if (host === null) return false;
+            return host ? host === ownerHost : true;
+          })
+        );
+      };
+      const sharesTargetHost = (target, hostTarget) => {
+        const hostNodes = nodesOf(hostTarget);
+        const hostOf = (el) => hostNodes.find((host) => isDescendantOf(el, host)) ?? null;
+        const ownerHosts = owners.map(hostOf).filter((host) => host !== null);
+        const candidates = nodesOf(target);
+        return ownerHosts.every((ownerHost) => candidates.some((el) => hostOf(el) === ownerHost));
       };
       const satisfied = (target) => {
+        const hostTarget = rule.requireSameTargetHost;
+        if (hostTarget) return sharesTargetHost(target, hostTarget);
         if (hosts) return sharesHost(target, hosts);
         if (rule.requireInside)
-          return nodesOf(target).some((el) => owners.some((owner) => isInside(el, owner)));
+          return nodesOf(target).some((el) => owners.some((owner) => isDescendantOf(el, owner)));
         return present.has(target);
       };
       const missing = rule.require.filter((target) => !satisfied(target));
@@ -1553,12 +1740,62 @@ function checkSource(source, manifest) {
         node,
         "missing-conditional-target",
         complete ? "error" : "warning",
-        hosts ? `"${identifier}" requires ${list(missing)} in the same ${rule.hostLabel ?? "element"} as its "${rule.whenPresent}".` : rule.requireInside ? `"${identifier}" requires ${list(missing)} inside its "${rule.whenPresent}".` : `"${identifier}" has a "${rule.whenPresent}" target, which also requires ${list(missing)}.`,
+        rule.requireSameTargetHost ? `"${identifier}" requires ${list(missing)} in the same "${rule.requireSameTargetHost}" as its "${rule.whenPresent}".` : hosts ? `"${identifier}" requires ${list(missing)} in the same ${rule.hostLabel ?? "element"} as its "${rule.whenPresent}".` : rule.requireInside ? `"${identifier}" requires ${list(missing)} inside its "${rule.whenPresent}".` : `"${identifier}" has a "${rule.whenPresent}" target, which also requires ${list(missing)}.`,
         node,
         complete ? rule.suggestion : UNRESOLVED_TARGET_HINT
       );
     }
   }
+  for (const { node, identifier } of scopes) {
+    const controller = known[identifier];
+    if (!controller) continue;
+    const complete = scopeIsComplete(node, node, identifier);
+    const nodesOf = (target) => targetNodes.get(node)?.get(identifier)?.get(target) ?? [];
+    const hint = complete ? void 0 : UNRESOLVED_TARGET_HINT;
+    for (const rule of controller.templateRoots) {
+      for (const template of nodesOf(rule.template)) {
+        if (template.origin === "markup" && template.tag !== "template") {
+          report(
+            node,
+            "invalid-template-root",
+            complete ? "error" : "warning",
+            `"${identifier}" requires its "${rule.template}" to be a <template>, and it is a <${template.tag}>.`,
+            template,
+            hint ?? rule.suggestion
+          );
+          continue;
+        }
+        if (template.children.some((child) => child.origin === "erb")) continue;
+        const rows = template.children;
+        const row = rows[0];
+        if (rows.length === 0) continue;
+        if (rows.length !== 1 || !row) {
+          report(
+            node,
+            "invalid-template-root",
+            complete ? "error" : "warning",
+            `"${identifier}" requires its "${rule.template}" to hold exactly one element, and it holds ${rows.length}.`,
+            template,
+            hint ?? rule.suggestion
+          );
+          continue;
+        }
+        if (!rule.rootTarget) continue;
+        if (unnamedTargets.some((entry) => entry.node === row && entry.identifier === identifier)) {
+          continue;
+        }
+        if (nodesOf(rule.rootTarget).includes(row)) continue;
+        report(
+          node,
+          "invalid-template-root",
+          complete ? "error" : "warning",
+          `"${identifier}" requires the one element in its "${rule.template}" to be its "${rule.rootTarget}" itself.`,
+          row,
+          hint ?? rule.suggestion
+        );
+      }
+    }
+  }
   for (const { node, identifier } of scopes) {
     const controller = known[identifier];
     if (!controller) continue;
@@ -1658,8 +1895,9 @@ function checkSource(source, manifest) {
       for (const element of elements) {
         if (!hasReadableMarkup(element)) continue;
         if (hostIsAllowed(element, rule) !== false) continue;
-        const type = element.attrs.find((attr) => attr.name === "type");
-        const detail = element.tag === "button" ? `the unsupported ${type ? `type="${type.value}"` : 'implicit type="submit"'}` : `an unsupported interactive <${element.tag}>`;
+        const byType = element.tag === "button" && rule.mode !== "non-interactive";
+        const type = byType ? element.attrs.find((attr) => attr.name === "type") : void 0;
+        const detail = byType ? `the unsupported ${type ? `type="${type.value}"` : 'implicit type="submit"'}` : `an unsupported interactive <${element.tag}>`;
         report(
           element,
           "invalid-host",
@@ -1784,8 +2022,6 @@ function checkSource(source, manifest) {
           `The ${where} of "${identifier}" must also declare "${rule.controller}" in data-controller.`,
           declared ?? el,
           rule.suggestion,
-          // Appending to an existing list is unambiguous; creating the
-          // attribute from nothing is an insertion the anchor cannot express.
           declared ? valueFix(
             declared,
             `${declared.value.trim()} ${rule.controller}`.trim(),
@@ -1809,7 +2045,7 @@ function checkSource(source, manifest) {
         if (rule.values && !rule.values.includes(value)) continue;
         if (findOwner(el, identifier) !== node) continue;
         const declaredAs = el.attrs.find((a) => a.name === targetAttrName);
-        if (declaredAs && !isDynamicValue(declaredAs) && declaredAs.value.trim() === rule.target) {
+        if (declaredAs && !isDynamicValue(declaredAs) && attributeTokens(declaredAs.value).some((token) => token.name === rule.target)) {
           continue;
         }
         if (declaredAs && isDynamicValue(declaredAs)) continue;
@@ -1837,7 +2073,7 @@ function checkSource(source, manifest) {
       for (const container of containers) {
         const matched = [];
         for (const el of counted) {
-          if (!isWithin(el, container)) continue;
+          if (!isSelfOrDescendantOf(el, container)) continue;
           if (rule.attr === void 0) {
             matched.push({ el, at: el });
             continue;
@@ -1893,14 +2129,14 @@ function checkSource(source, manifest) {
   for (const el of anchored) {
     for (const attr of el.attrs) {
       if (!IDREF_ATTRS.has(attr.name) || isDynamicValue(attr)) continue;
-      for (const token of attr.value.split(/\s+/).filter((t) => t.length > 0)) {
-        if (!ids.has(token)) {
-          const best = nearestName(token, [...ids]);
+      for (const token of attributeTokens(attr.value)) {
+        if (!ids.has(token.name)) {
+          const best = nearestName(token.name, [...ids]);
           report(
             el,
             "unresolved-idref",
             "warning",
-            `${attr.name} references id "${token}", but no element in this file declares it.`,
+            `${attr.name} references id "${token.name}", but no element in this file declares it.`,
             attr,
             asDidYouMean(best),
             tokenFix(attr, token, best)
@@ -1920,14 +2156,20 @@ function declaredConstraint(controller, valueToken) {
 function valueSatisfiesConstraint(raw, constraint) {
   if (constraint.type === "string") return stringValueSatisfies(raw, constraint);
   const value = decodeNumericValue(raw);
-  if (Number.isNaN(value)) return false;
-  if (constraint.finite && !Number.isFinite(value)) return false;
+  if (constraint.finite === true && !matchesNumberBounds(value, { ...constraint}))
+    return false;
+  if (constraint.finite !== true) {
+    const bounds = {
+      ...constraint,
+      allowInfinity: constraint.allowInfinity ?? "both"
+    };
+    if (!matchesNumberBounds(value, bounds)) return false;
+  }
   if (constraint.greaterThan !== void 0 && !(value > constraint.greaterThan)) return false;
-  if (constraint.integer && !Number.isInteger(value)) return false;
   return true;
 }
 function decodeNumericValue(raw) {
-  return Number(raw.replace(/_/g, ""));
+  return decodeNumberValue(raw);
 }
 function stringValueSatisfies(raw, constraint) {
   if (!("syntax" in constraint)) return constraint.allowedValues.includes(raw);
@@ -1941,10 +2183,15 @@ function stringValueSatisfies(raw, constraint) {
 }
 function describeValueConstraint(constraint) {
   if (constraint.type === "string") return describeStringConstraint(constraint);
-  const parts = [constraint.finite ? "a finite number" : "a number"];
+  const parts = [constraint.finite || constraint.allowInfinity ? "a finite number" : "a number"];
   if (constraint.greaterThan !== void 0) {
     parts.push(`greater than ${constraint.greaterThan}`);
   }
+  if (constraint.exclusiveMin !== void 0) parts.push(`greater than ${constraint.exclusiveMin}`);
+  if (constraint.min !== void 0) parts.push(`at least ${constraint.min}`);
+  if (constraint.max !== void 0) parts.push(`at most ${constraint.max}`);
+  if (constraint.allowedValues) parts.push(`among ${constraint.allowedValues.join(", ")}`);
+  if (constraint.allowInfinity) parts.push(`or ${constraint.allowInfinity} infinity`);
   if (constraint.integer) parts.push("with no fractional part");
   return parts.join(" ");
 }
@@ -2016,7 +2263,7 @@ function checkA11y(report, el, identifier, req, severity, isDynamicValue) {
     );
   }
 }
-function isWithin(node, container) {
+function isSelfOrDescendantOf(node, container) {
   let current = node;
   while (current) {
     if (current === container) return true;
@@ -2121,15 +2368,13 @@ function push(out, code, severity, message, at, suggestion, fix) {
   });
 }
 function tokenFix(attr, token, replacement) {
-  if (replacement === void 0 || attr.valueStart === void 0 || token.length === 0) {
+  if (replacement === void 0 || attr.valueStart === void 0 || token.name.length === 0) {
     return void 0;
   }
-  const index = attr.value.indexOf(token);
-  if (index < 0) return void 0;
-  const start = attr.valueStart + index;
+  const start = attr.valueStart + token.start;
   return {
     start,
-    end: start + token.length,
+    end: start + token.name.length,
     text: replacement,
     title: `Replace with "${replacement}"`
   };
@@ -2142,7 +2387,7 @@ function list(names) {
   return names.length > 0 ? names.map((n) => `"${n}"`).join(", ") : "(none)";
 }
 function describeAttrs(attrs) {
-  return attrs.length === 1 ? attrs[0] : attrs.join(" or ");
+  return attrs.join(" or ");
 }
 function nearestName(name, candidates) {
   if (name.length === 0) return void 0;
@@ -2184,8 +2429,14 @@ function levenshtein(a, b) {
   }
   return prev[cols];
 }
+function decodeActionParamLiteral(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
 
-// src/inspector/examples.ts
 var EXAMPLES_SCHEMA_VERSION = 1;
 var CHECKABLE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".erb", ".html", ".htm"]);
 function isCheckableFile(path) {
@@ -2196,10 +2447,12 @@ var CONTROLLER_ARRAY_FIELDS = [
   "values",
   "valueConstraints",
   "valueRelations",
+  "actionParams",
   "actions",
   "events",
   "requiredTargets",
   "conditionalTargets",
+  "templateRoots",
   "requiredActions",
   "actionCompletion",
   "a11y",
@@ -2227,6 +2480,21 @@ function isCompatibleManifest(value) {
     for (const field of CONTROLLER_ARRAY_FIELDS) {
       if (!Array.isArray(entry[field])) return false;
     }
+    const constraints = entry.valueConstraints;
+    for (const constraint of constraints) {
+      if (typeof constraint !== "object" || constraint === null) return false;
+      const numeric = constraint;
+      if (numeric.type !== "number") continue;
+      for (const field of ["min", "max", "exclusiveMin"]) {
+        const bound = numeric[field];
+        if (bound !== void 0 && (typeof bound !== "number" || !Number.isFinite(bound)))
+          return false;
+      }
+      if (numeric.allowedValues !== void 0 && (!Array.isArray(numeric.allowedValues) || !numeric.allowedValues.every((item) => typeof item === "number" && Number.isFinite(item))))
+        return false;
+      if (numeric.allowInfinity !== void 0 && !["negative", "positive", "both"].includes(String(numeric.allowInfinity)))
+        return false;
+    }
   }
   return true;
 }
@@ -2238,7 +2506,6 @@ function readManifestFile(path) {
   return parsed;
 }
 
-// src/inspector/cli.ts
 function bundledPath(name) {
   return join(dirname(fileURLToPath(import.meta.url)), name);
 }
@@ -2441,5 +2708,4 @@ ${USAGE}`);
 }
 
 export { buildCheckReport, catalogSummary, formatGithubAnnotation, loadExamplesIndex, loadManifest, runCli, sortedControllerEntries };
-//# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map