stimeo-ui 0.2.1 → 0.4.0

package/dist/inspector/cli_bin.js

@@ -7,66 +7,8 @@ import { createInterface } from 'readline';
 
 // src/inspector/cli_bin.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",
@@ -103,7 +45,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] : "";
@@ -113,12 +55,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;
@@ -127,11 +114,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 === "/") {
@@ -143,6 +132,7 @@ function parseHtml(source) {
       }
       const end = source.indexOf(">", j2);
       i = end === -1 ? len : end + 1;
+      takeSynthetics(i - 1, false);
       closeTag(stack, name.toLowerCase());
       continue;
     }
@@ -223,10 +213,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;
     }
@@ -239,10 +232,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) {
@@ -260,6 +256,673 @@ 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
+      };
+    }
+  }
+  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",
@@ -269,28 +932,40 @@ var DIAGNOSTIC_CODES = [
   "unknown-action-method",
   "orphan-target",
   "missing-required-target",
+  "missing-conditional-target",
   "missing-aria",
   "invalid-aria-value",
   "keyboard-inaccessible",
   "unresolved-idref",
   "managed-aria",
   "composition-mismatch",
+  "missing-companion",
+  "undeclared-target",
+  "cardinality-violation",
+  "forbidden-aria",
   "unknown-ignore-code"
 ];
 
 // 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;
+    const hostAttr = scope.attrs.find(
+      (a) => a.name === `data-${identifier}-${dasherize(when.value)}-value`
+    );
+    if (hostAttr && isDynamicValue(hostAttr)) return null;
+    return when.equals.includes(hostAttr ? hostAttr.value.trim() : when.default);
   };
   const suppressed = (node, code) => {
     if (code === "unknown-ignore-code") return false;
@@ -299,7 +974,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;
     }
@@ -308,6 +985,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();
@@ -339,7 +1036,44 @@ function checkSource(source, manifest) {
     if (found) found.push(el);
     else byName.set(target, [el]);
   };
+  const contentHolds = (scope, identifier, element, condition) => {
+    if (!condition) return true;
+    const nodes = targetNodes.get(scope)?.get(identifier)?.get(condition.target) ?? [];
+    let held = 0;
+    for (const node of nodes) if (isWithin(node, element)) held += 1;
+    if (condition.min !== void 0 && held < condition.min) return false;
+    if (condition.max !== void 0 && held > condition.max) return false;
+    return true;
+  };
+  const elementHolds = (element, condition) => !condition?.exceptTags.includes(element.tag);
+  const roleTally = /* @__PURE__ */ new Map();
+  const focusableRoleTally = /* @__PURE__ */ new Map();
+  const documentHolds = (condition) => {
+    if (condition === void 0) return false;
+    const tally = condition.focusable ? focusableRoleTally : roleTally;
+    return (tally.get(condition.role) ?? 0) >= condition.atLeast;
+  };
+  const declarationAttrs = /* @__PURE__ */ new Set();
+  for (const controller of Object.values(known)) {
+    for (const rule of controller.targetDeclarations) declarationAttrs.add(rule.attr);
+  }
+  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);
+    }
+    const roleAttr = node.attrs.find((a) => a.name === "role");
+    if (roleAttr && !isDynamicValue(roleAttr)) {
+      const role = roleAttr.value.trim();
+      roleTally.set(role, (roleTally.get(role) ?? 0) + 1);
+      if (isFocusable(node, "tab")) {
+        focusableRoleTally.set(role, (focusableRoleTally.get(role) ?? 0) + 1);
+      }
+    }
     for (const attr of node.attrs) {
       if (attr.name === IGNORE_ATTR) {
         for (const token of attr.value.split(/\s+/).filter((t) => t.length > 0)) {
@@ -418,7 +1152,7 @@ function checkSource(source, manifest) {
           );
           continue;
         }
-        const targetName = attr.value.trim();
+        const targetName = isDynamicValue(attr) ? "" : attr.value.trim();
         if (targetName.length > 0 && !controller.targets.includes(targetName)) {
           const best = nearestName(targetName, controller.targets);
           report(
@@ -436,14 +1170,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;
@@ -506,29 +1244,57 @@ function checkSource(source, manifest) {
       }
     }
   });
+  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
         );
       }
     }
   }
+  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;
+      const missing = rule.require.filter((target) => !present.has(target));
+      if (missing.length === 0) continue;
+      report(
+        node,
+        "missing-conditional-target",
+        complete ? "error" : "warning",
+        `"${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;
     for (const req of controller.a11y) {
+      if (conditionHolds(node, identifier, req.when) !== true) continue;
       const elements = req.target === "" ? [node] : targetNodes.get(node)?.get(identifier)?.get(req.target) ?? [];
+      if (req.whenDocument && !documentHolds(req.whenDocument)) continue;
+      const severity = documentHolds(req.escalateWhen) ? "error" : req.severity ?? "error";
       for (const el of elements) {
-        checkA11y(report, el, identifier, req);
+        if (!hasReadableMarkup(el)) continue;
+        if (!contentHolds(node, identifier, el, req.whenContains)) continue;
+        if (!elementHolds(el, req.whenElement)) continue;
+        checkA11y(report, el, identifier, req, severity);
       }
     }
   }
@@ -539,6 +1305,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(
@@ -560,6 +1327,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;
@@ -575,6 +1343,33 @@ function checkSource(source, manifest) {
       }
     }
   }
+  for (const { node, identifier } of scopes) {
+    const controller = known[identifier];
+    if (!controller) continue;
+    for (const rule of controller.forbiddenAria) {
+      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);
+          if (!attr) continue;
+          if (rule.values && (isDynamicValue(attr) || !rule.values.includes(attr.value.trim()))) {
+            continue;
+          }
+          report(
+            el,
+            "forbidden-aria",
+            "warning",
+            `${name} on the ${where} of "${identifier}" contradicts the markup around it.`,
+            attr,
+            rule.suggestion
+          );
+        }
+      }
+    }
+  }
   for (const { node, identifier } of scopes) {
     const controller = known[identifier];
     if (!controller) continue;
@@ -583,16 +1378,10 @@ function checkSource(source, manifest) {
       const elements = rule.target === "" ? [node] : targeted ?? (rule.fallbackToScope ? [node] : []);
       const where = rule.target === "" || !targeted ? "scope element" : `"${rule.target}" target`;
       const when = rule.when;
-      if (when) {
-        const hostAttr = node.attrs.find(
-          (a) => a.name === `data-${identifier}-${dasherize(when.value)}-value`
-        );
-        if (hostAttr && isDynamicValue(hostAttr)) continue;
-        const hostEffective = hostAttr ? hostAttr.value.trim() : when.default;
-        if (!when.equals.includes(hostEffective)) continue;
-      }
+      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;
@@ -626,6 +1415,115 @@ function checkSource(source, manifest) {
       }
     }
   }
+  for (const { node, identifier } of scopes) {
+    const controller = known[identifier];
+    if (!controller) continue;
+    for (const rule of controller.companions) {
+      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;
+        report(
+          el,
+          "missing-companion",
+          "error",
+          `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(),
+            `Add "${rule.controller}" to data-controller`
+          ) : void 0
+        );
+      }
+    }
+  }
+  for (const { node, identifier } of scopes) {
+    const controller = known[identifier];
+    if (!controller) continue;
+    if (controller.targetDeclarations.length === 0) continue;
+    const targetAttrName = `data-${identifier}-target`;
+    for (const rule of controller.targetDeclarations) {
+      for (const el of declarationCandidates) {
+        const marker = el.attrs.find((a) => a.name === rule.attr);
+        if (!marker || isDynamicValue(marker)) continue;
+        const value = marker.value.trim();
+        if (value.length === 0) continue;
+        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) {
+          continue;
+        }
+        if (declaredAs && isDynamicValue(declaredAs)) continue;
+        report(
+          el,
+          "undeclared-target",
+          "error",
+          `${rule.attr}="${value}" inside "${identifier}" is not declared as its "${rule.target}" target, so the controller never manages it.`,
+          marker,
+          rule.suggestion
+        );
+      }
+    }
+  }
+  for (const { node, identifier } of scopes) {
+    const controller = known[identifier];
+    if (!controller) continue;
+    for (const rule of controller.cardinality) {
+      if (conditionHolds(node, identifier, rule.when) !== true) continue;
+      const byName = targetNodes.get(node)?.get(identifier);
+      const counted = byName?.get(rule.target) ?? [];
+      const containers = rule.within === "" ? [node] : byName?.get(rule.within) ?? [];
+      const what = describeCounted(rule.target, rule.attr, rule.values);
+      const where = rule.within === "" ? "controller scope" : `"${rule.within}" target`;
+      for (const container of containers) {
+        const matched = [];
+        for (const el of counted) {
+          if (!isWithin(el, container)) continue;
+          if (rule.attr === void 0) {
+            matched.push({ el, at: el });
+            continue;
+          }
+          const attr = el.attrs.find((a) => a.name === rule.attr);
+          if (!attr) continue;
+          if (rule.values && (isDynamicValue(attr) || !rule.values.includes(attr.value.trim()))) {
+            continue;
+          }
+          matched.push({ el, at: attr });
+        }
+        if (rule.max !== void 0 && matched.length > rule.max) {
+          for (const { el, at } of matched.slice(rule.max)) {
+            report(
+              el,
+              "cardinality-violation",
+              "error",
+              `"${identifier}" allows at most ${rule.max} ${what} per ${where}, but found ${matched.length}.`,
+              at,
+              rule.suggestion
+            );
+          }
+        }
+        if (rule.min !== void 0 && matched.length < rule.min) {
+          const complete = scopeIsComplete(container, node, identifier);
+          report(
+            container,
+            "cardinality-violation",
+            complete ? "error" : "warning",
+            `"${identifier}" requires at least ${rule.min} ${what} per ${where}, but found ${matched.length}.`,
+            container,
+            complete ? rule.suggestion : UNRESOLVED_TARGET_HINT
+          );
+        }
+      }
+    }
+  }
   const ids = /* @__PURE__ */ new Set();
   walk(tree, (node) => {
     const id = node.attrs.find((a) => a.name === "id");
@@ -663,7 +1561,12 @@ function checkSource(source, manifest) {
   diagnostics.sort((a, b) => a.line - b.line || a.column - b.column);
   return diagnostics;
 }
-function checkA11y(report, el, identifier, req) {
+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 },
     ...req.or ?? []
@@ -692,11 +1595,12 @@ function checkA11y(report, el, identifier, req) {
     }
   }
   if (!anyPresent) {
+    const verb = severity === "warning" ? "recommends" : "requires";
     report(
       el,
       "missing-aria",
-      "error",
-      `"${identifier}" requires ${describeAttrs([...allowedByAttr.keys()])} on its ${where}.`,
+      severity,
+      `"${identifier}" ${verb} ${describeAttrs([...allowedByAttr.keys()])} on its ${where}.`,
       el,
       req.suggestion
     );
@@ -715,6 +1619,19 @@ function checkA11y(report, el, identifier, req) {
     );
   }
 }
+function isWithin(node, container) {
+  let current = node;
+  while (current) {
+    if (current === container) return true;
+    current = current.parent;
+  }
+  return false;
+}
+function describeCounted(target, attr, values) {
+  if (attr === void 0) return `"${target}" targets`;
+  const constrained = values && values.length > 0 ? ` set to ${list(values)}` : "";
+  return `"${target}" targets with ${attr}${constrained}`;
+}
 var NATIVE_FOCUSABLE_TAGS = /* @__PURE__ */ new Set(["button", "select", "textarea", "summary"]);
 function isNativelyFocusable(el) {
   if (NATIVE_FOCUSABLE_TAGS.has(el.tag)) return true;
@@ -777,6 +1694,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) {
@@ -868,10 +1786,15 @@ var CONTROLLER_ARRAY_FIELDS = [
   "actions",
   "events",
   "requiredTargets",
+  "conditionalTargets",
   "a11y",
   "keyboard",
   "managedAria",
-  "compositions"
+  "compositions",
+  "companions",
+  "targetDeclarations",
+  "cardinality",
+  "forbiddenAria"
 ];
 function isCompatibleManifest(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
@@ -1297,6 +2220,41 @@ var EXAMPLE_RESULT_SCHEMA = {
   },
   required: ["id", "file", "source", "guidance"]
 };
+var CONTENT_CONDITION_SCHEMA = {
+  type: "object",
+  description: "Condition on the element's own contents arming the rule; absent means it does not depend on them. Evaluated per element, unlike the scope-level `when`.",
+  properties: {
+    target: { type: "string", description: "Target counted inside the element." },
+    min: { type: "integer", description: "Arms the rule when the count is at least this." },
+    max: { type: "integer", description: "Arms the rule when the count is at most this." }
+  },
+  required: ["target"]
+};
+var ELEMENT_CONDITION_SCHEMA = {
+  type: "object",
+  description: "Tags the rule is disarmed on because they name the role natively (a <table>'s <caption>, a <fieldset>'s <legend>, an <input>'s <label for>); absent means the rule applies to every spelling.",
+  properties: {
+    exceptTags: {
+      type: "array",
+      items: { type: "string" },
+      description: "Lowercase tag names whose native naming path disarms the rule."
+    }
+  },
+  required: ["exceptTags"]
+};
+var DOCUMENT_CONDITION_SCHEMA = {
+  type: "object",
+  description: "Condition on the whole file: how many elements in it carry a role. Backs ARIA's conditional name levels (a toolbar's name becomes required on the second toolbar). Counts per file, which under-approximates a page built from partials.",
+  properties: {
+    role: { type: "string", description: "Role counted across the file." },
+    atLeast: { type: "integer", description: "Holds at this many or more." },
+    focusable: {
+      type: "boolean",
+      description: "Counts only Tab-reachable carriers of the role; absent counts all. ARIA qualifies a separator's condition by focusability (a decorative hr cannot be landed on) but a toolbar's not at all."
+    }
+  },
+  required: ["role", "atLeast"]
+};
 var CONTROLLER_CONTRACT_SCHEMA = {
   type: "object",
   properties: {
@@ -1309,6 +2267,19 @@ var CONTROLLER_CONTRACT_SCHEMA = {
       ...STRING_ARRAY,
       description: "Targets that must be present at least once inside the controller scope."
     },
+    conditionalTargets: {
+      type: "array",
+      description: "Targets that become required only once another optional target appears \u2014 an opt-in feature that is incomplete without its whole set. Omitting one half passes every other check and silently does nothing.",
+      items: {
+        type: "object",
+        properties: {
+          whenPresent: { type: "string", description: "The optional target that turns it on." },
+          require: { ...STRING_ARRAY, description: "Targets required once it appears." },
+          suggestion: { type: "string" }
+        },
+        required: ["whenPresent", "require", "suggestion"]
+      }
+    },
     a11y: {
       type: "array",
       description: "Author-supplied ARIA the controller relies on but never sets itself.",
@@ -1330,6 +2301,25 @@ var CONTROLLER_CONTRACT_SCHEMA = {
               required: ["attrs"]
             }
           },
+          when: {
+            type: "object",
+            description: "Own-value condition arming the requirement; absent means unconditional. Outside the named configuration the ARIA is not optional but wrong.",
+            properties: {
+              value: { type: "string" },
+              equals: STRING_ARRAY,
+              default: { type: "string" }
+            },
+            required: ["value", "equals", "default"]
+          },
+          whenContains: CONTENT_CONDITION_SCHEMA,
+          whenElement: ELEMENT_CONDITION_SCHEMA,
+          whenDocument: DOCUMENT_CONDITION_SCHEMA,
+          severity: {
+            type: "string",
+            enum: ["error", "warning"],
+            description: 'Level of an unmet requirement; absent means "error". ARIA recommends some names rather than requiring them, and those report as warnings.'
+          },
+          escalateWhen: DOCUMENT_CONDITION_SCHEMA,
           suggestion: { type: "string" }
         },
         required: ["target", "attrs", "suggestion"]
@@ -1404,6 +2394,84 @@ var CONTROLLER_CONTRACT_SCHEMA = {
         },
         required: ["target", "coController", "require", "suggestion"]
       }
+    },
+    companions: {
+      type: "array",
+      description: "Controllers the named target must ALSO declare. Unlike compositions (which only check an already co-located companion), these report the companion being missing.",
+      items: {
+        type: "object",
+        properties: {
+          target: {
+            type: "string",
+            description: 'Target that must declare it; "" means the data-controller element.'
+          },
+          controller: { type: "string", description: "Required companion identifier." },
+          suggestion: { type: "string" }
+        },
+        required: ["target", "controller", "suggestion"]
+      }
+    },
+    targetDeclarations: {
+      type: "array",
+      description: "Reverse direction: elements in scope carrying the attribute must be declared as the named target, or the controller never manages them.",
+      items: {
+        type: "object",
+        properties: {
+          attr: { type: "string", description: 'Marking attribute, e.g. "role".' },
+          values: { ...STRING_ARRAY, description: "Marking values; absent = any value." },
+          target: {
+            type: "string",
+            description: "Target the matched element must be declared as."
+          },
+          suggestion: { type: "string" }
+        },
+        required: ["attr", "target", "suggestion"]
+      }
+    },
+    cardinality: {
+      type: "array",
+      description: "Set-level count bounds: how many of the named target may or must exist per scope or per container target, optionally narrowed to elements carrying an attribute.",
+      items: {
+        type: "object",
+        properties: {
+          within: {
+            type: "string",
+            description: 'Container target bounding the count; "" means the whole scope.'
+          },
+          target: { type: "string", description: "Target name being counted." },
+          attr: { type: "string", description: "Count only elements carrying this attribute." },
+          values: { ...STRING_ARRAY, description: "Restrict the attribute to these values." },
+          min: { type: "integer", description: "Smallest permitted count (inclusive)." },
+          max: { type: "integer", description: "Largest permitted count (inclusive)." },
+          when: {
+            type: "object",
+            description: "Own-value condition arming the bound; absent means unconditional.",
+            properties: {
+              value: { type: "string" },
+              equals: STRING_ARRAY,
+              default: { type: "string" }
+            },
+            required: ["value", "equals", "default"]
+          },
+          suggestion: { type: "string" }
+        },
+        required: ["within", "target", "suggestion"]
+      }
+    },
+    forbiddenAria: {
+      type: "array",
+      description: "ARIA the author owns that the surrounding markup contradicts (e.g. a menu still declaring itself busy once its items are present). Reported as a warning \u2014 unlike managedAria, the attribute is the author's and is required in the other configuration.",
+      items: {
+        type: "object",
+        properties: {
+          target: { type: "string" },
+          attrs: STRING_ARRAY,
+          values: { ...STRING_ARRAY, description: "Forbidden values; absent = any value." },
+          whenContains: CONTENT_CONDITION_SCHEMA,
+          suggestion: { type: "string" }
+        },
+        required: ["target", "attrs", "suggestion"]
+      }
     }
   },
   required: [
@@ -1413,10 +2481,15 @@ var CONTROLLER_CONTRACT_SCHEMA = {
     "actions",
     "events",
     "requiredTargets",
+    "conditionalTargets",
     "a11y",
     "keyboard",
     "managedAria",
-    "compositions"
+    "compositions",
+    "companions",
+    "targetDeclarations",
+    "cardinality",
+    "forbiddenAria"
   ]
 };
 var InvalidToolArgsError = class extends Error {
@@ -1429,7 +2502,7 @@ var TOOL_DESCRIPTORS = [
   {
     name: "stimeo_check",
     title: "Check Stimeo UI markup",
-    description: "Statically check HTML or ERB source that uses Stimeo UI (stimeo--*) controllers. Returns a CheckReport with diagnostics \u2014 unknown controllers/targets/values/action methods, missing required targets, missing or invalid author-supplied ARIA, keyboard-focusability prerequisites, and misaligned cross-controller composition values \u2014 each with a fix suggestion when available. Call this on generated markup before finalizing it; ok=true means no errors.",
+    description: "Statically check HTML or ERB source that uses Stimeo UI (stimeo--*) controllers \u2014 the headless, accessible Stimulus UI component library for Rails. Returns a CheckReport with diagnostics \u2014 unknown controllers/targets/values/action methods, missing required targets, missing or invalid author-supplied ARIA, keyboard-focusability prerequisites, and misaligned cross-controller composition values \u2014 each with a fix suggestion when available. Call this to validate any Rails view, ERB template, or HTML you write or edit with these components, before finalizing it; ok=true means no errors.",
     annotations: READ_ONLY_ANNOTATIONS,
     inputSchema: {
       type: "object",
@@ -1451,7 +2524,7 @@ var TOOL_DESCRIPTORS = [
   {
     name: "stimeo_catalog",
     title: "List Stimeo UI controllers",
-    description: "List every Stimeo UI controller with its targets, values, actions, and events. Use this to discover which stimeo--* controllers exist and the data-* API each accepts before writing markup.",
+    description: "List every Stimeo UI controller with its targets, values, actions, and events. Stimeo UI is a headless, accessible (WAI-ARIA APG) Stimulus UI component library for Rails: dialog/modal, drawer, dropdown menu, tabs, accordion, combobox, listbox, tooltip, popover, toast, carousel, data grid, date picker, tree view, and many more. Start here to find which stimeo--* controller implements a requested component and the data-* API it accepts before writing markup.",
     annotations: READ_ONLY_ANNOTATIONS,
     inputSchema: {
       type: "object",
@@ -1463,7 +2536,7 @@ var TOOL_DESCRIPTORS = [
   {
     name: "stimeo_controller",
     title: "Get one controller's usage contract",
-    description: 'Fetch the full usage contract of one Stimeo UI controller by identifier (e.g. "stimeo--tabs"): targets, values, actions, events, required targets, and the accessibility contract \u2014 author-supplied ARIA requirements, keyboard-focusability prerequisites, the ARIA attributes the controller manages at runtime (which the author must NOT hardcode), and cross-controller composition value alignments.',
+    description: 'Fetch the full usage contract of one Stimeo UI controller by identifier (e.g. "stimeo--tabs"): targets, values, actions, events, required targets, and the accessibility contract \u2014 author-supplied ARIA requirements, keyboard-focusability prerequisites, the ARIA attributes the controller manages at runtime (which the author must NOT hardcode), and cross-controller composition value alignments. Use it after stimeo_catalog to write correct, accessible Rails ERB or HTML markup for that Stimulus component.',
     annotations: READ_ONLY_ANNOTATIONS,
     inputSchema: {
       type: "object",
@@ -1481,7 +2554,7 @@ var TOOL_DESCRIPTORS = [
   {
     name: "stimeo_example",
     title: "Get one controller's verified example markup",
-    description: 'Fetch verified example markup for one Stimeo UI controller by identifier (e.g. "stimeo--menu"). The example is the official catalog demo \u2014 it passes stimeo_check against the bundled manifest, so use it as the reference for correct structure, required targets, and author-supplied ARIA. class attributes in it are demo styling placeholders to replace; the stimeo--* data attributes and role/aria-* attributes are the contract to keep.',
+    description: 'Fetch verified example markup for one Stimeo UI controller by identifier (e.g. "stimeo--menu"). The example is the official catalog demo \u2014 it passes stimeo_check against the bundled manifest, so use it as the reference for correct structure, required targets, and author-supplied ARIA. class attributes in it are demo styling placeholders to replace; the stimeo--* data attributes and role/aria-* attributes are the contract to keep. Copy it as the starting point when adding that accessible Stimulus component to a Rails ERB view.',
     annotations: READ_ONLY_ANNOTATIONS,
     inputSchema: {
       type: "object",
@@ -1693,7 +2766,13 @@ var McpSession = class {
         title: "Stimeo UI Inspector",
         version: this.#context.manifest.packageVersion
       },
-      instructions: "Stimeo UI is a headless Stimulus UI framework for Rails. Use stimeo_catalog to discover controllers, stimeo_controller for one controller's usage and accessibility contract, stimeo_example for verified reference markup, and stimeo_check to validate generated HTML/ERB before presenting it. The full manifest and every example are also exposed as resources (stimeo:// URIs), and the stimeo_build_ui / stimeo_fix_markup prompts bake this workflow into user-invokable templates."
+      // The server's own account of itself. Per the MCP schema this is a hint
+      // a client MAY put in front of the model, which makes it the earliest
+      // point this server can be routed to — clients that defer tool
+      // definitions still tend to load it alongside the tool names. Hence the
+      // trigger condition first, in the words a request would use, and a
+      // length that survives truncation.
+      instructions: "Search for these tools whenever a task involves building, editing, or reviewing an accessible UI component in a Rails view \u2014 dialog/modal, drawer, dropdown menu, tabs, accordion, combobox, toast, and the rest of the catalog \u2014 or whenever HTML/ERB carrying stimeo--* attributes is in play. Stimeo UI is a headless Stimulus UI framework for Rails. Use stimeo_catalog to discover controllers, stimeo_controller for one controller's usage and accessibility contract, stimeo_example for verified reference markup, and stimeo_check to validate generated HTML/ERB before presenting it. The full manifest and every example are also exposed as resources (stimeo:// URIs), and the stimeo_build_ui / stimeo_fix_markup prompts bake this workflow into user-invokable templates."
     });
   }
   #getPrompt(id, params) {
@@ -1807,40 +2886,41 @@ async function runMcpServer(io) {
 
 // src/inspector/cli_bin.ts
 var argv = process2.argv.slice(2);
+process2.stdout.on("error", (error) => {
+  process2.exit(error.code === "EPIPE" ? 0 : 1);
+});
 if (argv[0] === "mcp") {
   if (argv.includes("--help") || argv.includes("-h")) {
-    process2.exit(runCli(["--help"]));
-  }
-  process2.stdout.on("error", (error) => {
-    process2.exit(error.code === "EPIPE" ? 0 : 1);
-  });
-  runMcpServer({
-    input: process2.stdin,
-    write: (line) => {
-      process2.stdout.write(`${line}
+    process2.exitCode = runCli(["--help"]);
+  } else {
+    runMcpServer({
+      input: process2.stdin,
+      write: (line) => {
+        process2.stdout.write(`${line}
 `);
-    },
-    load: () => ({ manifest: loadManifest(), examples: loadExamplesIndex() }),
-    logError: (message) => {
-      process2.stderr.write(`stimeo mcp: ${message}
+      },
+      load: () => ({ manifest: loadManifest(), examples: loadExamplesIndex() }),
+      logError: (message) => {
+        process2.stderr.write(`stimeo mcp: ${message}
 `);
-    }
-  }).then(
-    // Set the exit code instead of calling process.exit so any buffered
-    // stdout responses are flushed before the process ends.
-    () => {
-      process2.exitCode = 0;
-    },
-    (error) => {
-      process2.stderr.write(
-        `stimeo mcp: ${error instanceof Error ? error.message : String(error)}
+      }
+    }).then(
+      // Set the exit code instead of calling process.exit so any buffered
+      // stdout responses are flushed before the process ends.
+      () => {
+        process2.exitCode = 0;
+      },
+      (error) => {
+        process2.stderr.write(
+          `stimeo mcp: ${error instanceof Error ? error.message : String(error)}
 `
-      );
-      process2.exitCode = 1;
-    }
-  );
+        );
+        process2.exitCode = 1;
+      }
+    );
+  }
 } else {
-  process2.exit(runCli(argv));
+  process2.exitCode = runCli(argv);
 }
 //# sourceMappingURL=cli_bin.js.map
 //# sourceMappingURL=cli_bin.js.map