@wcstack/lint 1.25.0 → 1.27.0

package/dist/cli.cjs

@@ -89,6 +89,13 @@ var WcsDiagnosticCode = {
   TokenUndeclared: "wcs/token-undeclared",
   TokenMisconfigured: "wcs/token-misconfigured",
   NestedAssign: "wcs/nested-assign",
+  // --- <wcs-state> script: $watch declaration ---
+  // ランタイム（watch/processWatchDeclaration.ts）が raiseError で落とす宣言。
+  // 越境 `@` / `$` 始まり / 空キー・空セグメント / 明らかな非関数ハンドラ。
+  WatchDeclarationInvalid: "wcs/watch-declaration-invalid",
+  // `$watch` のキーが状態定義に存在しない。バインディング側と違い黙って発火しない
+  // だけなので気づけない。severity は binding-path-missing に揃える（warning）。
+  WatchPathMissing: "wcs/watch-path-missing",
   TypeAnnotation: "wcs/type-annotation",
   TemplateSyntax: "wcs/template-syntax",
   // --- <wcs-state> script: array reactivity hazards ---
@@ -134,6 +141,8 @@ var builtinFilterMeta = {
   mul: { description: "\u4E57\u7B97", hasArgs: true, resultType: "number", acceptTypes: ["number"], minArgs: 1, maxArgs: 1, argTypes: ["number"] },
   div: { description: "\u9664\u7B97", hasArgs: true, resultType: "number", acceptTypes: ["number"], minArgs: 1, maxArgs: 1, argTypes: ["number"] },
   mod: { description: "\u5270\u4F59", hasArgs: true, resultType: "number", acceptTypes: ["number"], minArgs: 1, maxArgs: 1, argTypes: ["number"] },
+  abs: { description: "\u7D76\u5BFE\u5024", hasArgs: false, resultType: "number", acceptTypes: ["number"], minArgs: 0, maxArgs: 0 },
+  clamp: { description: "\u7BC4\u56F2\u5185\u306B\u4E38\u3081\u308B (min,max)", hasArgs: true, resultType: "number", acceptTypes: ["number"], minArgs: 2, maxArgs: 2, argTypes: ["number", "number"] },
   // 数値フォーマット
   fix: { description: "\u56FA\u5B9A\u5C0F\u6570\u70B9\u8868\u8A18", hasArgs: true, resultType: "string", acceptTypes: ["number"], minArgs: 0, maxArgs: 1, argTypes: ["number"] },
   locale: { description: "\u30ED\u30B1\u30FC\u30EB\u5F62\u5F0F\u3067\u6570\u5024\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8", hasArgs: true, resultType: "string", acceptTypes: ["number"], minArgs: 0, maxArgs: 1, argTypes: ["string"] },
@@ -147,6 +156,8 @@ var builtinFilterMeta = {
   pad: { description: "\u30D1\u30C7\u30A3\u30F3\u30B0 (length[,char])", hasArgs: true, resultType: "string", acceptTypes: ["string"], minArgs: 1, maxArgs: 2, argTypes: ["number", "string"] },
   rep: { description: "\u7E70\u308A\u8FD4\u3057 (count)", hasArgs: true, resultType: "string", acceptTypes: ["string"], minArgs: 1, maxArgs: 1, argTypes: ["number"] },
   rev: { description: "\u6587\u5B57\u9806\u3092\u53CD\u8EE2", hasArgs: false, resultType: "string", acceptTypes: ["string"], minArgs: 0, maxArgs: 0 },
+  truncate: { description: "\u5207\u308A\u8A70\u3081\u3066\u7701\u7565\u8A18\u53F7 (length[,suffix])", hasArgs: true, resultType: "string", acceptTypes: ["string"], minArgs: 1, maxArgs: 2, argTypes: ["number", "string"] },
+  join: { description: "\u914D\u5217\u3092\u9023\u7D50 ([separator])", hasArgs: true, resultType: "string", acceptTypes: ["array"], minArgs: 0, maxArgs: 1, argTypes: ["string"] },
   // 数値パース・丸め
   int: { description: "\u6574\u6570\u306B\u30D1\u30FC\u30B9", hasArgs: false, resultType: "number", acceptTypes: ["string", "number"], minArgs: 0, maxArgs: 0 },
   float: { description: "\u6D6E\u52D5\u5C0F\u6570\u70B9\u6570\u306B\u30D1\u30FC\u30B9", hasArgs: false, resultType: "number", acceptTypes: ["string", "number"], minArgs: 0, maxArgs: 0 },
@@ -154,11 +165,15 @@ var builtinFilterMeta = {
   floor: { description: "\u5207\u308A\u4E0B\u3052", hasArgs: true, resultType: "number", acceptTypes: ["number"], minArgs: 0, maxArgs: 1, argTypes: ["number"] },
   ceil: { description: "\u5207\u308A\u4E0A\u3052", hasArgs: true, resultType: "number", acceptTypes: ["number"], minArgs: 0, maxArgs: 1, argTypes: ["number"] },
   percent: { description: "\u30D1\u30FC\u30BB\u30F3\u30C6\u30FC\u30B8\u5F62\u5F0F", hasArgs: true, resultType: "string", acceptTypes: ["number"], minArgs: 0, maxArgs: 1, argTypes: ["number"] },
+  // number だけでなく string も受ける。実用チェーンは fix / percent の後ろに繋がり、
+  // それらは既に string を返すため（builtinFilters.ts の unit を参照）
+  unit: { description: "\u5358\u4F4D\uFF08\u63A5\u5C3E\u8F9E\uFF09\u3092\u4ED8\u52A0", hasArgs: true, resultType: "string", acceptTypes: ["number", "string"], minArgs: 1, maxArgs: 1, argTypes: ["string"] },
   // 日付・時刻
   date: { description: "\u30ED\u30B1\u30FC\u30EB\u5F62\u5F0F\u306E\u65E5\u4ED8", hasArgs: false, resultType: "string", acceptTypes: "any", minArgs: 0, maxArgs: 0 },
   time: { description: "\u30ED\u30B1\u30FC\u30EB\u5F62\u5F0F\u306E\u6642\u523B", hasArgs: false, resultType: "string", acceptTypes: "any", minArgs: 0, maxArgs: 0 },
   datetime: { description: "\u30ED\u30B1\u30FC\u30EB\u5F62\u5F0F\u306E\u65E5\u6642", hasArgs: false, resultType: "string", acceptTypes: "any", minArgs: 0, maxArgs: 0 },
   ymd: { description: "YYYY-MM-DD \u5F62\u5F0F", hasArgs: true, resultType: "string", acceptTypes: "any", minArgs: 0, maxArgs: 1, argTypes: ["string"] },
+  hms: { description: "HH:MM:SS \u5F62\u5F0F", hasArgs: true, resultType: "string", acceptTypes: "any", minArgs: 0, maxArgs: 1, argTypes: ["string"] },
   // 真偽値・変換
   falsy: { description: "\u507D\u5024\u304B\u5224\u5B9A", hasArgs: false, resultType: "boolean", acceptTypes: "any", minArgs: 0, maxArgs: 0 },
   truthy: { description: "\u771F\u5024\u304B\u5224\u5B9A", hasArgs: false, resultType: "boolean", acceptTypes: "any", minArgs: 0, maxArgs: 0 },
@@ -418,15 +433,18 @@ function extractAttribute(tagContent, attrName) {
 var RESERVED_STREAMS_KEY = "$streams";
 var RESERVED_COMMAND_TOKENS_KEY = "$commandTokens";
 var RESERVED_EVENT_TOKENS_KEY = "$eventTokens";
+var RESERVED_LIST_KEYS_KEY = "$listKeys";
+var RESERVED_WATCH_KEY = "$watch";
 function analyzeStatePaths(scriptContent, stateName = "default") {
   const objectContent = extractDefaultExportObject(scriptContent);
   if (!objectContent) return [];
   const paths = [];
   const topLevelProps = parseTopLevelProperties(objectContent);
   const pendingStreamValues = [];
+  const pendingListKeys = [];
   for (const prop of topLevelProps) {
     if (prop.name.startsWith("$")) {
-      collectReservedKeyPaths(prop, paths, pendingStreamValues, stateName);
+      collectReservedKeyPaths(prop, paths, pendingStreamValues, pendingListKeys, stateName);
       continue;
     }
     if (prop.kind === "method") {
@@ -434,7 +452,9 @@ function analyzeStatePaths(scriptContent, stateName = "default") {
       continue;
     }
     if (prop.kind === "getter") {
-      paths.push({ path: prop.name, kind: "computed", stateName });
+      if (!paths.some((p) => p.stateName === stateName && p.path === prop.name)) {
+        paths.push({ path: prop.name, kind: "computed", stateName });
+      }
       continue;
     }
     pushDataPropertyPaths(prop, paths, stateName);
@@ -443,9 +463,42 @@ function analyzeStatePaths(scriptContent, stateName = "default") {
     if (paths.some((p) => p.stateName === stateName && p.path === streamValue.name)) continue;
     pushDataPropertyPaths(streamValue, paths, stateName);
   }
+  for (const listKeyEntry of pendingListKeys) {
+    pushListKeyPaths(listKeyEntry, paths, stateName);
+  }
   return paths;
 }
-function collectReservedKeyPaths(prop, paths, pendingStreamValues, stateName) {
+function analyzeWatchEntries(scriptContent) {
+  const root = locateDefaultExportObject(scriptContent);
+  if (!root) return [];
+  const watchProp = parseTopLevelProperties(root.content).find((p) => p.name === RESERVED_WATCH_KEY);
+  if (!watchProp || watchProp.kind !== "data" || !watchProp.value || !isObjectLiteral(watchProp.value) || watchProp.valueStart === void 0) {
+    return [];
+  }
+  const leading = watchProp.value.length - watchProp.value.trimStart().length;
+  const innerStart = root.start + watchProp.valueStart + leading + 1;
+  const entries = [];
+  for (const entry of parseTopLevelProperties(extractObjectContent(watchProp.value))) {
+    if (entry.nameStart === void 0 || entry.nameEnd === void 0) continue;
+    entries.push({
+      key: entry.name,
+      start: innerStart + entry.nameStart,
+      end: innerStart + entry.nameEnd,
+      // メソッド短縮記法は関数。data は値リテラルの形で判定し、識別子参照は疑わない。
+      definitelyNotFunction: entry.kind === "data" && isNonFunctionLiteral(entry.value)
+    });
+  }
+  return entries;
+}
+function isNonFunctionLiteral(value) {
+  if (value === void 0) return false;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return false;
+  const scan = maskCommentsAndStrings(trimmed);
+  if (/^(?:async\s+)?function\b/.test(trimmed) || scan.includes("=>")) return false;
+  return /^["'`]/.test(trimmed) || /^-?\d/.test(trimmed) || /^(?:true|false|null|undefined)\b/.test(trimmed) || trimmed.startsWith("[") || trimmed.startsWith("{");
+}
+function collectReservedKeyPaths(prop, paths, pendingStreamValues, pendingListKeys, stateName) {
   if (prop.name === RESERVED_STREAMS_KEY && prop.kind === "data" && prop.value && isObjectLiteral(prop.value)) {
     const entries = parseTopLevelProperties(extractObjectContent(prop.value));
     for (const entry of entries) {
@@ -474,6 +527,36 @@ function collectReservedKeyPaths(prop, paths, pendingStreamValues, stateName) {
     }
     return;
   }
+  if (prop.name === RESERVED_LIST_KEYS_KEY && prop.kind === "data" && prop.value && isObjectLiteral(prop.value)) {
+    for (const entry of parseTopLevelProperties(extractObjectContent(prop.value))) {
+      if (entry.kind !== "data") continue;
+      pendingListKeys.push(entry);
+    }
+    return;
+  }
+}
+function pushListKeyPaths(entry, paths, stateName) {
+  const listPath = entry.name;
+  const segments = listPath.split(".");
+  if (listPath.length === 0 || segments.some((s) => s.length === 0) || segments[segments.length - 1] === "*") {
+    return;
+  }
+  const has = (path) => paths.some((p) => p.stateName === stateName && p.path === path);
+  if (!has(listPath)) paths.push({ path: listPath, kind: "data", typeHint: "array", stateName });
+  if (!has(`${listPath}.*`)) paths.push({ path: `${listPath}.*`, kind: "list", stateName });
+  if (!has(`${listPath}.length`)) {
+    paths.push({ path: `${listPath}.length`, kind: "data", typeHint: "number", stateName });
+  }
+  const keyField = extractStringLiteralValue(entry.value);
+  if (keyField === null || keyField.includes(".") || keyField.includes("*")) return;
+  if (!has(`${listPath}.*.${keyField}`)) {
+    paths.push({ path: `${listPath}.*.${keyField}`, kind: "data", stateName });
+  }
+}
+function extractStringLiteralValue(value) {
+  if (!value) return null;
+  const match = value.trim().match(/^["']([^"'\\]*)["']$/);
+  return match && match[1].length > 0 ? match[1] : null;
 }
 function findStreamInitialProperty(entryValue) {
   const defProps = parseTopLevelProperties(extractObjectContent(entryValue));
@@ -489,46 +572,32 @@ function extractStringArrayItems(value) {
   }
   return items;
 }
+var MAX_OBJECT_NEST_DEPTH = 5;
 function pushDataPropertyPaths(prop, paths, stateName) {
-  paths.push({ path: prop.name, kind: "data", typeHint: prop.typeHint, rawInitial: prop.value?.trim(), stateName });
+  pushDataPropertyPathsAt(prop.name, prop, paths, stateName, 0);
+}
+function pushDataPropertyPathsAt(path, prop, paths, stateName, depth) {
+  paths.push({ path, kind: "data", typeHint: prop.typeHint, rawInitial: prop.value?.trim(), stateName });
   if (prop.value && isArrayLiteral(prop.value)) {
-    paths.push({ path: `${prop.name}.*`, kind: "list", stateName });
-    paths.push({ path: `${prop.name}.length`, kind: "data", typeHint: "number", stateName });
+    paths.push({ path: `${path}.*`, kind: "list", stateName });
+    paths.push({ path: `${path}.length`, kind: "data", typeHint: "number", stateName });
     const elementProps = extractArrayElementProperties(prop.value);
     for (const childProp of elementProps) {
       paths.push({
-        path: `${prop.name}.*.${childProp.name}`,
+        path: `${path}.*.${childProp.name}`,
         kind: "data",
         typeHint: childProp.typeHint,
         stateName
       });
     }
+    return;
   }
   if (prop.value && isObjectLiteral(prop.value)) {
+    if (depth >= MAX_OBJECT_NEST_DEPTH) return;
     const childProps = parseTopLevelProperties(extractObjectContent(prop.value));
     for (const childProp of childProps) {
-      if (childProp.kind === "data") {
-        paths.push({
-          path: `${prop.name}.${childProp.name}`,
-          kind: "data",
-          typeHint: childProp.typeHint,
-          rawInitial: childProp.value?.trim(),
-          stateName
-        });
-        if (childProp.value && isArrayLiteral(childProp.value)) {
-          paths.push({ path: `${prop.name}.${childProp.name}.*`, kind: "list", stateName });
-          paths.push({ path: `${prop.name}.${childProp.name}.length`, kind: "data", typeHint: "number", stateName });
-          const grandchildProps = extractArrayElementProperties(childProp.value);
-          for (const gc of grandchildProps) {
-            paths.push({
-              path: `${prop.name}.${childProp.name}.*.${gc.name}`,
-              kind: "data",
-              typeHint: gc.typeHint,
-              stateName
-            });
-          }
-        }
-      }
+      if (childProp.kind !== "data") continue;
+      pushDataPropertyPathsAt(`${path}.${childProp.name}`, childProp, paths, stateName, depth + 1);
     }
   }
 }
@@ -575,53 +644,109 @@ function inferJsonTypeHint(value) {
   if (typeof value === "object") return "object";
   return void 0;
 }
-function extractDefaultExportObject(script) {
-  const match = script.match(/export\s+default\s+(?:defineState\s*\(\s*)?(\{)/);
+function locateDefaultExportObject(script) {
+  const scan = maskCommentsAndStrings(script);
+  const match = scan.match(/export\s+default\s+(?:defineState\s*\(\s*)?(\{)/);
   if (!match) return null;
-  const startIndex = script.indexOf(match[1], match.index);
-  return extractBracedContent(script, startIndex);
+  const braceIndex = scan.indexOf(match[1], match.index);
+  return { content: extractBracedContent(script, scan, braceIndex), start: braceIndex + 1 };
+}
+function extractDefaultExportObject(script) {
+  return locateDefaultExportObject(script)?.content ?? null;
 }
 function parseTopLevelProperties(objectContent) {
   const props = [];
-  const regex = /(?:get\s+(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*\(\s*\))|(?:(?:async\s+)?([$\w]+)\s*\([^)]*\)\s*\{)|(?:(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*:\s*)/g;
+  const scan = maskCommentsAndStrings(objectContent);
+  const regex = /(?:(?:get|set)\s+(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*\([^)]*\)\s*\{)|(?:(?:async\s+)?(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*\([^)]*\)\s*\{)|(?:(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*:\s*)/gd;
   let match;
-  while ((match = regex.exec(objectContent)) !== null) {
-    const getterName = match[1] ?? match[2] ?? match[3];
-    if (getterName) {
-      props.push({ name: getterName, kind: "getter" });
+  while ((match = regex.exec(scan)) !== null) {
+    const indices = match.indices;
+    let nameSpan;
+    const nameAt = (group) => {
+      const span = indices[group];
+      if (!span) return void 0;
+      nameSpan = [span[0], span[1]];
+      return objectContent.slice(span[0], span[1]);
+    };
+    const skipBody = () => {
+      const braceStart = match.index + match[0].length - 1;
+      const body = extractBracedContent(objectContent, scan, braceStart);
+      regex.lastIndex = braceStart + body.length + 2;
+    };
+    const accessorName = nameAt(1) ?? nameAt(2) ?? nameAt(3);
+    if (accessorName) {
+      props.push({ name: accessorName, kind: "getter", nameStart: nameSpan[0], nameEnd: nameSpan[1] });
+      skipBody();
       continue;
     }
-    const methodName = match[4];
+    const methodName = nameAt(4) ?? nameAt(5) ?? nameAt(6);
     if (methodName) {
-      props.push({ name: methodName, kind: "method" });
-      const braceStart = objectContent.indexOf("{", match.index + match[0].length - 1);
-      if (braceStart !== -1) {
-        const body = extractBracedContent(objectContent, braceStart);
-        regex.lastIndex = braceStart + body.length + 2;
-      }
+      props.push({ name: methodName, kind: "method", nameStart: nameSpan[0], nameEnd: nameSpan[1] });
+      skipBody();
       continue;
     }
-    const propName = match[5] ?? match[6] ?? match[7];
+    const propName = nameAt(7) ?? nameAt(8) ?? nameAt(9);
     if (propName) {
       const valueStartIndex = match.index + match[0].length;
-      const value = extractFullValue(objectContent, valueStartIndex);
+      const value = extractFullValue(objectContent, scan, valueStartIndex);
       const jsdocType = extractJsDocType(objectContent, match.index);
       const typeHint = jsdocType ?? inferTypeHint(value);
-      props.push({ name: propName, kind: "data", value, typeHint });
+      props.push({
+        name: propName,
+        kind: "data",
+        value,
+        typeHint,
+        nameStart: nameSpan[0],
+        nameEnd: nameSpan[1],
+        valueStart: valueStartIndex
+      });
       regex.lastIndex = valueStartIndex + value.length;
     }
   }
   return props;
 }
-function extractFullValue(content, startIndex) {
+function maskCommentsAndStrings(source) {
+  const out = source.split("");
+  const len = source.length;
+  const blank = (i2) => {
+    if (source[i2] !== "\n" && source[i2] !== "\r") out[i2] = " ";
+  };
+  let i = 0;
+  while (i < len) {
+    const ch = source[i];
+    if (ch === "/" && source[i + 1] === "/") {
+      i += 2;
+      while (i < len && source[i] !== "\n") blank(i++);
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "*") {
+      i += 2;
+      while (i < len && !(source[i] === "*" && source[i + 1] === "/")) blank(i++);
+      i += 2;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      i++;
+      while (i < len && source[i] !== ch) {
+        if (source[i] === "\\") blank(i++);
+        if (i < len) blank(i++);
+      }
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return out.join("");
+}
+function extractFullValue(content, scan, startIndex) {
   let depth = 0;
   let i = startIndex;
-  const len = content.length;
+  const len = scan.length;
   let inString = null;
   while (i < len) {
-    const ch = content[i];
+    const ch = scan[i];
     if (inString) {
-      if (ch === inString && !isEscaped(content, i)) {
+      if (ch === inString && !isEscaped(scan, i)) {
         inString = null;
       }
       i++;
@@ -641,13 +766,13 @@ function extractFullValue(content, startIndex) {
   }
   return content.slice(startIndex, i).trim();
 }
-function extractBracedContent(text, openBraceIndex) {
+function extractBracedContent(text, scan, openBraceIndex) {
   let depth = 0;
   let inString = null;
-  for (let i = openBraceIndex; i < text.length; i++) {
-    const ch = text[i];
+  for (let i = openBraceIndex; i < scan.length; i++) {
+    const ch = scan[i];
     if (inString) {
-      if (ch === inString && !isEscaped(text, i)) {
+      if (ch === inString && !isEscaped(scan, i)) {
         inString = null;
       }
       continue;
@@ -673,16 +798,18 @@ function isObjectLiteral(value) {
 }
 function extractObjectContent(value) {
   const trimmed = value.trim();
-  const start = trimmed.indexOf("{");
+  const scan = maskCommentsAndStrings(trimmed);
+  const start = scan.indexOf("{");
   if (start === -1) return "";
-  return extractBracedContent(trimmed, start);
+  return extractBracedContent(trimmed, scan, start);
 }
 function extractArrayElementProperties(value) {
   const trimmed = value.trim();
   if (!trimmed.startsWith("[")) return [];
-  const objectStart = trimmed.indexOf("{");
+  const scan = maskCommentsAndStrings(trimmed);
+  const objectStart = scan.indexOf("{");
   if (objectStart === -1) return [];
-  const objectContent = extractBracedContent(trimmed, objectStart);
+  const objectContent = extractBracedContent(trimmed, scan, objectStart);
   const props = [];
   const allProps = parseTopLevelProperties(objectContent);
   for (const prop of allProps) {
@@ -904,6 +1031,11 @@ var ja = {
   wcsTextInfo: (e) => `wcs-text \u30D0\u30A4\u30F3\u30C7\u30A3\u30F3\u30B0: ${e}`,
   moustacheFouc: (e) => `<template> \u5916\u306E {{ }} \u69CB\u6587\u306F FOUC\uFF08\u521D\u671F\u8868\u793A\u6642\u306B\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8\u6587\u5B57\u5217\u304C\u898B\u3048\u308B\uFF09\u306E\u539F\u56E0\u306B\u306A\u308A\u307E\u3059\u3002<!--@@:${e}--> \u307E\u305F\u306F\u30B3\u30E1\u30F3\u30C8\u69CB\u6587\u306E\u4F7F\u7528\u3092\u691C\u8A0E\u3057\u3066\u304F\u3060\u3055\u3044\u3002`,
   nestedAssign: (sp) => `\u30CD\u30B9\u30C8\u3055\u308C\u305F\u30D7\u30ED\u30D1\u30C6\u30A3\u3078\u306E\u4EE3\u5165\u306F\u30EA\u30A2\u30AF\u30C6\u30A3\u30D6\u66F4\u65B0\u3092\u30C8\u30EA\u30AC\u30FC\u3057\u307E\u305B\u3093\u3002this["${sp}"] \u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002`,
+  watchKeyCrossState: (k) => `$watch \u306E\u30AD\u30FC "${k}" \u306F\u4ED6\u306E state \u3092\u6307\u3057\u3066\u3044\u307E\u3059\u3002@ \u4ED8\u304D\u306E\u8D8A\u5883 watch \u306F\u4F7F\u3048\u307E\u305B\u3093\uFF08\u81EA state \u306E\u30D1\u30B9\u306E\u307F\uFF09`,
+  watchKeyReserved: (k) => `$watch \u306E\u30AD\u30FC "${k}" \u306F "$" \u3067\u59CB\u3081\u3089\u308C\u307E\u305B\u3093\uFF08\u4E88\u7D04\u540D\u524D\u7A7A\u9593\uFF09`,
+  watchKeyEmptySegment: (k) => `$watch \u306E\u30AD\u30FC "${k}" \u306B\u7A7A\u306E\u30D1\u30B9\u30BB\u30B0\u30E1\u30F3\u30C8\u304C\u3042\u308A\u307E\u3059`,
+  watchHandlerNotFunction: (k) => `$watch \u306E\u30A8\u30F3\u30C8\u30EA "${k}" \u306E\u5024\u306F\u95A2\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  watchPathMissing: (k) => `$watch \u306E\u30AD\u30FC "${k}" \u306F\u72B6\u614B\u5B9A\u7FA9\u306B\u5B58\u5728\u3057\u307E\u305B\u3093\uFF08\u4E00\u5EA6\u3082\u767A\u706B\u3057\u307E\u305B\u3093\uFF09`,
   typeAnnotationIncompatible: (vt, rt) => `\u578B "${vt}" \u306F @type {${rt}} \u3068\u4E92\u63DB\u6027\u304C\u3042\u308A\u307E\u305B\u3093`,
   arrayMutation: (m, alt) => `\u914D\u5217\u306E\u7834\u58CA\u7684\u30E1\u30BD\u30C3\u30C9 "${m}" \u306F\u30EA\u30A2\u30AF\u30C6\u30A3\u30D6\u66F4\u65B0\u3092\u30C8\u30EA\u30AC\u30FC\u3057\u307E\u305B\u3093\uFF08\u540C\u4E00\u53C2\u7167\u306E\u81EA\u5DF1\u518D\u4EE3\u5165\u3067\u3082\u8981\u7D20\u306E\u8FFD\u52A0\u30FB\u524A\u9664\u306F\u53CD\u6620\u3055\u308C\u307E\u305B\u3093\uFF09\u3002\u975E\u7834\u58CA\u30E1\u30BD\u30C3\u30C9\u3068\u518D\u4EE3\u5165\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\uFF08\u4F8B: ${alt}\uFF09\u3002`,
   arrayIndexAssign: (sp) => `\u914D\u5217\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u3078\u306E\u76F4\u63A5\u4EE3\u5165\u306F\u30EA\u30A2\u30AF\u30C6\u30A3\u30D6\u66F4\u65B0\u3092\u30C8\u30EA\u30AC\u30FC\u3057\u307E\u305B\u3093\u3002this["${sp}"] \u306E\u3088\u3046\u306A\u30C9\u30C3\u30C8\u30D1\u30B9\u4EE3\u5165\u3001\u307E\u305F\u306F with() \u3068\u518D\u4EE3\u5165\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002`,
@@ -946,6 +1078,11 @@ var en = {
   wcsTextInfo: (e) => `wcs-text binding: ${e}`,
   moustacheFouc: (e) => `{{ }} outside a <template> causes FOUC (the raw template string is visible before binding). Consider the comment syntax <!--@@:${e}--> instead.`,
   nestedAssign: (sp) => `Assigning to a nested property does not trigger a reactive update. Use this["${sp}"] instead.`,
+  watchKeyCrossState: (k) => `$watch key "${k}" targets another state. Cross-state watching with @ is not supported (own paths only)`,
+  watchKeyReserved: (k) => `$watch key "${k}" must not start with "$" (reserved namespace)`,
+  watchKeyEmptySegment: (k) => `$watch key "${k}" has an empty path segment`,
+  watchHandlerNotFunction: (k) => `The value of $watch entry "${k}" must be a function`,
+  watchPathMissing: (k) => `$watch key "${k}" does not exist in the state definition (it will never fire)`,
   typeAnnotationIncompatible: (vt, rt) => `Type "${vt}" is not compatible with @type {${rt}}`,
   arrayMutation: (m, alt) => `Destructive array method "${m}" does not trigger a reactive update (re-assigning the same reference does not reflect added/removed elements either). Use a non-destructive method with reassignment (e.g. ${alt}).`,
   arrayIndexAssign: (sp) => `Assigning directly to an array index does not trigger a reactive update. Use a dot-path assignment like this["${sp}"], or with() plus reassignment.`,
@@ -978,6 +1115,11 @@ function validateBindings(html, attrName, stateTagName = "wcs-state", locale) {
     pathsByState.set(p.stateName, list);
   }
   const attrs = findAllBindAttributes(html, attrName);
+  let structuralTemplates = null;
+  const getStructuralTemplates = () => {
+    structuralTemplates ??= collectStructuralTemplates(html, attrName);
+    return structuralTemplates;
+  };
   const filterNameSet = new Set(BUILTIN_FILTERS.map((f) => f.name));
   for (const attr of attrs) {
     const bindings = splitBindingExpressions(attr.value);
@@ -1063,7 +1205,7 @@ function validateBindings(html, attrName, stateTagName = "wcs-state", locale) {
           if (pathTrimmed.startsWith(".")) {
             const forPath = getInnermostForPath(html, attr.valueStart, attrName);
             if (forPath && !forPath.startsWith(".")) {
-              checkPath = `${forPath}.*.${pathTrimmed.slice(1)}`;
+              checkPath = pathTrimmed === "." ? `${forPath}.*` : `${forPath}.*.${pathTrimmed.slice(1)}`;
             } else {
               checkPath = "";
             }
@@ -1172,7 +1314,10 @@ function validateBindings(html, attrName, stateTagName = "wcs-state", locale) {
         if (pathTrimmed && !pathTrimmed.startsWith(".") && !isLiteral(pathTrimmed)) {
           const resultType = resolveResultType(pathTrimmed, parsed.filters, scopedPaths);
           if (resultType !== null) {
-            const typeReq = getExpectedType(parsed.property);
+            const typeReq = getExpectedType(
+              parsed.property,
+              () => isNegatedByElseChain(getStructuralTemplates(), attr.valueStart)
+            );
             if (typeReq && resultType !== typeReq.expected) {
               const pathOffset = binding.indexOf(parsed.path);
               const pathStart = bindingStart + pathOffset;
@@ -1352,12 +1497,54 @@ function validatePathExistence(checkPath, displayPath, scopedPaths, scopedPathSe
   }
   return null;
 }
-function getExpectedType(property) {
+function collectStructuralTemplates(html, attrName) {
+  const escaped = attrName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const attrRegex = new RegExp(`${escaped}\\s*=\\s*(["'])`, "i");
+  const tagRegex = /<template(?:\s[^>]*)?>|<\/template\s*>/gi;
+  const templates = [];
+  let depth = 0;
+  let match;
+  while ((match = tagRegex.exec(html)) !== null) {
+    if (match[0].startsWith("</")) {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    const attrMatch = attrRegex.exec(match[0]);
+    if (attrMatch) {
+      const quote = attrMatch[1];
+      const valueStart = match.index + attrMatch.index + attrMatch[0].length;
+      const valueEnd = html.indexOf(quote, valueStart);
+      if (valueEnd !== -1) {
+        const first = splitBindingExpressions(html.slice(valueStart, valueEnd))[0] ?? "";
+        const prop = first.split(":")[0].replace(/#.*$/, "").trim();
+        const type = prop === "if" || prop === "elseif" || prop === "else" ? prop : "other";
+        templates.push({ valueStart, depth, type });
+      }
+    }
+    depth++;
+  }
+  return templates;
+}
+function isNegatedByElseChain(templates, valueStart) {
+  const index = templates.findIndex((t) => t.valueStart === valueStart);
+  if (index === -1) return false;
+  const selfDepth = templates[index].depth;
+  for (let i = index + 1; i < templates.length; i++) {
+    const next = templates[i];
+    if (next.depth > selfDepth) continue;
+    if (next.depth < selfDepth) return false;
+    if (next.type === "elseif" || next.type === "else") return true;
+    if (next.type === "if") return false;
+  }
+  return false;
+}
+function getExpectedType(property, isNegatedIf) {
   const prop = property.replace(/#.*$/, "");
   if (prop === "for") {
     return { label: "for", expected: "array", severity: "error" };
   }
   if (prop === "if" || prop === "elseif") {
+    if (!isNegatedIf()) return null;
     return { label: prop, expected: "boolean", severity: "warning" };
   }
   if (prop.startsWith("class.")) {
@@ -1696,20 +1883,18 @@ function findAllCommentBindings(html, commentTextPrefix = "wcs-text") {
   return results;
 }
 function isInsideTag(html, offset, tagName) {
-  const openRegex = new RegExp(`<${tagName}[\\s>]`, "gi");
-  const closeRegex = new RegExp(`</${tagName}>`, "gi");
-  let lastOpenEnd = -1;
-  let lastCloseEnd = -1;
+  const tagRegex = new RegExp(`<(/?)${tagName}[\\s>]`, "gi");
+  let depth = 0;
   let match;
-  while ((match = openRegex.exec(html)) !== null) {
-    if (match.index > offset) break;
-    lastOpenEnd = match.index;
-  }
-  while ((match = closeRegex.exec(html)) !== null) {
+  while ((match = tagRegex.exec(html)) !== null) {
     if (match.index > offset) break;
-    lastCloseEnd = match.index;
+    if (match[1]) {
+      depth = Math.max(0, depth - 1);
+    } else {
+      depth++;
+    }
   }
-  return lastOpenEnd > lastCloseEnd;
+  return depth > 0;
 }
 
 // src/service/templateSyntaxValidator.ts
@@ -1779,7 +1964,7 @@ function validateTemplateSyntax(html, stateTagName, bindAttrName = "data-wcs", l
       if (pathPart.startsWith(".")) {
         const forPath = insideFor ? getInnermostForPath(html, item.matchStart, bindAttrName) : null;
         if (forPath && !forPath.startsWith(".")) {
-          const expandedPath = `${forPath}.*.${pathPart.slice(1)}`;
+          const expandedPath = pathPart === "." ? `${forPath}.*` : `${forPath}.*.${pathPart.slice(1)}`;
           if (!isValidTemplatePath(expandedPath, pathSet, defaultPaths)) {
             diagnostics.push({
               code: WcsDiagnosticCode.BindingPathMissing,
@@ -2963,6 +3148,55 @@ function blankJsComments(code) {
   return code.replace(/\/\*[\s\S]*?\*\//g, (m) => " ".repeat(m.length)).replace(/(^|[^:])\/\/[^\n]*/g, (m, pre) => pre + " ".repeat(m.length - pre.length));
 }
 
+// src/service/watchDeclarationValidator.ts
+var STATE_NAME_SEPARATOR = "@";
+function validateWatchDeclarations(html, stateTagName = "wcs-state", locale) {
+  const msgs = getMessages(locale);
+  const out = [];
+  for (const block of parseWcsScriptBlocks(html, stateTagName)) {
+    const entries = analyzeWatchEntries(block.content);
+    if (entries.length === 0) continue;
+    const paths = analyzeStatePaths(block.content, block.stateName);
+    const pathSet = new Set(paths.map((p) => p.path));
+    for (const entry of entries) {
+      const diagnostic = validateEntry(entry, pathSet, msgs);
+      if (diagnostic === null) continue;
+      out.push({
+        code: diagnostic.code,
+        start: block.contentStart + entry.start,
+        end: block.contentStart + entry.end,
+        message: diagnostic.message,
+        severity: diagnostic.severity
+      });
+    }
+  }
+  return out;
+}
+function validateEntry(entry, pathSet, msgs) {
+  const { key } = entry;
+  const invalid = (message) => ({ code: WcsDiagnosticCode.WatchDeclarationInvalid, message, severity: "error" });
+  if (key.includes(STATE_NAME_SEPARATOR)) {
+    return invalid(msgs.watchKeyCrossState(key));
+  }
+  if (key.startsWith("$")) {
+    return invalid(msgs.watchKeyReserved(key));
+  }
+  if (key.split(".").some((segment) => segment.length === 0)) {
+    return invalid(msgs.watchKeyEmptySegment(key));
+  }
+  if (entry.definitelyNotFunction) {
+    return invalid(msgs.watchHandlerNotFunction(key));
+  }
+  if (pathSet.size > 0 && !pathSet.has(key)) {
+    return {
+      code: WcsDiagnosticCode.WatchPathMissing,
+      message: msgs.watchPathMissing(key),
+      severity: "warning"
+    };
+  }
+  return null;
+}
+
 // src/core/validateDocument.ts
 function validateDocument(text, options = {}) {
   const bindAttribute = options.bindAttribute ?? "data-wcs";
@@ -2974,6 +3208,7 @@ function validateDocument(text, options = {}) {
   out.push(...validateIoNodes(text, bindAttribute, stateTagName, locale));
   out.push(...validateDocumentEnv(text, locale));
   out.push(...validateArrayMutations(text, stateTagName, locale));
+  out.push(...validateWatchDeclarations(text, stateTagName, locale));
   for (const d of validateStateTypes(text, stateTagName, locale)) {
     out.push({ code: WcsDiagnosticCode.TypeAnnotation, start: d.start, end: d.end, message: d.message, severity: d.severity });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wcstack/lint",
-  "version": "1.25.0",
+  "version": "1.27.0",
   "description": "Static-contract validator CLI (wcs-validate) for wcstack data-wcs bindings and wcstack.manifest.json sidecars. Thin npm wrapper around the wcstack-intellisense validator core.",
   "type": "module",
   "bin": {