stimeo-ui 0.3.0 → 0.5.0

package/dist/inspector/cli.js

@@ -5,66 +5,8 @@ import { fileURLToPath } from 'url';
 
 // src/inspector/cli.ts
 
-// src/inspector/erb.ts
-function neutralizeErb(source) {
-  return source.replace(/<%[\s\S]*?%>/g, (match) => match.replace(/[^\n]/g, " "));
-}
-
-// src/inspector/extract.ts
-var NAMESPACE_PREFIX = "stimeo--";
-function dasherize(value) {
-  return value.replace(/([A-Z])/g, (_match, char) => `-${char.toLowerCase()}`);
-}
-function controllerIdentifiers(dataControllerValue) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const token of dataControllerValue.split(/\s+/)) {
-    if (token.startsWith(NAMESPACE_PREFIX)) seen.add(token);
-  }
-  return [...seen];
-}
-function parseTargetAttr(attrName) {
-  const match = /^data-(stimeo--[a-z0-9][a-z0-9-]*)-target$/.exec(attrName);
-  return match?.[1] ?? null;
-}
-function parseValueAttr(attrName, knownIdentifiers) {
-  const match = /^data-(stimeo--[a-z0-9-]+)-value$/.exec(attrName);
-  if (!match) return null;
-  const inner = match[1] ?? "";
-  let best = null;
-  for (const id of knownIdentifiers) {
-    if (inner.startsWith(`${id}-`)) {
-      const valueToken = inner.slice(id.length + 1);
-      if (valueToken.length > 0 && (!best || id.length > best.identifier.length)) {
-        best = { identifier: id, valueToken };
-      }
-    }
-  }
-  if (best) return best;
-  const rest = inner.slice(NAMESPACE_PREFIX.length);
-  const dash = rest.indexOf("-");
-  const identifierGuess = dash === -1 ? inner : `${NAMESPACE_PREFIX}${rest.slice(0, dash)}`;
-  const valueGuess = dash === -1 ? "" : rest.slice(dash + 1);
-  return { identifier: null, valueToken: valueGuess || identifierGuess };
-}
-function actionDescriptors(dataActionValue) {
-  const descriptors = [];
-  for (const descriptor of dataActionValue.split(/\s+/)) {
-    const hash = descriptor.indexOf("#");
-    if (hash === -1) continue;
-    let lhs = descriptor.slice(0, hash);
-    const arrow = lhs.indexOf("->");
-    if (arrow !== -1) lhs = lhs.slice(arrow + 2);
-    if (!lhs.startsWith(NAMESPACE_PREFIX)) continue;
-    const method = /^[a-zA-Z_$][\w$]*/.exec(descriptor.slice(hash + 1))?.[0] ?? "";
-    descriptors.push({ identifier: lhs, method });
-  }
-  return descriptors;
-}
-function isStimeoDataAttr(attrName) {
-  return attrName.startsWith(`data-${NAMESPACE_PREFIX}`);
-}
-
 // src/inspector/html_parser.ts
+var ERB_ELEMENT_TAG = "#erb";
 var VOID_ELEMENTS = /* @__PURE__ */ new Set([
   "area",
   "base",
@@ -101,7 +43,7 @@ var PositionIndex = class {
     return { line: lo + 1, column: offset - (this.#lineStarts[lo] ?? 0) + 1 };
   }
 };
-function parseHtml(source) {
+function parseHtml(source, synthetics = []) {
   const pos = new PositionIndex(source);
   const len = source.length;
   const ch = (k) => k >= 0 && k < len ? source[k] : "";
@@ -111,12 +53,57 @@ function parseHtml(source) {
     children: [],
     parent: null,
     line: 1,
-    column: 1
+    column: 1,
+    origin: "markup",
+    opaque: false
   };
   const stack = [root];
   let i = 0;
   const top = () => stack[stack.length - 1];
+  let pending = 0;
+  const closesAt = /* @__PURE__ */ new Map();
+  const takeSynthetics = (offset, splice) => {
+    while (pending < synthetics.length) {
+      const synthetic = synthetics[pending];
+      if (synthetic.start > offset) return;
+      pending++;
+      if (!splice) continue;
+      const at = pos.at(synthetic.start);
+      const node = {
+        tag: synthetic.tag,
+        attrs: synthetic.attrs,
+        children: [],
+        parent: top(),
+        line: at.line,
+        column: at.column,
+        sourceLength: synthetic.sourceLength,
+        origin: "erb",
+        opaque: synthetic.opaque
+      };
+      top().children.push(node);
+      if (synthetic.container) {
+        closesAt.set(node, synthetic.end);
+        stack.push(node);
+      }
+    }
+  };
+  const closeSynthetics = (offset) => {
+    for (; ; ) {
+      let expired = -1;
+      for (let depth = stack.length - 1; depth >= 1; depth--) {
+        const end = closesAt.get(stack[depth]);
+        if (end !== void 0 && end <= offset) {
+          expired = depth;
+          break;
+        }
+      }
+      if (expired < 0) return;
+      stack.length = expired;
+    }
+  };
   while (i < len) {
+    closeSynthetics(i);
+    takeSynthetics(i, true);
     if (ch(i) !== "<") {
       i++;
       continue;
@@ -125,11 +112,13 @@ function parseHtml(source) {
     if (source.startsWith("<!--", i)) {
       const end = source.indexOf("-->", i + 4);
       i = end === -1 ? len : end + 3;
+      takeSynthetics(i - 1, false);
       continue;
     }
     if (next === "!" || next === "?") {
       const end = source.indexOf(">", i);
       i = end === -1 ? len : end + 1;
+      takeSynthetics(i - 1, false);
       continue;
     }
     if (next === "/") {
@@ -141,6 +130,7 @@ function parseHtml(source) {
       }
       const end = source.indexOf(">", j2);
       i = end === -1 ? len : end + 1;
+      takeSynthetics(i - 1, false);
       closeTag(stack, name.toLowerCase());
       continue;
     }
@@ -221,10 +211,13 @@ function parseHtml(source) {
       children: [],
       parent: top(),
       line: startPos.line,
-      column: startPos.column
+      column: startPos.column,
+      origin: "markup",
+      opaque: false
     };
     top().children.push(node);
     i = j;
+    takeSynthetics(i - 1, false);
     if (selfClosing || VOID_ELEMENTS.has(lowerTag)) {
       continue;
     }
@@ -237,10 +230,13 @@ function parseHtml(source) {
         const gt = source.indexOf(">", idx);
         i = gt === -1 ? len : gt + 1;
       }
+      takeSynthetics(i - 1, false);
       continue;
     }
     stack.push(node);
   }
+  closeSynthetics(len);
+  takeSynthetics(len, true);
   return root;
 }
 function closeTag(stack, name) {
@@ -258,11 +254,699 @@ 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_]/;
+var ESCAPES = {
+  n: "\n",
+  t: "	",
+  r: "\r",
+  f: "\f",
+  v: "\v",
+  b: "\b",
+  a: "\x07",
+  e: "\x1B",
+  s: " "
+};
+var UNDECODED_ESCAPE = /[uxcCM0-7]/;
+function readString(code, start) {
+  const quote = code[start];
+  const single = quote === "'";
+  const contentStart = start + 1;
+  let i = contentStart;
+  let value = "";
+  let verbatim = true;
+  while (i < code.length) {
+    const char = code[i];
+    if (char === quote) {
+      return { end: i + 1, value, literal: true, verbatim, contentStart, contentEnd: i };
+    }
+    if (char === "\\") {
+      const escaped = code[i + 1];
+      if (escaped === void 0) break;
+      verbatim = false;
+      if (single) {
+        value += escaped === "'" || escaped === "\\" ? escaped : `\\${escaped}`;
+      } else if (UNDECODED_ESCAPE.test(escaped)) {
+        return {
+          end: closingQuote(code, i + 2, quote),
+          value,
+          literal: false,
+          verbatim: false,
+          contentStart,
+          contentEnd: i
+        };
+      } else if (escaped !== "\n") {
+        value += ESCAPES[escaped] ?? escaped;
+      }
+      i += 2;
+      continue;
+    }
+    if (!single && char === "#" && code[i + 1] === "{") {
+      const close = skipBraces(code, i + 1);
+      return {
+        end: closingQuote(code, close, quote),
+        value,
+        literal: false,
+        verbatim: false,
+        contentStart,
+        contentEnd: i
+      };
+    }
+    value += char;
+    i++;
+  }
+  return {
+    end: code.length,
+    value,
+    literal: false,
+    verbatim: false,
+    contentStart,
+    contentEnd: code.length
+  };
+}
+function closingQuote(code, from, quote) {
+  for (let i = from; i < code.length; i++) {
+    if (code[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (code[i] === quote) return i + 1;
+  }
+  return code.length;
+}
+function skipBraces(code, open) {
+  let depth = 0;
+  let i = open;
+  while (i < code.length) {
+    const char = code[i];
+    if (char === '"' || char === "'" || char === "`") {
+      i = readString(code, i).end;
+      continue;
+    }
+    if (char === "{") depth++;
+    else if (char === "}") {
+      depth--;
+      if (depth === 0) return i + 1;
+    }
+    i++;
+  }
+  return code.length;
+}
+function endOfLine(code, at) {
+  const newline = code.indexOf("\n", at);
+  return newline === -1 ? code.length : newline + 1;
+}
+function skipTrivia(code, at) {
+  let i = at;
+  while (i < code.length) {
+    const char = code[i];
+    if (SPACE.has(char)) i++;
+    else if (char === "#") i = endOfLine(code, i);
+    else break;
+  }
+  return i;
+}
+function previousSignificant(code, at) {
+  let i = at - 1;
+  while (i >= 0 && (code[i] === " " || code[i] === "	")) i--;
+  return i >= 0 ? code[i] : "";
+}
+var EXPRESSION_LEAD = /* @__PURE__ */ new Set([
+  "",
+  "\n",
+  "\r",
+  ";",
+  "(",
+  "[",
+  "{",
+  ",",
+  ":",
+  "=",
+  "<",
+  ">",
+  "!",
+  "&",
+  "|",
+  "^",
+  "~",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "?"
+]);
+function opensExpression(code, at) {
+  return EXPRESSION_LEAD.has(previousSignificant(code, at));
+}
+var PERCENT_TYPES = "qQwWiIrsx";
+var DELIMITER_PAIRS = { "(": ")", "[": "]", "{": "}", "<": ">" };
+function skipLiteral(code, at) {
+  const char = code[at];
+  if (char === void 0) return -1;
+  if (char === "%") {
+    const typed = PERCENT_TYPES.includes(code[at + 1] ?? "");
+    const open = typed ? code[at + 2] : code[at + 1];
+    if (open === void 0 || IDENT_CHAR.test(open) || SPACE.has(open)) return -1;
+    if (!typed && !opensExpression(code, at) && !SPACE.has(code[at - 1] ?? "")) return -1;
+    const end = closeDelimited(code, typed ? at + 3 : at + 2, open);
+    return end < 0 ? code.length : end;
+  }
+  if (char === "/" && opensExpression(code, at)) {
+    const end = closeDelimited(code, at + 1, "/");
+    if (end < 0) return -1;
+    let i = end;
+    while (i < code.length && /[imxounse]/.test(code[i])) i++;
+    return i;
+  }
+  if (char === "?" && opensExpression(code, at)) {
+    const next = code[at + 1];
+    if (next === void 0 || SPACE.has(next)) return -1;
+    if (next === "\\") return at + 3;
+    if (IDENT_CHAR.test(next) && IDENT_CHAR.test(code[at + 2] ?? "")) return -1;
+    return at + 2;
+  }
+  return -1;
+}
+function closeDelimited(code, from, open) {
+  const close = DELIMITER_PAIRS[open] ?? open;
+  const nests = close !== open;
+  let depth = 1;
+  for (let i = from; i < code.length; i++) {
+    const char = code[i];
+    if (char === "\\") {
+      i++;
+      continue;
+    }
+    if (nests && char === open) depth++;
+    else if (char === close) {
+      depth--;
+      if (depth === 0) return i + 1;
+    }
+  }
+  return -1;
+}
+var HEREDOC_OPEN = /^<<([-~])?(["'`])?([A-Za-z_]\w*)/;
+function maskHeredocs(code) {
+  let masked = code;
+  let i = 0;
+  while (i < masked.length) {
+    const char = masked[i];
+    if (char === "#") {
+      i = endOfLine(masked, i);
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      i = readString(masked, i).end;
+      continue;
+    }
+    const literal = skipLiteral(masked, i);
+    if (literal > i) {
+      i = literal;
+      continue;
+    }
+    if (char === "<" && masked[i + 1] === "<") {
+      const [matched, dash, quote, identifier] = HEREDOC_OPEN.exec(masked.slice(i)) ?? [];
+      const opensBody = identifier !== void 0 && (dash !== void 0 || quote !== void 0 || /^[A-Z]/.test(identifier) && opensExpression(masked, i));
+      const consumed = (matched?.length ?? 0) + (quote === void 0 ? 0 : 1);
+      if (opensBody && (quote === void 0 || masked[i + consumed - 1] === quote)) {
+        const bodyStart = endOfLine(masked, i);
+        const bodyEnd = heredocEnd(masked, bodyStart, identifier);
+        masked = masked.slice(0, bodyStart) + masked.slice(bodyStart, bodyEnd).replace(/[^\n]/g, " ") + masked.slice(bodyEnd);
+        i += consumed;
+        continue;
+      }
+    }
+    i++;
+  }
+  return masked;
+}
+function heredocEnd(code, bodyStart, identifier) {
+  let line = bodyStart;
+  while (line < code.length) {
+    const next = endOfLine(code, line);
+    if (code.slice(line, next).trim() === identifier) return next;
+    line = next;
+  }
+  return code.length;
+}
+
+// src/inspector/ruby_hash.ts
+function readDataOption(source, base) {
+  const code = maskHeredocs(source);
+  const attrs = [];
+  let found = false;
+  let opaque = false;
+  let i = 0;
+  while (i < code.length) {
+    const char = code[i];
+    if (char === "#") {
+      i = endOfLine(code, i);
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      const literal = readString(code, i);
+      const value = char === "`" ? null : keySeparator(code, literal.end);
+      if (literal.literal && literal.value === "data" && value !== null) {
+        i = value;
+      } else {
+        i = literal.end;
+        continue;
+      }
+    } else if (char === ":" && IDENT_START.test(code[i + 1] ?? "")) {
+      const name = readIdentifier(code, i + 1);
+      const value = hashRocket(code, name.end);
+      if (name.text === "data" && value !== null) {
+        i = value;
+      } else {
+        i = name.end;
+        continue;
+      }
+    } else if (IDENT_START.test(char) && !IDENT_CHAR.test(code[i - 1] ?? "")) {
+      const name = readIdentifier(code, i);
+      const keyed = name.text === "data" && code[name.end] === ":" && code[name.end + 1] !== ":";
+      if (keyed) {
+        i = name.end + 1;
+      } else {
+        i = name.end;
+        continue;
+      }
+    } else {
+      const literal = skipLiteral(code, i);
+      i = literal < 0 ? i + 1 : literal;
+      continue;
+    }
+    found = true;
+    const start = skipTrivia(code, i);
+    if (code[start] === "{") {
+      const hash = readHash(code, start, base);
+      attrs.push(...hash.attrs);
+      if (hash.partial || !optionEnds(code, hash.end)) opaque = true;
+      i = hash.end;
+    } else {
+      opaque = true;
+      i = start;
+    }
+  }
+  return { attrs, found, opaque };
+}
+var OPTION_TAIL = /^(?:do|if|unless|while|until|rescue|then|and|or|end)\b/;
+function optionEnds(code, at) {
+  const i = skipTrivia(code, at);
+  if (i >= code.length) return true;
+  const char = code[i];
+  if (char === "," || char === "}" || char === ")" || char === "]" || char === ";") return true;
+  return OPTION_TAIL.test(code.slice(i));
+}
+function readHash(code, open, base) {
+  const attrs = [];
+  let partial = false;
+  let i = open + 1;
+  for (; ; ) {
+    i = skipTrivia(code, i);
+    if (i >= code.length) {
+      partial = true;
+      break;
+    }
+    if (code[i] === "}") {
+      i++;
+      break;
+    }
+    if (code[i] === ",") {
+      i++;
+      continue;
+    }
+    const entry = readEntry(code, i, base);
+    if (entry.attr) attrs.push(entry.attr);
+    else partial = true;
+    i = entry.end;
+  }
+  return { attrs, partial, end: i };
+}
+function readEntry(code, start, base) {
+  const key = readKey(code, start);
+  if (key === null) return { attr: null, end: skipValue(code, start) };
+  const valueStart = skipTrivia(code, key.valueAt);
+  const name = attributeName(key.name);
+  if (name === null) return { attr: null, end: skipValue(code, valueStart) };
+  const anchor = { keyStart: base + start, keyEnd: base + key.end };
+  const quote = code[valueStart];
+  if (quote === '"' || quote === "'") {
+    const literal = readString(code, valueStart);
+    const after = skipTrivia(code, literal.end);
+    const whole = after >= code.length || code[after] === "," || code[after] === "}";
+    if (literal.literal && whole) {
+      return {
+        attr: {
+          name,
+          value: literal.value,
+          ...anchor,
+          valueStart: literal.verbatim ? base + literal.contentStart : void 0,
+          valueEnd: literal.verbatim ? base + literal.contentEnd : void 0
+        },
+        end: literal.end
+      };
+    }
+  }
+  const number = /^[+-]?\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?/.exec(
+    code.slice(valueStart)
+  )?.[0];
+  if (number !== void 0) {
+    const end = valueStart + number.length;
+    const after = skipTrivia(code, end);
+    const whole = after >= code.length || code[after] === "," || code[after] === "}";
+    if (whole) {
+      return {
+        attr: {
+          name,
+          value: number,
+          ...anchor,
+          valueStart: base + valueStart,
+          valueEnd: base + end
+        },
+        end
+      };
+    }
+  }
+  return { attr: { name, value: null, ...anchor }, end: skipValue(code, valueStart) };
+}
+function readKey(code, start) {
+  const char = code[start];
+  if (char === '"' || char === "'") {
+    const literal = readString(code, start);
+    const valueAt = keySeparator(code, literal.end);
+    if (!literal.literal || valueAt === null) return null;
+    return { name: literal.value, end: literal.end, valueAt };
+  }
+  if (char === ":" && IDENT_START.test(code[start + 1] ?? "")) {
+    const name = readIdentifier(code, start + 1);
+    const valueAt = hashRocket(code, name.end);
+    return valueAt === null ? null : { name: name.text, end: name.end, valueAt };
+  }
+  if (char !== void 0 && IDENT_START.test(char)) {
+    const name = readIdentifier(code, start);
+    if (code[name.end] !== ":" || code[name.end + 1] === ":") return null;
+    return { name: name.text, end: name.end, valueAt: name.end + 1 };
+  }
+  return null;
+}
+function attributeName(key) {
+  const name = key.replaceAll("_", "-").toLowerCase();
+  return name.length > 0 && !/[\s"'=<>/]/.test(name) ? `data-${name}` : null;
+}
+function keySeparator(code, at) {
+  if (code[at] === ":" && code[at + 1] !== ":") return at + 1;
+  return hashRocket(code, at);
+}
+function hashRocket(code, at) {
+  const arrow = skipTrivia(code, at);
+  return code.startsWith("=>", arrow) ? arrow + 2 : null;
+}
+function readIdentifier(code, start) {
+  let end = start;
+  while (end < code.length && IDENT_CHAR.test(code[end])) end++;
+  return { text: code.slice(start, end), end };
+}
+function skipValue(code, start) {
+  let depth = 0;
+  let i = start;
+  while (i < code.length) {
+    const char = code[i];
+    if (char === '"' || char === "'" || char === "`") {
+      i = readString(code, i).end;
+      continue;
+    }
+    if (char === "#") {
+      i = endOfLine(code, i);
+      continue;
+    }
+    const literal = skipLiteral(code, i);
+    if (literal >= 0) {
+      i = literal;
+      continue;
+    }
+    if (char === "(" || char === "[" || char === "{") depth++;
+    else if (char === ")" || char === "]") depth--;
+    else if (char === "}") {
+      if (depth === 0) return i;
+      depth--;
+    } else if (char === "," && depth === 0) return i;
+    i++;
+  }
+  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, " "));
+}
+function erbRanges(source) {
+  return [...source.matchAll(ERB_TAG)].map(
+    (match) => [match.index ?? 0, (match.index ?? 0) + match[0].length]
+  );
+}
+function erbElements(source) {
+  const tags = readErbTags(source);
+  const blockEnds = matchBlocks(tags);
+  const index = new PositionIndex(source);
+  const elements = [];
+  for (const [ordinal, tag] of tags.entries()) {
+    if (!tag.output) continue;
+    const option = readDataOption(tag.code, tag.codeStart);
+    if (!option.found) continue;
+    const end = blockEnds.get(ordinal) ?? tag.end;
+    elements.push({
+      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,
+      opaque: option.opaque
+    });
+  }
+  return elements;
+}
+function toParsedAttr(attr, index) {
+  const at = index.at(attr.keyStart);
+  return {
+    name: attr.name,
+    value: attr.value ?? "",
+    line: at.line,
+    column: at.column,
+    sourceLength: attr.keyEnd - attr.keyStart,
+    valueStart: attr.valueStart,
+    valueEnd: attr.valueEnd,
+    dynamicValue: attr.value === null
+  };
+}
+function readErbTags(source) {
+  const tags = [];
+  for (const match of source.matchAll(ERB_TAG)) {
+    const raw = match[0];
+    const start = match.index ?? 0;
+    let open = 2;
+    let output = false;
+    if (raw[open] === "#") continue;
+    if (raw[open] === "=") {
+      output = true;
+      open++;
+      if (raw[open] === "=") open++;
+    } else if (raw[open] === "-") {
+      open++;
+    }
+    let close = raw.length - 2;
+    if (raw[close - 1] === "-") close--;
+    if (close < open) close = open;
+    tags.push({
+      start,
+      end: start + raw.length,
+      output,
+      code: raw.slice(open, close),
+      codeStart: start + open
+    });
+  }
+  return tags;
+}
+function matchBlocks(tags) {
+  const ends = /* @__PURE__ */ new Map();
+  const open = [];
+  for (const [ordinal, tag] of tags.entries()) {
+    for (const event of blockEvents(tag.code)) {
+      if (event === "open") {
+        open.push(ordinal);
+        continue;
+      }
+      const opener = open.pop();
+      if (opener !== void 0) ends.set(opener, tag.end);
+    }
+  }
+  return ends;
+}
+var BLOCK_OPENERS = /* @__PURE__ */ new Set(["case", "begin", "def", "class", "module", "for"]);
+var BLOCK_MODIFIERS = /* @__PURE__ */ new Set(["if", "unless", "while", "until"]);
+var BLOCK_CONTINUERS = /* @__PURE__ */ new Set(["elsif", "else", "when", "in", "then", "rescue", "ensure"]);
+function blockEvents(source) {
+  const code = maskHeredocs(source);
+  const events = [];
+  let previous = "";
+  let loopHeader = false;
+  let i = 0;
+  while (i < code.length) {
+    const char = code[i];
+    if (char === "\n" || char === ";") {
+      previous = char;
+      loopHeader = false;
+      i++;
+      continue;
+    }
+    if (SPACE.has(char)) {
+      i++;
+      continue;
+    }
+    if (char === "#") {
+      i = endOfLine(code, i);
+      previous = "\n";
+      loopHeader = false;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      i = readString(code, i).end;
+      previous = "value";
+      continue;
+    }
+    if (char === ":" && IDENT_START.test(code[i + 1] ?? "")) {
+      i = identifierEnd(code, i + 1);
+      previous = "value";
+      continue;
+    }
+    const literal = skipLiteral(code, i);
+    if (literal >= 0) {
+      i = literal;
+      previous = "value";
+      continue;
+    }
+    if (char === "{") {
+      events.push("open");
+      previous = "{";
+      i++;
+      continue;
+    }
+    if (char === "}") {
+      events.push("close");
+      previous = "value";
+      i++;
+      continue;
+    }
+    if (char === ")" || char === "]") {
+      previous = "value";
+      i++;
+      continue;
+    }
+    if (!IDENT_START.test(char)) {
+      previous = char;
+      i++;
+      continue;
+    }
+    const end = identifierEnd(code, i);
+    const word = code.slice(i, end);
+    const keyword = !(code[end] === ":" && code[end + 1] !== ":") && code[i - 1] !== ".";
+    i = end;
+    if (keyword && word === "end") {
+      events.push("close");
+      previous = "value";
+    } else if (keyword && word === "do") {
+      if (loopHeader) loopHeader = false;
+      else events.push("open");
+      previous = "do";
+    } else if (keyword && BLOCK_OPENERS.has(word)) {
+      events.push("open");
+      loopHeader = word === "for";
+      previous = word;
+    } else if (keyword && BLOCK_MODIFIERS.has(word)) {
+      if (previous !== "value") {
+        events.push("open");
+        loopHeader = word !== "if" && word !== "unless";
+      }
+      previous = word;
+    } else if (keyword && BLOCK_CONTINUERS.has(word)) {
+      previous = word;
+    } else {
+      previous = "value";
+    }
+  }
+  return events;
+}
+function identifierEnd(code, start) {
+  let end = start;
+  while (end < code.length && IDENT_CHAR.test(code[end])) end++;
+  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) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const token of dataControllerValue.split(/\s+/)) {
+    if (token.startsWith(NAMESPACE_PREFIX)) seen.add(token);
+  }
+  return [...seen];
+}
+function parseTargetAttr(attrName) {
+  const match = /^data-(stimeo--[a-z0-9][a-z0-9-]*)-target$/.exec(attrName);
+  return match?.[1] ?? null;
+}
+function parseValueAttr(attrName, knownIdentifiers) {
+  const match = /^data-(stimeo--[a-z0-9-]+)-value$/.exec(attrName);
+  if (!match) return null;
+  const inner = match[1] ?? "";
+  let best = null;
+  for (const id of knownIdentifiers) {
+    if (inner.startsWith(`${id}-`)) {
+      const valueToken = inner.slice(id.length + 1);
+      if (valueToken.length > 0 && (!best || id.length > best.identifier.length)) {
+        best = { identifier: id, valueToken };
+      }
+    }
+  }
+  if (best) return best;
+  const rest = inner.slice(NAMESPACE_PREFIX.length);
+  const dash = rest.indexOf("-");
+  const identifierGuess = dash === -1 ? inner : `${NAMESPACE_PREFIX}${rest.slice(0, dash)}`;
+  const valueGuess = dash === -1 ? "" : rest.slice(dash + 1);
+  return { identifier: null, valueToken: valueGuess || identifierGuess };
+}
+function actionDescriptors(dataActionValue) {
+  const descriptors = [];
+  for (const descriptor of dataActionValue.split(/\s+/)) {
+    const hash = descriptor.indexOf("#");
+    if (hash === -1) continue;
+    let lhs = descriptor.slice(0, hash);
+    const arrow = lhs.indexOf("->");
+    if (arrow !== -1) lhs = lhs.slice(arrow + 2);
+    if (!lhs.startsWith(NAMESPACE_PREFIX)) continue;
+    const method = /^[a-zA-Z_$][\w$]*/.exec(descriptor.slice(hash + 1))?.[0] ?? "";
+    descriptors.push({ identifier: lhs, method });
+  }
+  return descriptors;
+}
+function isStimeoDataAttr(attrName) {
+  return attrName.startsWith(`data-${NAMESPACE_PREFIX}`);
+}
+
 // src/inspector/types.ts
 var DIAGNOSTIC_CODES = [
   "unknown-controller",
   "unknown-target",
   "unknown-value",
+  "invalid-value",
   "unknown-action-controller",
   "unknown-action-method",
   "orphan-target",
@@ -271,6 +955,7 @@ var DIAGNOSTIC_CODES = [
   "missing-aria",
   "invalid-aria-value",
   "keyboard-inaccessible",
+  "invalid-host",
   "unresolved-idref",
   "managed-aria",
   "composition-mismatch",
@@ -284,16 +969,15 @@ var DIAGNOSTIC_CODES = [
 // src/inspector/check.ts
 function checkSource(source, manifest) {
   const diagnostics = [];
-  const tree = parseHtml(neutralizeErb(source));
+  const tree = parseHtml(neutralizeErb(source), erbElements(source));
   const known = manifest.controllers;
   const knownIdentifiers = Object.keys(known);
-  const erbRanges = [...source.matchAll(/<%[\s\S]*?%>/g)].map(
-    (m) => [m.index ?? 0, (m.index ?? 0) + m[0].length]
-  );
+  const ranges = erbRanges(source);
   const isDynamicValue = (attr) => {
+    if (attr.dynamicValue !== void 0) return attr.dynamicValue;
     const { valueStart, valueEnd } = attr;
     if (valueStart === void 0 || valueEnd === void 0) return false;
-    return erbRanges.some(([start, end]) => start < valueEnd && end > valueStart);
+    return ranges.some(([start, end]) => start < valueEnd && end > valueStart);
   };
   const conditionHolds = (scope, identifier, when) => {
     if (!when) return true;
@@ -303,6 +987,36 @@ function checkSource(source, manifest) {
     if (hostAttr && isDynamicValue(hostAttr)) return null;
     return when.equals.includes(hostAttr ? hostAttr.value.trim() : when.default);
   };
+  const isContentEditable2 = (element) => {
+    let current = element;
+    while (current && current.tag !== "#root") {
+      const attr = current.attrs.find((candidate) => candidate.name === "contenteditable");
+      if (attr) {
+        if (isDynamicValue(attr)) return null;
+        const value = attr.value.trim().toLowerCase();
+        if (value === "false") return false;
+        if (value === "" || value === "true" || value === "plaintext-only") return true;
+      }
+      current = current.parent;
+    }
+    return false;
+  };
+  const hostIsAllowed = (element, rule) => {
+    if (element.tag === "button") {
+      if (rule.mode === "non-interactive") return false;
+      const type = element.attrs.find((attr) => attr.name === "type");
+      if (type && isDynamicValue(type)) return null;
+      const effectiveType = type?.value.trim().toLowerCase() || "submit";
+      return (rule.buttonTypes ?? []).includes(effectiveType);
+    }
+    if (ALWAYS_INTERACTIVE_HOSTS.has(element.tag)) return false;
+    if ((element.tag === "a" || element.tag === "area") && hasAttr(element, "href")) return false;
+    if ((element.tag === "audio" || element.tag === "video") && hasAttr(element, "controls")) {
+      return false;
+    }
+    const editable = isContentEditable2(element);
+    return editable === null ? null : !editable;
+  };
   const suppressed = (node, code) => {
     if (code === "unknown-ignore-code") return false;
     let current = node;
@@ -310,7 +1024,9 @@ function checkSource(source, manifest) {
       const ignore = current.attrs.find((a) => a.name === IGNORE_ATTR);
       if (ignore) {
         const codes = ignore.value.trim();
-        if (codes.length === 0 || codes.split(/\s+/).includes(code)) return true;
+        if (codes.length === 0) {
+          if (!isDynamicValue(ignore)) return true;
+        } else if (codes.split(/\s+/).includes(code)) return true;
       }
       current = current.parent;
     }
@@ -319,6 +1035,26 @@ function checkSource(source, manifest) {
   const report = (owner, code, severity, message, at, suggestion, fix) => {
     if (!suppressed(owner, code)) push(diagnostics, code, severity, message, at, suggestion, fix);
   };
+  const unresolved = /* @__PURE__ */ new Set();
+  const unnamedTargets = [];
+  const targetsUnreadable = (container, scope, identifier) => {
+    for (const node of unresolved) {
+      if (isWithin(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;
+    }
+    return false;
+  };
+  const unresolvedAbove = (node) => {
+    let current = node;
+    while (current && current.tag !== "#root") {
+      if (unresolved.has(current)) return true;
+      current = current.parent;
+    }
+    return false;
+  };
   const scopes = [];
   const presence = /* @__PURE__ */ new Map();
   const targetNodes = /* @__PURE__ */ new Map();
@@ -373,6 +1109,10 @@ function checkSource(source, manifest) {
   }
   const declarationCandidates = [];
   walk(tree, (node) => {
+    const declaredController = node.attrs.find((a) => a.name === "data-controller");
+    if (node.opaque || declaredController && isDynamicValue(declaredController)) {
+      unresolved.add(node);
+    }
     if (declarationAttrs.size > 0 && node.attrs.some((a) => declarationAttrs.has(a.name))) {
       declarationCandidates.push(node);
     }
@@ -384,6 +1124,7 @@ function checkSource(source, manifest) {
         focusableRoleTally.set(role, (focusableRoleTally.get(role) ?? 0) + 1);
       }
     }
+    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)) {
@@ -480,14 +1221,18 @@ function checkSource(source, manifest) {
           if (targetName.length > 0) {
             recordPresence(owner, targetIdentifier, targetName);
             recordTargetNode(owner, targetIdentifier, targetName, node);
+          } else if (isDynamicValue(attr)) {
+            unnamedTargets.push({ node, identifier: targetIdentifier });
           }
         } else if (!inDeclaredFragment(node, targetIdentifier)) {
+          const uncertain = unresolvedAbove(node);
           report(
             node,
             "orphan-target",
-            "error",
+            uncertain ? "warning" : "error",
             `Target "${attr.name}" has no enclosing controller "${targetIdentifier}".`,
-            attr
+            attr,
+            uncertain ? UNRESOLVED_HOST_HINT : void 0
           );
         }
         continue;
@@ -504,6 +1249,7 @@ function checkSource(source, manifest) {
               attr
             );
           } else {
+            authoredValueIdentifiers.add(parsed.identifier);
             const controller = known[parsed.identifier];
             const valid = controller?.values.some((v) => dasherize(v) === parsed.valueToken) ?? false;
             if (!valid) {
@@ -515,6 +1261,20 @@ function checkSource(source, manifest) {
                 attr,
                 didYouMean(parsed.valueToken, (controller?.values ?? []).map(dasherize))
               );
+            } else if (!isDynamicValue(attr)) {
+              const constraint = controller?.valueConstraints.find(
+                (candidate) => dasherize(candidate.value) === parsed.valueToken
+              );
+              if (constraint && !valueSatisfiesConstraint(attr.value, constraint)) {
+                report(
+                  node,
+                  "invalid-value",
+                  "error",
+                  `Invalid value "${attr.value.trim()}" for "${parsed.identifier}.${parsed.valueToken}". Expected ${describeValueConstraint(constraint)}.`,
+                  attr,
+                  constraint.suggestion
+                );
+              }
             }
           }
           continue;
@@ -549,19 +1309,50 @@ function checkSource(source, manifest) {
         }
       }
     }
+    for (const identifier of authoredValueIdentifiers) {
+      const controller = known[identifier];
+      if (!controller) continue;
+      for (const relation of controller.valueRelations) {
+        const leftAttr = node.attrs.find(
+          (attr) => attr.name === `data-${identifier}-${dasherize(relation.left)}-value`
+        );
+        const rightAttr = node.attrs.find(
+          (attr) => attr.name === `data-${identifier}-${dasherize(relation.right)}-value`
+        );
+        const at = rightAttr ?? leftAttr;
+        if (!at || leftAttr && isDynamicValue(leftAttr) || rightAttr && isDynamicValue(rightAttr)) {
+          continue;
+        }
+        const left = leftAttr ? decodeNumericValue(leftAttr.value) : relation.leftDefault;
+        const right = rightAttr ? decodeNumericValue(rightAttr.value) : relation.rightDefault;
+        if (!Number.isFinite(left) || !Number.isFinite(right)) continue;
+        if (relation.operator === "less-than-or-equal" && left <= right) continue;
+        report(
+          node,
+          "invalid-value",
+          "error",
+          `Invalid values for "${identifier}": "${relation.left}" (${left}) must be less than or equal to "${relation.right}" (${right}).`,
+          at,
+          relation.suggestion
+        );
+      }
+    }
   });
+  const scopeIsComplete = (container, scope, identifier) => container.origin === "markup" && !targetsUnreadable(container, scope, identifier);
   for (const { node, identifier } of scopes) {
     const controller = known[identifier];
     if (!controller) continue;
+    const complete = scopeIsComplete(node, node, identifier);
     const present = presence.get(node)?.get(identifier) ?? /* @__PURE__ */ new Set();
     for (const required of controller.requiredTargets) {
       if (!present.has(required)) {
         report(
           node,
           "missing-required-target",
-          "error",
+          complete ? "error" : "warning",
           `"${identifier}" is missing required target "${required}".`,
-          node
+          node,
+          complete ? void 0 : UNRESOLVED_TARGET_HINT
         );
       }
     }
@@ -569,6 +1360,7 @@ function checkSource(source, manifest) {
   for (const { node, identifier } of scopes) {
     const controller = known[identifier];
     if (!controller) continue;
+    const complete = scopeIsComplete(node, node, identifier);
     const present = presence.get(node)?.get(identifier) ?? /* @__PURE__ */ new Set();
     for (const rule of controller.conditionalTargets) {
       if (!present.has(rule.whenPresent)) continue;
@@ -577,10 +1369,10 @@ function checkSource(source, manifest) {
       report(
         node,
         "missing-conditional-target",
-        "error",
+        complete ? "error" : "warning",
         `"${identifier}" has a "${rule.whenPresent}" target, which also requires ${list(missing)}.`,
         node,
-        rule.suggestion
+        complete ? rule.suggestion : UNRESOLVED_TARGET_HINT
       );
     }
   }
@@ -593,6 +1385,7 @@ function checkSource(source, manifest) {
       if (req.whenDocument && !documentHolds(req.whenDocument)) continue;
       const severity = documentHolds(req.escalateWhen) ? "error" : req.severity ?? "error";
       for (const el of elements) {
+        if (!hasReadableMarkup(el)) continue;
         if (!contentHolds(node, identifier, el, req.whenContains)) continue;
         if (!elementHolds(el, req.whenElement)) continue;
         checkA11y(report, el, identifier, req, severity);
@@ -606,6 +1399,7 @@ function checkSource(source, manifest) {
       const reach = req.reach ?? "tab";
       const elements = targetNodes.get(node)?.get(identifier)?.get(req.target) ?? [];
       for (const el of elements) {
+        if (!hasReadableMarkup(el)) continue;
         if (!isFocusable(el, reach)) {
           const problem = reach === "tab" ? 'not in the Tab order (needs a native control or tabindex="0")' : "not focusable (needs a native control or tabindex)";
           report(
@@ -620,6 +1414,28 @@ function checkSource(source, manifest) {
       }
     }
   }
+  for (const { node, identifier } of scopes) {
+    const controller = known[identifier];
+    if (!controller) continue;
+    for (const rule of controller.hosts) {
+      const elements = rule.target === "" ? [node] : targetNodes.get(node)?.get(identifier)?.get(rule.target) ?? [];
+      const where = rule.target === "" ? "scope element" : `"${rule.target}" target`;
+      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}>`;
+        report(
+          element,
+          "invalid-host",
+          "error",
+          `The ${where} of "${identifier}" uses ${detail} host.`,
+          type ?? element,
+          rule.suggestion
+        );
+      }
+    }
+  }
   for (const { node, identifier } of scopes) {
     const controller = known[identifier];
     if (!controller) continue;
@@ -627,6 +1443,7 @@ function checkSource(source, manifest) {
       const elements = rule.target === "" ? [node] : targetNodes.get(node)?.get(identifier)?.get(rule.target) ?? [];
       const where = rule.target === "" ? "scope element" : `"${rule.target}" target`;
       for (const el of elements) {
+        if (!hasReadableMarkup(el)) continue;
         for (const name of rule.attrs) {
           const attr = el.attrs.find((a) => a.name === name);
           if (!attr) continue;
@@ -649,6 +1466,7 @@ function checkSource(source, manifest) {
       const elements = rule.target === "" ? [node] : targetNodes.get(node)?.get(identifier)?.get(rule.target) ?? [];
       const where = rule.target === "" ? "scope element" : `"${rule.target}" target`;
       for (const el of elements) {
+        if (!hasReadableMarkup(el)) continue;
         if (!contentHolds(node, identifier, el, rule.whenContains)) continue;
         for (const name of rule.attrs) {
           const attr = el.attrs.find((a) => a.name === name);
@@ -679,6 +1497,7 @@ function checkSource(source, manifest) {
       if (conditionHolds(node, identifier, when) !== true) continue;
       const hostContext = when ? ` (${when.value} ${list(when.equals)})` : "";
       for (const el of elements) {
+        if (el.opaque) continue;
         const declared = el.attrs.find((a) => a.name === "data-controller");
         if (!declared || !controllerIdentifiers(declared.value).includes(rule.coController)) {
           continue;
@@ -719,6 +1538,7 @@ function checkSource(source, manifest) {
       const elements = rule.target === "" ? [node] : targetNodes.get(node)?.get(identifier)?.get(rule.target) ?? [];
       const where = rule.target === "" ? "scope element" : `"${rule.target}" target`;
       for (const el of elements) {
+        if (el.opaque) continue;
         const declared = el.attrs.find((a) => a.name === "data-controller");
         if (declared && isDynamicValue(declared)) continue;
         if (declared && controllerIdentifiers(declared.value).includes(rule.controller)) continue;
@@ -807,13 +1627,14 @@ function checkSource(source, manifest) {
           }
         }
         if (rule.min !== void 0 && matched.length < rule.min) {
+          const complete = scopeIsComplete(container, node, identifier);
           report(
             container,
             "cardinality-violation",
-            "error",
+            complete ? "error" : "warning",
             `"${identifier}" requires at least ${rule.min} ${what} per ${where}, but found ${matched.length}.`,
             container,
-            rule.suggestion
+            complete ? rule.suggestion : UNRESOLVED_TARGET_HINT
           );
         }
       }
@@ -856,6 +1677,28 @@ function checkSource(source, manifest) {
   diagnostics.sort((a, b) => a.line - b.line || a.column - b.column);
   return diagnostics;
 }
+function valueSatisfiesConstraint(raw, constraint) {
+  const value = decodeNumericValue(raw);
+  if (Number.isNaN(value)) return false;
+  if (constraint.finite && !Number.isFinite(value)) return false;
+  if (constraint.greaterThan !== void 0 && !(value > constraint.greaterThan)) return false;
+  return true;
+}
+function decodeNumericValue(raw) {
+  return Number(raw.replace(/_/g, ""));
+}
+function describeValueConstraint(constraint) {
+  const parts = [constraint.finite ? "a finite number" : "a number"];
+  if (constraint.greaterThan !== void 0) {
+    parts.push(`greater than ${constraint.greaterThan}`);
+  }
+  return parts.join(" ");
+}
+var UNRESOLVED_TARGET_HINT = "Part of this scope is rendered by a helper or a non-literal data: hash, so the target may exist at runtime.";
+var UNRESOLVED_HOST_HINT = "An enclosing helper's data: option is not a literal hash, so the host controller may be declared at runtime.";
+function hasReadableMarkup(el) {
+  return el.origin === "markup";
+}
 function checkA11y(report, el, identifier, req, severity) {
   const groups = [
     { attrs: req.attrs, values: req.values },
@@ -923,6 +1766,20 @@ function describeCounted(target, attr, values) {
   return `"${target}" targets with ${attr}${constrained}`;
 }
 var NATIVE_FOCUSABLE_TAGS = /* @__PURE__ */ new Set(["button", "select", "textarea", "summary"]);
+var ALWAYS_INTERACTIVE_HOSTS = /* @__PURE__ */ new Set([
+  "input",
+  "select",
+  "textarea",
+  "label",
+  "summary",
+  "details",
+  "iframe",
+  "object",
+  "embed"
+]);
+function hasAttr(element, name) {
+  return element.attrs.some((attr) => attr.name === name);
+}
 function isNativelyFocusable(el) {
   if (NATIVE_FOCUSABLE_TAGS.has(el.tag)) return true;
   if (el.tag === "input") {
@@ -984,6 +1841,7 @@ function inDeclaredFragment(node, identifier) {
   return false;
 }
 function anchorLength(at) {
+  if (at.sourceLength !== void 0) return at.sourceLength;
   return "name" in at ? at.name.length : at.tag.length + 1;
 }
 function push(out, code, severity, message, at, suggestion, fix) {
@@ -1072,12 +1930,15 @@ function isCheckableFile(path) {
 var CONTROLLER_ARRAY_FIELDS = [
   "targets",
   "values",
+  "valueConstraints",
+  "valueRelations",
   "actions",
   "events",
   "requiredTargets",
   "conditionalTargets",
   "a11y",
   "keyboard",
+  "hosts",
   "managedAria",
   "compositions",
   "companions",