@wcstack/typescript 2.2.0 → 2.4.0

package/dist/schema-core.cjs

@@ -93,6 +93,44 @@ var WcsDiagnosticCode = {
   // `$watch` のキーが状態定義に存在しない。バインディング側と違い黙って発火しない
   // だけなので気づけない。severity は binding-path-missing に揃える（warning）。
   WatchPathMissing: "wcs/watch-path-missing",
+  // --- <wcs-state> script: $scan declaration ---
+  // ランタイム（scan/processScanDeclaration.ts）が raiseError で落とす宣言の形。出力名・source の本数・
+  // initial / fold の欠落・from / resetOn のパスの形・未宣言トークン・自出力の読み。
+  ScanDeclarationInvalid: "wcs/scan-declaration-invalid",
+  // from / resetOn が getter（またはその配下）。畳むと出来事ではなく再評価の回数を数える。ランタイムも raise。
+  ScanSourceComputed: "wcs/scan-source-computed",
+  // from / resetOn のパスが状態定義に存在しない。黙って一度も畳まれない。severity は watch-path-missing に揃える。
+  ScanPathMissing: "wcs/scan-path-missing",
+  // --- <wcs-state> script: $recursion declaration / `**` paths ---
+  // ランタイムと同じ code 語彙(@wcstack/state src/recursion/ が正本。
+  // docs/state-recursive-path-impl-plan.md §7)。静的に出すのは**パス文字列と宣言だけで
+  // 決まる**ものに限る。データを見ないと決まらない wcs/recursion-shared-list /
+  // wcs/recursion-cycle / wcs/recursion-depth-exceeded、および評価時の呼び出し文脈に
+  // 依存する wcs/recursion-context は runtime 専用(静的側は出さない)。
+  //
+  // `**` を解釈しない場所へ `**` が渡った(data-wcs / mustache / $watch キー / $listKeys
+  // キー / $resolve / $postUpdate / $trackDependency / 代入)、または `$recursion` 宣言が
+  // 無いのに `**` を使った。runtime は PathInfo の不変条件として raiseError するか
+  //(API 経由)、getter を黙って無視する(宣言なしの `**` getter)。
+  RecursionUnsupported: "wcs/recursion-unsupported",
+  // 宣言済みアンカーと合致しない `**`(綴り違い・2 つ目の `**`)、または `**` の後ろが
+  // 整形されていない(空セグメント・`**` 直後の素の `*`)。
+  RecursionAnchor: "wcs/recursion-anchor",
+  // `$getAll` の添字の形が `**` に対して定義できない(非空の接頭辞 / 配列でない値)。
+  RecursionGetAllForm: "wcs/recursion-getall-form",
+  // `$setAll` の添字・値の形が `**` に対して定義できない
+  //(非空の接頭辞 / 添字省略 / mapper / spread)。
+  RecursionSetAllForm: "wcs/recursion-setall-form",
+  // ノード自身・子リスト・子ノード・子リストの length・多段の反復サブパスなら子リストへ
+  // 至る途中のオブジェクトへの一括書き込み(確定済みの子アドレスを壊す)。
+  RecursionStructuralWrite: "wcs/recursion-structural-write",
+  // 再帰 getter(およびその派生値の中)への書き込み。setter は初版では持てない。
+  RecursionReadonly: "wcs/recursion-readonly",
+  // `$recursion` 宣言そのもの、または `**` getter の宣言の形が不正(アンカー / 反復
+  // サブパスの形・複数宣言・setter・getter でない・ノード自身・構造を名指す接尾辞・
+  // 展開形と同名の具体 getter・ボリューム / マウント下での宣言)。
+  //(ランタイムは初期化時に raiseError)。wcs/watch-declaration-invalid の再帰版。
+  RecursionDeclarationInvalid: "wcs/recursion-declaration-invalid",
   TypeAnnotation: "wcs/type-annotation",
   TemplateSyntax: "wcs/template-syntax",
   // --- <wcs-state> script: array reactivity hazards ---
@@ -1270,6 +1308,8 @@ var STATE_EVENT_TOKENS_NAME = "$eventTokens";
 var STATE_ON_NAME = "$on";
 var STATE_STREAMS_NAME = "$streams";
 var STATE_WATCH_NAME = "$watch";
+var STATE_SCAN_NAME = "$scan";
+var STATE_RECURSION_NAME = "$recursion";
 var STATE_LIST_KEYS_NAME = "$listKeys";
 var STATE_STREAM_STATUS_NAMESPACE_NAME = "$streamStatus";
 var STATE_STREAM_ERROR_NAMESPACE_NAME = "$streamError";
@@ -1331,7 +1371,9 @@ function getWcsManifest() {
       STATE_ON_NAME,
       STATE_STREAMS_NAME,
       STATE_WATCH_NAME,
+      STATE_SCAN_NAME,
       STATE_LIST_KEYS_NAME,
+      STATE_RECURSION_NAME,
       STATE_STREAM_STATUS_NAMESPACE_NAME,
       STATE_STREAM_ERROR_NAMESPACE_NAME
     ]
@@ -1353,12 +1395,174 @@ var STRUCTURAL_DIRECTIVES = [...STRUCTURAL_BINDING_TYPE_SET].map((name) => ({
   ...STRUCTURAL_DIRECTIVE_INFO[name]
 }));
 
+// src/service/recursionPaths.ts
+var RECURSION_WILDCARD = "**";
+var RECURSION_KEY = "$recursion";
+function hasRecursionWildcard(path) {
+  return path.indexOf(RECURSION_WILDCARD) !== -1;
+}
+function checkNodePath(path) {
+  if (typeof path !== "string" || path.length === 0) return "empty";
+  const segments = path.split(".");
+  if (segments.some((segment) => segment.length === 0)) return "emptySegment";
+  if (segments.length < 2 || segments[segments.length - 1] !== "*") return "notElement";
+  if (segments[0].startsWith("$")) return "reservedRoot";
+  if (path.indexOf("#") !== -1) return "reservedMount";
+  for (let i = 0; i < segments.length - 1; i++) {
+    if (segments[i] === "*") return "midWildcard";
+    if (segments[i] === RECURSION_WILDCARD) return "nestedRecursion";
+    if (!isNaN(Number(segments[i]))) return "indexSegment";
+  }
+  return null;
+}
+function makeRecursionSpec(anchor, repeat) {
+  return Object.freeze({
+    anchor,
+    repeat,
+    recursiveAnchor: anchor.slice(0, anchor.lastIndexOf(".")) + "." + RECURSION_WILDCARD,
+    anchorList: anchor.slice(0, anchor.lastIndexOf(".")),
+    repeatList: repeat.slice(0, repeat.lastIndexOf("."))
+  });
+}
+function splitRecursivePath(spec, path) {
+  if (path === spec.recursiveAnchor) return "";
+  if (!path.startsWith(spec.recursiveAnchor + ".")) return null;
+  const suffix = path.slice(spec.recursiveAnchor.length);
+  if (hasRecursionWildcard(suffix)) return null;
+  const segments = suffix.slice(1).split(".");
+  if (segments[0] === "*" || segments.some((segment) => segment.length === 0)) return null;
+  return suffix;
+}
+function foldSuffixIndexes(suffix) {
+  return suffix.length === 0 ? suffix : "." + indexSegmentsToWildcard(suffix.slice(1));
+}
+function foldRecursion(spec, path) {
+  if (!path.startsWith(spec.anchor)) return null;
+  const unit3 = "." + spec.repeat;
+  let cursor = spec.anchor.length;
+  let depth = 0;
+  while (path.startsWith(unit3, cursor)) {
+    cursor += unit3.length;
+    depth++;
+  }
+  if (cursor !== path.length && path.charCodeAt(cursor) !== 46) return null;
+  return { depth, rest: path.slice(cursor) };
+}
+function matchesRecursion(specs, path, has) {
+  for (const spec of specs) {
+    const folded = foldRecursion(spec, path);
+    if (folded === null) continue;
+    const unit3 = "." + spec.repeat;
+    for (let depth = folded.depth; depth >= 0; depth--) {
+      const rest = unit3.repeat(folded.depth - depth) + folded.rest;
+      if (has(spec.anchor + rest)) return true;
+      if (has(spec.recursiveAnchor + rest)) return true;
+      for (let dot = rest.lastIndexOf("."); dot > 0; dot = rest.lastIndexOf(".", dot - 1)) {
+        if (has(spec.recursiveAnchor + rest.slice(0, dot))) return true;
+      }
+    }
+  }
+  return false;
+}
+function owningGetterSuffix(spec, getterSuffixes, path) {
+  const pattern = indexSegmentsToWildcard(path);
+  const folded = foldRecursion(spec, pattern);
+  if (folded === null) return null;
+  const unit3 = "." + spec.repeat;
+  for (const suffix of getterSuffixes) {
+    for (let depth = folded.depth; depth >= 0; depth--) {
+      const expansion = spec.anchor + unit3.repeat(depth) + suffix;
+      if (pattern === expansion || pattern.startsWith(expansion + ".")) return suffix;
+    }
+  }
+  return null;
+}
+function indexSegmentsToWildcard(path) {
+  return path.split(".").map((segment) => segment !== "*" && !Number.isNaN(Number(segment)) ? "*" : segment).join(".");
+}
+function concreteExpansionSuffix(spec, getterSuffixes, key) {
+  const folded = foldRecursion(spec, key);
+  if (folded === null) return null;
+  const unit3 = "." + spec.repeat;
+  for (const suffix of getterSuffixes) {
+    for (let depth = folded.depth; depth >= 0; depth--) {
+      if (key === spec.anchor + unit3.repeat(depth) + suffix) return suffix;
+    }
+  }
+  return null;
+}
+function collectRecursionSpecs(candidates) {
+  const out = [];
+  for (const candidate of candidates) {
+    if (candidate.kind !== "recursionAnchor" || typeof candidate.repeat !== "string") continue;
+    if (!candidate.path.endsWith("." + RECURSION_WILDCARD)) continue;
+    const anchor = candidate.path.slice(0, candidate.path.length - RECURSION_WILDCARD.length) + "*";
+    if (out.some((spec) => spec.anchor === anchor && spec.repeat === candidate.repeat)) continue;
+    out.push(makeRecursionSpec(anchor, candidate.repeat));
+  }
+  return out;
+}
+function impliedStructurePaths(spec) {
+  const out = [
+    { path: spec.anchorList, kind: "data", typeHint: "array" },
+    { path: spec.anchor, kind: "list" },
+    { path: `${spec.anchorList}.length`, kind: "data", typeHint: "number" }
+  ];
+  const repeatSegments = spec.repeatList.split(".");
+  for (let i = 1; i < repeatSegments.length; i++) {
+    out.push({ path: `${spec.anchor}.${repeatSegments.slice(0, i).join(".")}`, kind: "data" });
+  }
+  out.push({ path: `${spec.anchor}.${spec.repeatList}`, kind: "data", typeHint: "array" });
+  out.push({ path: `${spec.anchor}.${spec.repeat}`, kind: "list" });
+  out.push({ path: `${spec.anchor}.${spec.repeatList}.length`, kind: "data", typeHint: "number" });
+  return out;
+}
+function structuralWriteTarget(spec, suffix) {
+  const unit3 = "." + spec.repeat;
+  let rest = suffix;
+  while (rest.startsWith(unit3)) rest = rest.slice(unit3.length);
+  if (rest.length === 0) return "node";
+  if (rest === "." + spec.repeatList + ".length") return "length";
+  const segments = spec.repeatList.split(".");
+  for (let i = 1; i <= segments.length; i++) {
+    if (rest === "." + segments.slice(0, i).join(".")) return i === segments.length ? "list" : "branch";
+  }
+  return null;
+}
+function sameFamily(spec, a, b) {
+  const unit3 = "." + spec.repeat;
+  const shorter = a.length <= b.length ? a : b;
+  const longer = a.length <= b.length ? b : a;
+  if (!longer.endsWith(shorter)) return false;
+  const gap = longer.slice(0, longer.length - shorter.length);
+  if (gap.length === 0) return true;
+  if (gap.length % unit3.length !== 0) return false;
+  for (let cursor = 0; cursor < gap.length; cursor += unit3.length) {
+    if (!gap.startsWith(unit3, cursor)) return false;
+  }
+  return true;
+}
+function conflictingGetterSuffix(spec, getterSuffixes, suffix) {
+  for (const declared of getterSuffixes) {
+    if (coversSuffix(spec, declared, suffix)) return declared;
+  }
+  return null;
+}
+function coversSuffix(spec, familySuffix, suffix) {
+  for (let end = suffix.length; end > 0; end = suffix.lastIndexOf(".", end - 1)) {
+    if (sameFamily(spec, familySuffix, suffix.slice(0, end))) return true;
+  }
+  return false;
+}
+
 // src/service/stateAnalyzer.ts
 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";
+var RESERVED_SCAN_KEY = "$scan";
+var RESERVED_RECURSION_KEY = RECURSION_KEY;
 function analyzeStatePaths(scriptContent) {
   const objectContent = extractDefaultExportObject(scriptContent);
   if (!objectContent) return [];
@@ -1366,51 +1570,290 @@ function analyzeStatePaths(scriptContent) {
   const topLevelProps = parseTopLevelProperties(objectContent);
   const pendingStreamValues = [];
   const pendingListKeys = [];
+  const recursionSpec = specFromRecursionValue(topLevelProps.find((p) => p.name === RESERVED_RECURSION_KEY));
+  const effectiveDescriptors = effectiveTopLevelDescriptors(topLevelProps);
   for (const prop of topLevelProps) {
     if (prop.name.startsWith("$")) {
       collectReservedKeyPaths(prop, paths, pendingStreamValues, pendingListKeys);
       continue;
     }
+    const effective = effectiveDescriptors.get(prop.name);
+    if (prop.kind === "getter" !== (effective !== "data")) {
+      continue;
+    }
     if (prop.kind === "method") {
       paths.push({ path: prop.name, kind: "method" });
       continue;
     }
     if (prop.kind === "getter") {
-      if (!paths.some((p) => p.path === prop.name)) {
-        paths.push({ path: prop.name, kind: "computed" });
+      const { get, set } = effective;
+      const writeOnly = set && !get;
+      const declared = paths.find((p) => p.path === prop.name);
+      if (declared === void 0) {
+        const kind = hasRecursionWildcard(prop.name) ? "recursive" : "computed";
+        paths.push(writeOnly ? { path: prop.name, kind, writeOnly: true } : { path: prop.name, kind });
+      } else if (writeOnly) {
+        declared.writeOnly = true;
       }
       continue;
     }
     pushDataPropertyPaths(prop, paths);
   }
   for (const streamValue of pendingStreamValues) {
-    if (paths.some((p) => p.path === streamValue.name)) continue;
+    if (paths.some((p) => p.path === streamValue.name && p.kind !== "eventToken")) continue;
     pushDataPropertyPaths(streamValue, paths);
   }
   for (const listKeyEntry of pendingListKeys) {
     pushListKeyPaths(listKeyEntry, paths);
   }
+  if (recursionSpec !== null) {
+    if (!paths.some((p) => p.path === recursionSpec.recursiveAnchor && p.kind === "recursionAnchor")) {
+      paths.push({ path: recursionSpec.recursiveAnchor, kind: "recursionAnchor", repeat: recursionSpec.repeat });
+    }
+    for (const implied of impliedStructurePaths(recursionSpec)) {
+      if (paths.some((p) => p.path === implied.path)) continue;
+      paths.push({ path: implied.path, kind: implied.kind, typeHint: implied.typeHint });
+    }
+  }
   collectRowShapesFromAssignments(scriptContent, paths);
   return paths;
 }
+function specFromRecursionValue(prop) {
+  if (!prop || prop.kind !== "data" || !prop.value || !isObjectLiteral(prop.value)) return null;
+  const entries = parseTopLevelProperties(extractObjectContent(prop.value)).filter((e) => e.kind === "data");
+  if (entries.length !== 1) return null;
+  const anchor = entries[0].name;
+  const repeat = extractStringLiteralValue(entries[0].value);
+  if (repeat === null) return null;
+  if (checkNodePath(anchor) !== null || checkNodePath(repeat) !== null) return null;
+  return makeRecursionSpec(anchor, repeat);
+}
+function analyzeRecursionDeclaration(scriptContent) {
+  const root = locateDefaultExportObject(scriptContent);
+  if (!root) return null;
+  const prop = parseTopLevelProperties(root.content).find((p) => p.name === RESERVED_RECURSION_KEY);
+  if (!prop || prop.nameStart === void 0 || prop.nameEnd === void 0) return null;
+  const span = { start: root.start + prop.nameStart, end: root.start + prop.nameEnd };
+  if (prop.kind === "method") {
+    return { ...span, notObject: true, objectLiteral: false, entries: [], spec: null };
+  }
+  if (prop.kind !== "data" || !prop.value || prop.valueStart === void 0) {
+    return { ...span, notObject: false, objectLiteral: false, entries: [], spec: null };
+  }
+  if (!isObjectLiteral(prop.value)) {
+    const scan = maskCommentsAndStrings(prop.value).trim();
+    const definite = /^(["'`])[^"'`]*\1$/.test(scan) || /^-?\d[\w.]*$/.test(scan) || /^(?:true|false|null)$/.test(scan) || /^\[/.test(scan) || /^(?:async\s+)?function\b[\s\S]*\}$/.test(scan) || /^(?:async\s+)?\([^()]*\)\s*=>/.test(scan) || /^(?:async\s+)?[$\w]+\s*=>/.test(scan);
+    return { ...span, notObject: definite, objectLiteral: false, entries: [], spec: null };
+  }
+  const objectContent = extractObjectContent(prop.value);
+  if (hasUndecidableEntries(objectContent)) {
+    return { ...span, notObject: false, objectLiteral: false, entries: [], spec: null };
+  }
+  const leading = prop.value.length - prop.value.trimStart().length;
+  const innerStart = root.start + prop.valueStart + leading + 1;
+  const entries = [];
+  for (const entry of parseTopLevelProperties(objectContent)) {
+    if (entry.nameStart === void 0 || entry.nameEnd === void 0) continue;
+    const valueStart = entry.valueStart === void 0 ? innerStart + entry.nameEnd : innerStart + entry.valueStart + (entry.value ? entry.value.length - entry.value.trimStart().length : 0);
+    entries.push({
+      anchor: entry.name,
+      repeat: entry.kind === "data" ? extractStringLiteralValue(entry.value) : null,
+      repeatDefinitelyNotString: entry.kind !== "data" || isDefiniteNonStringLiteral(entry.value),
+      start: innerStart + entry.nameStart,
+      end: innerStart + entry.nameEnd,
+      valueStart,
+      valueEnd: valueStart + (entry.value?.trim().length ?? 0)
+    });
+  }
+  return { ...span, notObject: false, objectLiteral: true, entries, spec: specFromRecursionValue(prop) };
+}
 function analyzeWatchEntries(scriptContent) {
+  return analyzeObjectEntries(scriptContent, RESERVED_WATCH_KEY).map((entry) => ({
+    key: entry.key,
+    start: entry.start,
+    end: entry.end,
+    // メソッド短縮記法は関数。data は値リテラルの形で判定し、識別子参照は疑わない。
+    definitelyNotFunction: entry.kind === "data" && isNonFunctionLiteral(entry.value)
+  }));
+}
+function analyzeListKeyEntries(scriptContent) {
+  return analyzeObjectEntries(scriptContent, RESERVED_LIST_KEYS_KEY).map((entry) => ({ key: entry.key, start: entry.start, end: entry.end }));
+}
+function analyzeScanEntries(scriptContent) {
+  return analyzeObjectEntries(scriptContent, RESERVED_SCAN_KEY, true).map(describeScanEntry);
+}
+function describeScanEntry(entry) {
+  const unreadable = {
+    name: entry.key,
+    start: entry.start,
+    end: entry.end,
+    notObject: false,
+    readable: false,
+    hasFrom: false,
+    hasOn: false,
+    from: null,
+    on: null,
+    hasInitial: false,
+    foldMissingOrNotFunction: false,
+    resetOn: null,
+    resetOnNotArray: false,
+    fromNotString: false,
+    onNotString: false,
+    resetOnHasNonString: false
+  };
+  if (entry.kind === "method") {
+    return { ...unreadable, notObject: true };
+  }
+  const value = entry.value;
+  if (entry.kind !== "data" || value === void 0 || entry.valueStart === void 0) {
+    return unreadable;
+  }
+  if (!isObjectLiteral(value)) {
+    return { ...unreadable, notObject: isDefiniteNonObjectLiteral(value) };
+  }
+  const content = extractObjectContent(value);
+  if (hasUndecidableEntries(content)) {
+    return unreadable;
+  }
+  const contentStart = entry.valueStart + 1;
+  const props = parseTopLevelProperties(content);
+  const find = (name) => props.find((p) => p.name === name && !(p.kind === "data" && p.value?.trim() === "undefined"));
+  const foldProp = find("fold");
+  const resetProp = find("resetOn");
+  return {
+    ...unreadable,
+    readable: true,
+    hasFrom: find("from") !== void 0,
+    hasOn: find("on") !== void 0,
+    from: scanStringField(find("from"), contentStart),
+    on: scanStringField(find("on"), contentStart),
+    hasInitial: props.some((p) => p.name === "initial"),
+    foldMissingOrNotFunction: foldProp === void 0 || foldProp.kind === "data" && isNonFunctionLiteral(foldProp.value),
+    resetOn: resetProp === void 0 ? null : scanStringArrayFields(resetProp, contentStart),
+    resetOnNotArray: resetProp !== void 0 && resetProp.kind === "data" && isDefiniteNonArrayLiteral(resetProp.value),
+    fromNotString: isDefiniteNonPathValue(find("from")),
+    onNotString: isDefiniteNonPathValue(find("on")),
+    resetOnHasNonString: resetProp !== void 0 && resetProp.kind === "data" && resetProp.value !== void 0 && hasDefiniteNonStringElement(resetProp.value)
+  };
+}
+function isDefiniteNonPathValue(prop) {
+  if (prop === void 0 || prop.kind === "getter") return false;
+  if (prop.kind === "method") return true;
+  return prop.value !== void 0 && isDefiniteNonPathLiteral(prop.value, true);
+}
+function isDefiniteNonPathLiteral(value, emptyIsInvalid) {
+  const text = value.trim();
+  if (/^(["'`])\1$/.test(text)) return emptyIsInvalid;
+  const scan = maskCommentsAndStrings(text).trim();
+  return /^-?\d[\w.]*$/.test(scan) || /^(?:true|false|null)$/.test(scan) || isWholeBracketLiteral(scan) || /^(?:async\s+)?function\b[\s\S]*\}$/.test(scan) || /^(?:async\s+)?\([^()]*\)\s*=>/.test(scan) || /^(?:async\s+)?[$\w]+\s*=>/.test(scan);
+}
+function isWholeBracketLiteral(scan) {
+  if (scan[0] !== "[" && scan[0] !== "{") return false;
+  let depth = 0;
+  for (let i = 0; i < scan.length; i++) {
+    const ch = scan[i];
+    if (ch === "(" || ch === "[" || ch === "{") {
+      depth++;
+    } else if (ch === ")" || ch === "]" || ch === "}") {
+      depth--;
+      if (depth === 0) return i === scan.length - 1;
+    }
+  }
+  return false;
+}
+function hasDefiniteNonStringElement(value) {
+  const text = value.trim();
+  const scan = maskCommentsAndStrings(text);
+  if (scan[0] !== "[" || !isWholeBracketLiteral(scan)) return false;
+  const elements = [];
+  let depth = 0;
+  let start = 1;
+  for (let i = 1; i < scan.length - 1; i++) {
+    const ch = scan[i];
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth--;
+    else if (ch === "," && depth === 0) {
+      elements.push(text.slice(start, i));
+      start = i + 1;
+    }
+  }
+  elements.push(text.slice(start, scan.length - 1));
+  return elements.some((element) => element.trim().length > 0 && isDefiniteNonPathLiteral(element, false));
+}
+function scanStringField(prop, contentStart) {
+  if (!prop || prop.kind !== "data" || prop.value === void 0 || prop.valueStart === void 0) return null;
+  const literal2 = extractStringLiteralValue(prop.value);
+  if (literal2 === null) return null;
+  const leading = prop.value.length - prop.value.trimStart().length;
+  const start = contentStart + prop.valueStart + leading + 1;
+  return { value: literal2, start, end: start + literal2.length };
+}
+function scanStringArrayFields(prop, contentStart) {
+  if (prop.kind !== "data" || prop.value === void 0 || prop.valueStart === void 0) return null;
+  const text = prop.value.trim();
+  if (!isArrayLiteral(text)) return null;
+  const literal2 = /(["'])([^"'\\\n]*)\1/g;
+  if (text.replace(literal2, "").replace(/[\s,]/g, "") !== "[]") return null;
+  const base = contentStart + prop.valueStart + (prop.value.length - prop.value.trimStart().length);
+  const fields = [];
+  for (const match of text.matchAll(literal2)) {
+    const start = base + match.index + 1;
+    fields.push({ value: match[2], start, end: start + match[2].length });
+  }
+  return fields;
+}
+function isDefiniteNonObjectLiteral(value) {
+  const scan = maskCommentsAndStrings(value).trim();
+  return /^(["'`])[^"'`]*\1$/.test(scan) || /^-?\d[\w.]*$/.test(scan) || /^(?:true|false|null)$/.test(scan) || scan[0] === "[" && isWholeBracketLiteral(scan) || /^(?:async\s+)?function\b[\s\S]*\}$/.test(scan) || /^(?:async\s+)?\([^()]*\)\s*=>/.test(scan) || /^(?:async\s+)?[$\w]+\s*=>/.test(scan);
+}
+function isDefiniteNonArrayLiteral(value) {
+  if (value === void 0) return false;
+  const scan = maskCommentsAndStrings(value).trim();
+  return /^(["'`])[^"'`]*\1$/.test(scan) || /^-?\d[\w.]*$/.test(scan) || /^(?:true|false|null)$/.test(scan) || /^\{/.test(scan);
+}
+function readEventTokenNames(scriptContent) {
+  const root = locateDefaultExportObject(scriptContent);
+  if (!root || hasTopLevelSpread(scriptContent)) return null;
+  const prop = parseTopLevelProperties(root.content).find((p) => p.name === RESERVED_EVENT_TOKENS_KEY);
+  if (!prop) return /* @__PURE__ */ new Set();
+  if (prop.kind !== "data" || prop.value === void 0 || !isArrayLiteral(prop.value)) return null;
+  return new Set(extractStringArrayItems(prop.value));
+}
+function hasDefaultExportObject(scriptContent) {
+  return locateDefaultExportObject(scriptContent) !== null;
+}
+function hasTopLevelSpread(scriptContent) {
+  const root = locateDefaultExportObject(scriptContent);
+  if (!root) return false;
+  const scan = maskCommentsAndStrings(root.content);
+  let depth = 0;
+  for (let i = 0; i < scan.length; i++) {
+    const ch = scan[i];
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth--;
+    else if (depth === 0 && ch === "." && scan.startsWith("...", i)) return true;
+  }
+  return false;
+}
+function analyzeObjectEntries(scriptContent, key, allowEmptyKeys = false) {
   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) {
+  const prop = parseTopLevelProperties(root.content).find((p) => p.name === key);
+  if (!prop || prop.kind !== "data" || !prop.value || !isObjectLiteral(prop.value) || prop.valueStart === void 0) {
     return [];
   }
-  const leading = watchProp.value.length - watchProp.value.trimStart().length;
-  const innerStart = root.start + watchProp.valueStart + leading + 1;
+  const leading = prop.value.length - prop.value.trimStart().length;
+  const innerStart = root.start + prop.valueStart + leading + 1;
   const entries = [];
-  for (const entry of parseTopLevelProperties(extractObjectContent(watchProp.value))) {
+  for (const entry of parseTopLevelProperties(extractObjectContent(prop.value), allowEmptyKeys)) {
     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)
+      kind: entry.kind,
+      value: entry.value,
+      valueStart: entry.valueStart === void 0 || entry.value === void 0 ? void 0 : innerStart + entry.valueStart + (entry.value.length - entry.value.trimStart().length)
     });
   }
   return entries;
@@ -1458,20 +1901,27 @@ function isNonFunctionLiteral(value) {
   return /^["'`]/.test(trimmed) || /^-?\d/.test(trimmed) || /^(?:true|false|null|undefined)\b/.test(trimmed) || trimmed.startsWith("[") || trimmed.startsWith("{");
 }
 function findNonObjectWatch(scriptContent) {
+  return findNonObjectDeclaration(scriptContent, RESERVED_WATCH_KEY);
+}
+function findNonObjectScan(scriptContent) {
+  return findNonObjectDeclaration(scriptContent, RESERVED_SCAN_KEY, true);
+}
+function findNonObjectDeclaration(scriptContent, key, rejectArray = false) {
   const root = locateDefaultExportObject(scriptContent);
   if (!root) return null;
-  const watchProp = parseTopLevelProperties(root.content).find((p) => p.name === RESERVED_WATCH_KEY);
-  if (!watchProp || watchProp.nameStart === void 0 || watchProp.nameEnd === void 0) {
+  const declarationProp = parseTopLevelProperties(root.content).find((p) => p.name === key);
+  if (!declarationProp || declarationProp.nameStart === void 0 || declarationProp.nameEnd === void 0) {
     return null;
   }
-  const span = { start: root.start + watchProp.nameStart, end: root.start + watchProp.nameEnd };
-  if (watchProp.kind === "method") {
+  const span = { start: root.start + declarationProp.nameStart, end: root.start + declarationProp.nameEnd };
+  if (declarationProp.kind === "method") {
     return span;
   }
-  if (watchProp.kind !== "data" || !watchProp.value) return null;
-  const trimmed = watchProp.value.trim();
+  if (declarationProp.kind !== "data" || !declarationProp.value) return null;
+  const trimmed = declarationProp.value.trim();
   if (trimmed.startsWith("{")) return null;
   const scan = maskCommentsAndStrings(trimmed).trim();
+  if (rejectArray && scan.startsWith("[") && isWholeBracketLiteral(scan)) return span;
   const isArrowFunction = /^(?:async\s+)?\([^()]*\)\s*=>/.test(scan) || /^(?:async\s+)?[$\w]+\s*=>/.test(scan);
   const isWholeLiteral = /^(["'`])[^"'`]*\1$/.test(scan) || /^-?\d[\w.]*$/.test(scan) || /^(?:true|false|null)$/.test(scan) || /^(?:async\s+)?function\b[\s\S]*\}$/.test(scan);
   if (!isArrowFunction && !isWholeLiteral) return null;
@@ -1494,6 +1944,19 @@ function collectReservedKeyPaths(prop, paths, pendingStreamValues, pendingListKe
     }
     return;
   }
+  if (prop.name === RESERVED_SCAN_KEY && prop.kind === "data" && prop.value && isObjectLiteral(prop.value)) {
+    for (const entry of parseTopLevelProperties(extractObjectContent(prop.value), true)) {
+      if (entry.kind !== "data" || !isFlatScanOutputName(entry.name)) continue;
+      const initial = entry.value && isObjectLiteral(entry.value) ? findStreamInitialProperty(entry.value) : void 0;
+      pendingStreamValues.push({
+        name: entry.name,
+        kind: "data",
+        value: initial?.value,
+        typeHint: initial?.typeHint
+      });
+    }
+    return;
+  }
   if (prop.name === RESERVED_COMMAND_TOKENS_KEY && prop.value) {
     for (const name of extractStringArrayItems(prop.value)) {
       paths.push({ path: `$command.${name}`, kind: "command" });
@@ -1520,6 +1983,9 @@ function pushListKeyPaths(entry, paths) {
   if (listPath.length === 0 || segments.some((s) => s.length === 0) || segments[segments.length - 1] === "*") {
     return;
   }
+  if (hasRecursionWildcard(listPath)) {
+    return;
+  }
   const has = (path) => paths.some((p) => p.path === path);
   if (!has(listPath)) paths.push({ path: listPath, kind: "data", typeHint: "array" });
   if (!has(`${listPath}.*`)) paths.push({ path: `${listPath}.*`, kind: "list" });
@@ -1534,8 +2000,42 @@ function pushListKeyPaths(entry, paths) {
 }
 function extractStringLiteralValue(value) {
   if (!value) return null;
-  const match = value.trim().match(/^["']([^"'\\]*)["']$/);
-  return match && match[1].length > 0 ? match[1] : null;
+  const match = value.trim().match(/^(?:["']([^"'\\]*)["']|`([^`\\$]*)`)$/);
+  const literal2 = match ? match[1] ?? match[2] : null;
+  return literal2 !== null && literal2 !== void 0 && literal2.length > 0 ? literal2 : null;
+}
+function hasUndecidableEntries(objectContent) {
+  const scan = maskCommentsAndStrings(objectContent);
+  let depth = 0;
+  let atKey = true;
+  for (let i = 0; i < scan.length; i++) {
+    const ch = scan[i];
+    if (ch === "(" || ch === "[" || ch === "{") {
+      if (depth === 0 && atKey && (ch === "[" || scan.startsWith("...", i))) return true;
+      depth++;
+      atKey = false;
+      continue;
+    }
+    if (ch === ")" || ch === "]" || ch === "}") {
+      depth--;
+      continue;
+    }
+    if (depth !== 0) continue;
+    if (ch === ",") {
+      atKey = true;
+      continue;
+    }
+    if (/\s/.test(ch)) continue;
+    if (atKey && scan.startsWith("...", i)) return true;
+    atKey = false;
+  }
+  return false;
+}
+function isDefiniteNonStringLiteral(value) {
+  if (!value) return false;
+  const scan = maskCommentsAndStrings(value).trim();
+  if (scan.length === 0) return false;
+  return /^-?\d[\w.]*$/.test(scan) || /^(?:true|false|null)$/.test(scan) || /^[[{]/.test(scan) || /^(?:async\s+)?function\b/.test(scan) || /^(?:async\s+)?\([^()]*\)\s*=>/.test(scan) || /^(?:async\s+)?[$\w]+\s*=>/.test(scan);
 }
 var ROW_ASSIGN = new RegExp(
   String.raw`\bthis\s*(?:\.\s*([$\w]+)|\[\s*["']([^"']+)["']\s*\])\s*=(?![=>])\s*(?:(\[)|(?:[^;={}]|=>)*?\.\s*(?:concat|toSpliced|with)\s*(\())`,
@@ -1630,6 +2130,9 @@ function findStreamInitialProperty(entryValue) {
   const defProps = parseTopLevelProperties(extractObjectContent(entryValue));
   return defProps.find((p) => p.kind === "data" && p.name === "initial");
 }
+function isFlatScanOutputName(name) {
+  return name.length > 0 && !name.startsWith("$") && !name.includes(".") && !name.includes("*");
+}
 function extractStringArrayItems(value) {
   if (!isArrayLiteral(value)) return [];
   const items = [];
@@ -1641,6 +2144,19 @@ function extractStringArrayItems(value) {
   return items;
 }
 var MAX_OBJECT_NEST_DEPTH = 5;
+function effectiveTopLevelDescriptors(props) {
+  const effective = /* @__PURE__ */ new Map();
+  for (const prop of props) {
+    if (prop.kind !== "getter") {
+      effective.set(prop.name, "data");
+      continue;
+    }
+    const current2 = effective.get(prop.name);
+    const pair = current2 === void 0 || current2 === "data" ? { get: false, set: false } : current2;
+    effective.set(prop.name, prop.accessor === "set" ? { ...pair, set: true } : { ...pair, get: true });
+  }
+  return effective;
+}
 function pushDataPropertyPaths(prop, paths) {
   pushDataPropertyPathsAt(prop.name, prop, paths, 0);
 }
@@ -1719,10 +2235,10 @@ function locateDefaultExportObject(script) {
 function extractDefaultExportObject(script) {
   return locateDefaultExportObject(script)?.content ?? null;
 }
-function parseTopLevelProperties(objectContent) {
+function parseTopLevelProperties(objectContent, allowEmptyDataKeys = false) {
   const props = [];
   const scan = maskCommentsAndStrings(objectContent);
-  const regex = /(?:(?:get|set)\s+(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*\([^)]*\)\s*\{)|(?:(?:async\s+)?(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*\([^)]*\)\s*\{)|(?:(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*:\s*)/gd;
+  const regex = allowEmptyDataKeys ? /(?:(?:get|set)\s+(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*\([^)]*\)\s*\{)|(?:(?:async\s+)?(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*\([^)]*\)\s*\{)|(?:(?:"([^"]*)"|'([^']*)'|([$\w]+))\s*:\s*)/gd : /(?:(?:get|set)\s+(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*\([^)]*\)\s*\{)|(?:(?:async\s+)?(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*\([^)]*\)\s*\{)|(?:(?:"([^"]+)"|'([^']+)'|([$\w]+))\s*:\s*)/gd;
   let match;
   while ((match = regex.exec(scan)) !== null) {
     const indices = match.indices;
@@ -1768,7 +2284,7 @@ function parseTopLevelProperties(objectContent) {
       continue;
     }
     const propName = nameAt(7) ?? nameAt(8) ?? nameAt(9);
-    if (propName) {
+    if (propName !== void 0) {
       const valueStartIndex = match.index + match[0].length;
       const value = extractFullValue(objectContent, scan, valueStartIndex);
       const jsdocType = extractJsDocType(objectContent, match.index);
@@ -2129,6 +2645,7 @@ function parseWcsStateElements(html, stateTagName = "wcs-state") {
       continue;
     }
     const mountPath = extractAttribute(wcsMatch.tagContent, "mount");
+    const bindComponent = parseAttributeNames(wcsMatch.tagContent).has("bind-component");
     const jsonAttr = extractAttribute(wcsMatch.tagContent, "json") ?? void 0;
     const stateAttr = extractAttribute(wcsMatch.tagContent, "state") ?? void 0;
     const srcAttr = extractAttribute(wcsMatch.tagContent, "src") ?? void 0;
@@ -2170,7 +2687,7 @@ function parseWcsStateElements(html, stateTagName = "wcs-state") {
       pos = html.indexOf(">", scriptCloseIdx) + 1;
       if (pos === 0) break;
     }
-    elements.push({ mountPath, jsonAttr, stateAttr, srcAttr, scriptBlocks, tagStart, tagEnd });
+    elements.push({ mountPath, bindComponent, jsonAttr, stateAttr, srcAttr, scriptBlocks, tagStart, tagEnd });
     pos = wcsEnd;
     if (wcsCloseIdx !== -1) {
       const closeEnd = html.indexOf(">", wcsCloseIdx);
@@ -2260,6 +2777,15 @@ function findCloseTag(html, startPos, tagName) {
   }
   return -1;
 }
+function parseAttributeNames(tagContent) {
+  const names = /* @__PURE__ */ new Set();
+  const attribute = /([^\s"'<>/=]+)(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'<>`=]+))?/g;
+  let match;
+  while ((match = attribute.exec(tagContent)) !== null) {
+    names.add(match[1].toLowerCase());
+  }
+  return names;
+}
 function extractAttribute(tagContent, attrName) {
   const regex = new RegExp(
     `(?:^|\\s)${attrName}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|(\\S+))`,
@@ -2499,6 +3025,33 @@ var ja = {
   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`,
+  scanNotObject: () => `$scan \u306F\u300C\u51FA\u529B\u540D \u2192 { from | on, initial, fold, resetOn? }\u300D\u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\uFF08\u3053\u306E\u5F62\u306F\u30E9\u30F3\u30BF\u30A4\u30E0\u304C\u8AAD\u307F\u8FBC\u307F\u6642\u306B throw \u3057\u307E\u3059\uFF09`,
+  scanOutputInvalid: (n) => `$scan \u306E\u51FA\u529B\u540D "${n}" \u306F\u5E73\u5766\u306A\u30D7\u30ED\u30D1\u30C6\u30A3\u540D\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\uFF08"."\u30FB"*"\u30FB\u5148\u982D\u306E "$" \u306F\u4F7F\u3048\u307E\u305B\u3093\uFF09`,
+  scanOutputReserved: (n) => `$scan \u306E\u51FA\u529B\u540D "${n}" \u306F Object.prototype \u304B\u3089\u7D99\u627F\u3055\u308C\u308B\u540D\u524D\u3067\u3059\uFF08"constructor" \u306A\u3069\uFF09`,
+  scanOutputEmpty: () => `$scan \u306E\u51FA\u529B\u540D\u306F\u7A7A\u3067\u306A\u3044\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  scanInVolume: (mountPath) => `$scan \u306F\u30DC\u30EA\u30E5\u30FC\u30E0\uFF08mount="${mountPath}"\uFF09\u3067\u306F\u5BA3\u8A00\u3067\u304D\u307E\u305B\u3093\uFF08\u30E9\u30F3\u30BF\u30A4\u30E0\u306F\u63A5\u304E\u6728\u306E\u524D\u306B throw \u3057\u307E\u3059\uFF09\u3002scan \u306F\u30EB\u30FC\u30C8\u306E state \u306B\u5BA3\u8A00\u3057\u3066\u304F\u3060\u3055\u3044`,
+  scanInMountedComponent: () => `$scan \u306F\u30DE\u30A6\u30F3\u30C8\u3055\u308C\u305F\u30B3\u30F3\u30DD\u30FC\u30CD\u30F3\u30C8\uFF08bind-component\uFF09\u3067\u306F\u5B9F\u884C\u3055\u308C\u307E\u305B\u3093\uFF08\u30E9\u30F3\u30BF\u30A4\u30E0\u306F wcs/mount-dollar-declaration \u3067\u8B66\u544A\u3057\u3001\u9ED9\u3063\u3066\u6368\u3066\u307E\u3059\uFF09\u3002scan \u306F\u30EB\u30FC\u30C8\u306E state \u306B\u5BA3\u8A00\u3057\u3066\u304F\u3060\u3055\u3044`,
+  scanOutputConflict: (n, other) => other === "getter" ? `$scan \u306E\u51FA\u529B\u540D "${n}" \u306F\u540C\u540D\u306E getter / setter \u3068\u885D\u7A81\u3057\u3066\u3044\u307E\u3059\uFF08\u51FA\u529B\u306F\u30E9\u30F3\u30BF\u30A4\u30E0\u304C\u6240\u6709\u3059\u308B\u30D7\u30ED\u30D1\u30C6\u30A3\u3067\u3059\uFF09` : other === "method" ? `$scan \u306E\u51FA\u529B\u540D "${n}" \u306F\u540C\u540D\u306E\u30E1\u30BD\u30C3\u30C9\u3068\u885D\u7A81\u3057\u3066\u3044\u307E\u3059\uFF08\u51FA\u529B\u306F\u30E9\u30F3\u30BF\u30A4\u30E0\u304C\u6240\u6709\u3059\u308B\u30D7\u30ED\u30D1\u30C6\u30A3\u3067\u3001\u7573\u3093\u3060\u5024\u304C\u30E1\u30BD\u30C3\u30C9\u3092\u4E0A\u66F8\u304D\u3057\u307E\u3059\uFF09` : `$scan \u306E\u51FA\u529B\u540D "${n}" \u306F\u540C\u540D\u306E $streams \u30A8\u30F3\u30C8\u30EA\u3068\u885D\u7A81\u3057\u3066\u3044\u307E\u3059\uFF08\u51FA\u529B\u306E\u6301\u3061\u4E3B\u306F 1 \u3064\u3060\u3051\u3067\u3059\uFF09`,
+  scanEntryNotObject: (n) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306F { from | on, initial, fold, resetOn? } \u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  scanSourceCount: (n) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306B\u306F "from"\uFF08state \u30D1\u30B9\uFF09\u304B "on"\uFF08\u30A4\u30D9\u30F3\u30C8\u30C8\u30FC\u30AF\u30F3\u540D\uFF09\u306E\u3069\u3061\u3089\u304B 1 \u3064\u3060\u3051\u3092\u66F8\u304D\u307E\u3059`,
+  scanFromNotString: (n) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E "from" \u306F\u7A7A\u3067\u306A\u3044 state \u30D1\u30B9\u306E\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  scanOnNotString: (n) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E "on" \u306F\u7A7A\u3067\u306A\u3044\u30A4\u30D9\u30F3\u30C8\u30C8\u30FC\u30AF\u30F3\u540D\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  scanResetNotString: (n) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E "resetOn" \u306B\u306F state \u30D1\u30B9\u306E\u6587\u5B57\u5217\u3060\u3051\u3092\u66F8\u304D\u307E\u3059`,
+  scanOutputCycle: (chain) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA ${chain.map((c) => `"${c}"`).join(" \u2192 ")} \u306F from \u3092\u901A\u3058\u3066\u4E92\u3044\u3092\u7573\u307F\u5408\u3063\u3066\u3044\u307E\u3059\uFF08\u4E92\u3044\u306E\u66F8\u304D\u8FBC\u307F\u3067\u6C38\u4E45\u306B\u7573\u307F\u7D9A\u3051\u307E\u3059\uFF09`,
+  scanInitialMissing: (n) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306B "initial" \u304C\u3042\u308A\u307E\u305B\u3093\uFF08\u7D2F\u7A4D\u306E\u7A2E\u3067\u3042\u308A\u3001resetOn \u306E\u623B\u308A\u5148\u3067\u3059\uFF09`,
+  scanFoldNotFunction: (n) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E "fold" \u306F\u95A2\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  scanOnUndeclared: (n, t) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E on "${t}" \u306F $eventTokens \u306B\u5BA3\u8A00\u3055\u308C\u3066\u3044\u307E\u305B\u3093`,
+  scanPathInvalid: (n, f, p) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E ${f} "${p}" \u306F state \u30D1\u30B9\u3068\u3057\u3066\u6210\u7ACB\u3057\u307E\u305B\u3093\uFF08\u5148\u982D\u306E "$"\u30FB"@"\u30FB\u7A7A\u306E\u30BB\u30B0\u30E1\u30F3\u30C8\u306F\u4F7F\u3048\u307E\u305B\u3093\uFF09`,
+  scanPathReserved: (n, f, p) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E ${f} "${p}" \u306F Object.prototype \u304B\u3089\u7D99\u627F\u3055\u308C\u308B\u540D\u524D\u3067\u3059\uFF08"constructor" \u306A\u3069\uFF09`,
+  scanFromSelf: (n, p) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E from "${p}" \u306F\u81EA\u5206\u306E\u51FA\u529B\u3092\u8AAD\u3093\u3067\u3044\u307E\u3059\uFF08\u81EA\u5206\u306E\u66F8\u304D\u8FBC\u307F\u3092\u6C38\u4E45\u306B\u7573\u307F\u7D9A\u3051\u307E\u3059\uFF09`,
+  scanResetNotArray: (n) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E "resetOn" \u306F state \u30D1\u30B9\u306E\u914D\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`,
+  scanResetWildcard: (n, p) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E resetOn "${p}" \u306B "*" \u306F\u4F7F\u3048\u307E\u305B\u3093\uFF08reset \u306F\u51FA\u529B\u5168\u4F53\u3092 initial \u306B\u623B\u3057\u307E\u3059\uFF09`,
+  scanResetIsFrom: (n, p) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E resetOn "${p}" \u306F\u81EA\u5206\u306E from \u3068\u540C\u3058\u3067\u3059\uFF08\u5909\u5316\u306E\u305F\u3073\u306B\u7573\u307E\u305A\u306B reset \u3057\u307E\u3059\uFF09`,
+  scanResetUnderFrom: (n, p, from) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E resetOn "${p}" \u306F\u81EA\u5206\u306E from "${from}" \u306E\u914D\u4E0B\u3067\u3059\uFF08from \u3092\u66F8\u304F\u305F\u3073\u306B\u540C\u3058\u30D0\u30C3\u30C1\u306B\u8F09\u308A\u3001reset \u304C\u6BCE\u56DE\u52DD\u3063\u3066\u4E00\u5EA6\u3082\u7573\u307E\u308C\u307E\u305B\u3093\uFF09`,
+  scanResetReadsOutput: (n, p, o) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E resetOn "${p}" \u306F $scan \u306E\u51FA\u529B "${o}" \u3092\u8AAD\u3093\u3067\u3044\u307E\u3059\uFF08\u7D2F\u7A4D\u3067\u7D2F\u7A4D\u3092\u6D88\u3059\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u306B\u306A\u308A\u307E\u3059\uFF09\u3002\u7D20\u306E\u5165\u529B\u3067 reset \u3057\u3066\u304F\u3060\u3055\u3044`,
+  scanSourceComputed: (n, f, p, g) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E ${f} "${p}" \u306F${g === p ? " getter" : g.includes("**") ? `\u518D\u5E30 getter "${g}" \u304C\u8A08\u7B97\u3059\u308B\u30D1\u30B9` : ` getter "${g}" \u306E\u914D\u4E0B`}\u3067\u3059\u3002getter \u306F\u5165\u529B\u304C\u5909\u308F\u308B\u305F\u3073\u306B\u518D\u8A55\u4FA1\u3055\u308C\u308B\u306E\u3067\u3001\u7573\u3080\u3068\u51FA\u6765\u4E8B\u3067\u306F\u306A\u304F\u518D\u8A55\u4FA1\u306E\u56DE\u6570\u3092\u6570\u3048\u307E\u3059\u3002getter \u304C\u8AAD\u3080\u7D20\u306E\u5024\u3092\u6307\u3059\u304B\u3001on \u3067\u30A4\u30D9\u30F3\u30C8\u3092\u53D7\u3051\u3066\u304F\u3060\u3055\u3044`,
+  scanFromWriteOnly: (n, p, s) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E from "${p}" \u306F${s === p ? " getter \u306E\u7121\u3044 setter" : ` getter \u306E\u7121\u3044 setter "${s}" \u306E\u914D\u4E0B`}\u3067\u3059\u3002\u8AAD\u3080\u3068\u5E38\u306B undefined \u306A\u306E\u3067\u3001fold \u306F\u6BCE\u56DE undefined \u3092\u53D7\u3051\u53D6\u308A\u307E\u3059\u3002setter \u304C\u66F8\u304F\u7D20\u306E\u5024\u3092\u6307\u3059\u304B\u3001on \u3067\u30A4\u30D9\u30F3\u30C8\u3092\u53D7\u3051\u3066\u304F\u3060\u3055\u3044`,
+  scanPathMissing: (n, f, p) => `$scan \u306E\u30A8\u30F3\u30C8\u30EA "${n}" \u306E ${f} "${p}" \u306F\u72B6\u614B\u5B9A\u7FA9\u306B\u5B58\u5728\u3057\u307E\u305B\u3093\uFF08${f === "from" ? "\u4E00\u5EA6\u3082\u7573\u307E\u308C\u307E\u305B\u3093" : "\u4E00\u5EA6\u3082 reset \u3055\u308C\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`,
@@ -2527,7 +3080,96 @@ var ja = {
       default:
         return `"mount" \u30D1\u30B9 "${mountPath}" \u306B\u4E88\u7D04\u6587\u5B57\uFF08$, #, @\uFF09\u306F\u4F7F\u3048\u307E\u305B\u3093\uFF08runtime: must not use reserved characters.\uFF09`;
     }
-  }
+  },
+  recursionUnsupported: (p, where) => {
+    switch (where) {
+      case "binding":
+        return `"${p}" \u306E "**" \u306F data-wcs \u3067\u306F\u4F7F\u3048\u307E\u305B\u3093\u3002"**" \u306F $recursion \u5BA3\u8A00\u30FB\u518D\u5E30 getter \u306E\u30AD\u30FC\u30FB$getAll / $setAll \u306E\u30D1\u30B9\u5F15\u6570\u3060\u3051\u306E\u8A18\u53F7\u3067\u3059\uFF08\u30E9\u30F3\u30BF\u30A4\u30E0\u306F\u30D0\u30A4\u30F3\u30C9\u78BA\u7ACB\u6642\u306B throw \u3057\u307E\u3059\uFF09\u3002HTML \u3067\u306F\u5C55\u958B\u5F8C\u306E\u5177\u4F53\u30D1\u30B9\u3092\u66F8\u3044\u3066\u304F\u3060\u3055\u3044`;
+      case "watch":
+        return `$watch \u306E\u30AD\u30FC "${p}" \u306B "**" \u306F\u4F7F\u3048\u307E\u305B\u3093\u3002\u76E3\u8996\u306F\u5177\u4F53\u30D1\u30B9\uFF08\u56FA\u5B9A\u672C\u6570\u306E "*"\uFF09\u306B\u5BFE\u3057\u3066\u306E\u307F\u6210\u7ACB\u3057\u307E\u3059`;
+      case "resolve":
+        return `$resolve("${p}") \u306B "**" \u306F\u6E21\u305B\u307E\u305B\u3093\u3002$resolve \u306F\u5C55\u958B\u5F8C\u306E\u5177\u4F53\u30D1\u30B9\u3068\u6DFB\u5B57\u30BF\u30D7\u30EB\u306E\u53B3\u5BC6\u4E00\u81F4\u3060\u3051\u3092\u53D7\u3051\u4ED8\u3051\u307E\u3059`;
+      case "assignment":
+        return `this["${p}"] \u3078\u306E\u4EE3\u5165\u306B "**" \u306F\u4F7F\u3048\u307E\u305B\u3093\uFF08\u518D\u5E30 setter \u306F\u521D\u7248\u3067\u306F\u6301\u3066\u305A\u3001\u4EE3\u5165\u306F\u5C55\u958B\u5F8C\u306E\u5177\u4F53\u30D1\u30B9\u306B\u3057\u304B\u6210\u7ACB\u3057\u307E\u305B\u3093\uFF09\u3002$setAll("${p}", [], value) \u3067\u5168\u6DF1\u3055\u3078\u30D6\u30ED\u30FC\u30C9\u30AD\u30E3\u30B9\u30C8\u3059\u308B\u304B\u3001\u5177\u4F53\u30D1\u30B9\u3078\u66F8\u3044\u3066\u304F\u3060\u3055\u3044`;
+      case "postUpdate":
+        return `$postUpdate("${p}") \u306B "**" \u306F\u6E21\u305B\u307E\u305B\u3093\u3002\u901A\u77E5\u306F\u5C55\u958B\u5F8C\u306E\u5177\u4F53\u30D1\u30B9\uFF08\u56FA\u5B9A\u672C\u6570\u306E "*"\uFF09\u306B\u5BFE\u3057\u3066\u306E\u307F\u6210\u7ACB\u3057\u307E\u3059`;
+      case "trackDependency":
+        return `$trackDependency("${p}") \u306B "**" \u306F\u6E21\u305B\u307E\u305B\u3093\u3002\u4F9D\u5B58\u306E\u767B\u9332\u306F\u5C55\u958B\u5F8C\u306E\u5177\u4F53\u30D1\u30B9\uFF08\u56FA\u5B9A\u672C\u6570\u306E "*"\uFF09\u306B\u5BFE\u3057\u3066\u306E\u307F\u6210\u7ACB\u3057\u307E\u3059`;
+      case "listKeys":
+        return `$listKeys \u306E\u30AD\u30FC "${p}" \u306B "**" \u306F\u4F7F\u3048\u307E\u305B\u3093\u3002\u30AD\u30FC\u4ED8\u304D\u30EA\u30B9\u30C8\u306F 1 \u672C\u306E\u5177\u4F53\u30EA\u30B9\u30C8\u30D1\u30B9\u3067\u3059 \u2014 \u6DF1\u3055\u3054\u3068\u306B\u5BA3\u8A00\u3057\u3066\u304F\u3060\u3055\u3044\uFF08\u4F8B: "nodes.*.children"\uFF09`;
+      case "scan":
+        return `$scan \u306E\u30D1\u30B9 "${p}" \u306B "**" \u306F\u4F7F\u3048\u307E\u305B\u3093\u3002from / resetOn \u306F\u5177\u4F53\u30D1\u30B9\uFF08\u56FA\u5B9A\u672C\u6570\u306E "*"\uFF09\u3092\u6307\u3057\u307E\u3059`;
+      default:
+        return `"${p}" \u306F "**" \u3092\u542B\u307F\u307E\u3059\u304C\u3001\u3053\u306E state \u306B\u306F $recursion \u5BA3\u8A00\u304C\u3042\u308A\u307E\u305B\u3093\u3002$recursion = { "<anchor>": "<repeat>" }\uFF08\u4F8B: { "nodes.*": "children.*" }\uFF09\u3092\u5BA3\u8A00\u3057\u3066\u304F\u3060\u3055\u3044\uFF08\u5BA3\u8A00\u304C\u7121\u3044\u3068 "**" \u306E\u30AD\u30FC\u306F\u9ED9\u3063\u3066\u7121\u8996\u3055\u308C\u307E\u3059\uFF09`;
+    }
+  },
+  recursionAnchorMismatch: (p, anchor) => `"${p}" \u306F\u5BA3\u8A00\u6E08\u307F\u306E\u518D\u5E30\u30A2\u30F3\u30AB\u30FC "${anchor}" \u3068\u5408\u81F4\u3057\u307E\u305B\u3093\uFF08\u521D\u7248\u306F state \u3054\u3068\u306B 1 \u3064\u306E\u81EA\u5DF1\u518D\u5E30\u306E\u307F\u3002"**" \u306E\u5F8C\u308D\u306F\u6574\u5F62\u3055\u308C\u305F\u63A5\u5C3E\u8F9E \u2014 2 \u3064\u76EE\u306E "**"\u30FB\u7A7A\u30BB\u30B0\u30E1\u30F3\u30C8\u30FB"**" \u76F4\u5F8C\u306E\u7D20\u306E "*" \u306F\u7F6E\u3051\u307E\u305B\u3093\uFF09`,
+  recursionGetAllForm: (p, problem) => problem === "notArray" ? `$getAll("${p}", indexes) \u306E "**" \u306E\u6DFB\u5B57\u306F\u3001\u7701\u7565\uFF08\u8A55\u4FA1\u4E2D\u306E\u518D\u5E30 getter \u306E\u6DF1\u3055\uFF09\u304B [] \uFF08\u5168\u6DF1\u3055\uFF09\u306E\u3069\u3061\u3089\u304B\u3067\u3059\u3002null \u3084\u914D\u5217\u3067\u306A\u3044\u5024\u306F\u6E21\u305B\u307E\u305B\u3093` : `$getAll("${p}", indexes) \u306E "**" \u306B\u975E\u7A7A\u306E\u63A5\u982D\u8F9E\u306F\u6E21\u305B\u307E\u305B\u3093\uFF08\u63A5\u982D\u8F9E\u306F\u3069\u306E\u6DF1\u3055\u306B\u9069\u7528\u3055\u308C\u308B\u304B\u3092\u8A00\u3048\u307E\u305B\u3093\uFF09\u3002\u6DFB\u5B57\u3092\u7701\u7565\u3059\u308B\u3068\u8A55\u4FA1\u4E2D\u306E\u518D\u5E30 getter \u306E\u6DF1\u3055\u3001[] \u3092\u6E21\u3059\u3068\u5168\u6DF1\u3055\u306B\u306A\u308A\u307E\u3059`,
+  recursionSetAllForm: (p, problem) => {
+    switch (problem) {
+      case "prefix":
+        return `$setAll("${p}", indexes, \u2026) \u306E "**" \u306B\u975E\u7A7A\u306E\u63A5\u982D\u8F9E\u306F\u6E21\u305B\u307E\u305B\u3093\uFF08\u63A5\u982D\u8F9E\u306F\u3069\u306E\u6DF1\u3055\u306B\u9069\u7528\u3055\u308C\u308B\u304B\u3092\u8A00\u3048\u307E\u305B\u3093\uFF09\u3002[] \u3092\u6E21\u3057\u3066\u5168\u6DF1\u3055\u3078\u30D6\u30ED\u30FC\u30C9\u30AD\u30E3\u30B9\u30C8\u3057\u3066\u304F\u3060\u3055\u3044`;
+      case "noIndexes":
+        return `$setAll("${p}", \u2026) \u306E "**" \u306B\u306F\u660E\u793A\u7684\u306A\u7A7A\u306E\u6DFB\u5B57\u914D\u5217 [] \u304C\u5FC5\u8981\u3067\u3059\uFF08\u66F8\u304D\u8FBC\u307F API \u306F\u6587\u8108\u3092\u53D6\u308A\u307E\u305B\u3093\uFF09`;
+      case "mapper":
+        return `$setAll("${p}", \u2026) \u306E "**" \u306F mapper \u3092\u53D6\u308C\u307E\u305B\u3093\uFF08\u6DFB\u5B57\u30BF\u30D7\u30EB\u306E\u672C\u6570\u304C\u6DF1\u3055\u3054\u3068\u306B\u5909\u308F\u308B\u305F\u3081\uFF09\u3002\u5B9A\u6570\u5024\u3092\u6E21\u3057\u3066\u304F\u3060\u3055\u3044`;
+      default:
+        return `$setAll("${p}", \u2026) \u306E "**" \u306F { spread: true } \u3092\u53D6\u308C\u307E\u305B\u3093\uFF08\u5E73\u5766\u306A\u914D\u5217\u3092\u6728\u306B\u914D\u308B\u306B\u306F\u4F5C\u8005\u304C\u8D70\u67FB\u9806\u3092\u77E5\u308B\u5FC5\u8981\u304C\u3042\u308A\u3001\u5951\u7D04\u306B\u306A\u308A\u307E\u305B\u3093\uFF09`;
+    }
+  },
+  recursionStructuralWrite: (p, target, repeatList) => {
+    switch (target) {
+      case "node":
+        return `$setAll("${p}") \u306F\u518D\u5E30\u306E\u69CB\u9020\u305D\u306E\u3082\u306E\uFF08\u30CE\u30FC\u30C9\uFF09\u3092\u66F8\u304D\u63DB\u3048\u307E\u3059\u3002\u521D\u7248\u306F\u8449\u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u3078\u306E\u30D6\u30ED\u30FC\u30C9\u30AD\u30E3\u30B9\u30C8\u306E\u307F\u3067\u3059 \u2014 \u30CE\u30FC\u30C9\u3092\u7F6E\u304D\u63DB\u3048\u308B\u3068\u3053\u306E\u66F8\u304D\u8FBC\u307F\u306E\u305F\u3081\u306B\u78BA\u5B9A\u6E08\u307F\u306E\u5B50\u30A2\u30C9\u30EC\u30B9\u304C\u7121\u52B9\u306B\u306A\u308A\u307E\u3059`;
+      case "branch":
+        return `$setAll("${p}") \u306F\u518D\u5E30\u306E\u69CB\u9020\u305D\u306E\u3082\u306E\uFF08"${repeatList}" \u30EA\u30B9\u30C8\u3078\u81F3\u308B\u9014\u4E2D\u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\uFF09\u3092\u66F8\u304D\u63DB\u3048\u307E\u3059\u3002\u521D\u7248\u306F\u8449\u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u3078\u306E\u30D6\u30ED\u30FC\u30C9\u30AD\u30E3\u30B9\u30C8\u306E\u307F\u3067\u3059 \u2014 \u7F6E\u304D\u63DB\u3048\u308B\u3068\u305D\u306E\u4E0B\u306E\u78BA\u5B9A\u6E08\u307F\u306E\u5B50\u30A2\u30C9\u30EC\u30B9\u304C\u7121\u52B9\u306B\u306A\u308A\u307E\u3059`;
+      case "length":
+        return `$setAll("${p}") \u306F\u518D\u5E30\u306E\u69CB\u9020\u305D\u306E\u3082\u306E\uFF08"${repeatList}" \u30EA\u30B9\u30C8\u306E length\uFF09\u3092\u66F8\u304D\u63DB\u3048\u307E\u3059\u3002length \u3078\u306E\u4EE3\u5165\u306F\u914D\u5217\u3092\u5207\u308A\u8A70\u3081\u308B\u306E\u3067\u3001\u30EA\u30B9\u30C8\u306E\u7F6E\u63DB\u3068\u540C\u3058\u304F\u305D\u306E\u4E0B\u306E\u78BA\u5B9A\u6E08\u307F\u306E\u5B50\u30A2\u30C9\u30EC\u30B9\u304C\u7121\u52B9\u306B\u306A\u308A\u307E\u3059`;
+      default:
+        return `$setAll("${p}") \u306F\u518D\u5E30\u306E\u69CB\u9020\u305D\u306E\u3082\u306E\uFF08"${repeatList}" \u30EA\u30B9\u30C8\uFF09\u3092\u66F8\u304D\u63DB\u3048\u307E\u3059\u3002\u521D\u7248\u306F\u8449\u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u3078\u306E\u30D6\u30ED\u30FC\u30C9\u30AD\u30E3\u30B9\u30C8\u306E\u307F\u3067\u3059`;
+    }
+  },
+  recursionReadonly: (subject, getterPath) => `${subject} \u306F\u518D\u5E30 getter "${getterPath}" \u306B\u66F8\u304D\u8FBC\u307F\u307E\u3059\uFF08setter \u306F\u521D\u7248\u3067\u306F\u6301\u3066\u307E\u305B\u3093\u3002\u3053\u306E\u7DB4\u308A\u306F\u305D\u306E getter \u306E\u3042\u308B\u6DF1\u3055\u306E\u5C55\u958B\u5F62\u304B\u3001\u5C0E\u51FA\u5024\u306E\u5185\u5074\u3067\u3059\uFF09\u3002\u3053\u306E getter \u304C\u5C0E\u51FA\u5143\u306B\u3057\u3066\u3044\u308B\u5024\u306E\u5074\u3092\u66F8\u3044\u3066\u304F\u3060\u3055\u3044`,
+  recursionInVolume: (subject, mountPath) => `${subject} \u306F\u30DC\u30EA\u30E5\u30FC\u30E0\uFF08mount="${mountPath}"\uFF09\u3067\u306F\u5BA3\u8A00\u3067\u304D\u307E\u305B\u3093\uFF08\u30E9\u30F3\u30BF\u30A4\u30E0\u306F\u63A5\u304E\u6728\u306E\u524D\u306B throw \u3057\u307E\u3059\uFF09\u3002\u518D\u5E30\u306E\u5BA3\u8A00\u3068 "**" getter \u306F\u30EB\u30FC\u30C8\u306E state \u306B\u7F6E\u3044\u3066\u304F\u3060\u3055\u3044 \u2014 \u30A2\u30F3\u30AB\u30FC\u306E\u30D1\u30B9\u306F\u30EB\u30FC\u30C8\u306E\u6728\u306B\u5BFE\u3057\u3066\u89E3\u6C7A\u3055\u308C\u307E\u3059`,
+  recursionNotObject: () => `$recursion \u306F\u300C\u30A2\u30F3\u30AB\u30FC \u2192 \u53CD\u5FA9\u30B5\u30D6\u30D1\u30B9\u300D\u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\uFF08\u4F8B: { "nodes.*": "children.*" }\u3002\u3053\u306E\u5F62\u306F\u30E9\u30F3\u30BF\u30A4\u30E0\u304C\u8AAD\u307F\u8FBC\u307F\u6642\u306B throw \u3057\u307E\u3059\uFF09`,
+  recursionAnchorCount: (count) => count === 0 ? `$recursion \u306B\u306F\u30A2\u30F3\u30AB\u30FC\u304C\u3061\u3087\u3046\u3069 1 \u3064\u5FC5\u8981\u3067\u3059\uFF08\u7A7A\u306E\u5BA3\u8A00\u3067\u3059\uFF09` : `$recursion \u304C ${count} \u500B\u306E\u30A2\u30F3\u30AB\u30FC\u3092\u5BA3\u8A00\u3057\u3066\u3044\u307E\u3059\u3002\u521D\u7248\u306F state \u3054\u3068\u306B\u3061\u3087\u3046\u3069 1 \u3064\u306E\u81EA\u5DF1\u518D\u5E30\u306E\u307F\u5BFE\u5FDC\u3057\u307E\u3059`,
+  recursionNodePathInvalid: (kind, path, problem) => {
+    const subject = kind === "anchor" ? "$recursion \u306E\u30A2\u30F3\u30AB\u30FC" : "$recursion \u306E\u53CD\u5FA9\u30B5\u30D6\u30D1\u30B9";
+    switch (problem) {
+      case "empty":
+        return `${subject}\u306F\u7A7A\u3067\u306A\u3044\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
+      case "emptySegment":
+        return `${subject} "${path}" \u306B\u7A7A\u306E\u30D1\u30B9\u30BB\u30B0\u30E1\u30F3\u30C8\u304C\u3042\u308A\u307E\u3059`;
+      case "notElement":
+        return `${subject} "${path}" \u306F\u30EA\u30B9\u30C8\u306E\u8981\u7D20\u3092\u6307\u3059\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059 \u2014 \u672B\u5C3E\u304C ".*" \u306E\u30D7\u30ED\u30D1\u30C6\u30A3\u30D1\u30B9\uFF08\u4F8B: "nodes.*"\uFF09\u306B\u3057\u3066\u304F\u3060\u3055\u3044`;
+      case "reservedRoot":
+        return `${subject} "${path}" \u306F "$" \u3067\u59CB\u3081\u3089\u308C\u307E\u305B\u3093\uFF08\u4E88\u7D04\u540D\u524D\u7A7A\u9593\uFF09`;
+      case "reservedMount":
+        return `${subject} "${path}" \u306B "#" \u306F\u4F7F\u3048\u307E\u305B\u3093\uFF08\u30DE\u30A6\u30F3\u30C8\u7528\u306E\u4E88\u7D04\u30BB\u30B0\u30E1\u30F3\u30C8\uFF09`;
+      case "midWildcard":
+        return `${subject} "${path}" \u306E "*" \u306F\u672B\u5C3E\u306B\u3061\u3087\u3046\u3069 1 \u3064\u3060\u3051\u7F6E\u3051\u307E\u3059\uFF08\u9014\u4E2D\u306E\u30EF\u30A4\u30EB\u30C9\u30AB\u30FC\u30C9\u306F\u521D\u7248\u3067\u306F\u672A\u5BFE\u5FDC\uFF09`;
+      case "indexSegment":
+        return `${subject} "${path}" \u306B\u6DFB\u5B57\u30BB\u30B0\u30E1\u30F3\u30C8\u306F\u542B\u3081\u3089\u308C\u307E\u305B\u3093\uFF08\u518D\u5E30\u306F\u6728\u306E\u5F62\u306B\u5BFE\u3059\u308B\u5BA3\u8A00\u3067\u3042\u3063\u3066\u30011 \u884C\u306B\u5BFE\u3059\u308B\u5BA3\u8A00\u3067\u306F\u3042\u308A\u307E\u305B\u3093\uFF09`;
+      default:
+        return `${subject} "${path}" \u306B "**" \u306F\u542B\u3081\u3089\u308C\u307E\u305B\u3093\uFF08"**" \u306B\u610F\u5473\u3092\u4E0E\u3048\u308B\u306E\u304C\u3053\u306E\u5BA3\u8A00\u305D\u306E\u3082\u306E\u3067\u3059\uFF09`;
+    }
+  },
+  recursionRepeatNotString: (anchor) => `$recursion \u306E\u30A8\u30F3\u30C8\u30EA "${anchor}" \u306E\u5024\u306F\u53CD\u5FA9\u30B5\u30D6\u30D1\u30B9\u306E\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\uFF08\u4F8B: "children.*"\uFF09`,
+  recursionGetterInvalid: (key, problem, anchor) => {
+    switch (problem) {
+      case "setter":
+        return `\u518D\u5E30 setter \u306F\u521D\u7248\u3067\u306F\u672A\u5BFE\u5FDC\u3067\u3059: "${key}"\u3002\u901A\u5E38\u306E\u30D1\u30B9 setter \u3092\u5BA3\u8A00\u3059\u308B\u304B\u3001\u5177\u4F53\u30D1\u30B9\u7D4C\u7531\u3067\u66F8\u304D\u8FBC\u3093\u3067\u304F\u3060\u3055\u3044`;
+      case "notGetter":
+        return `"${key}" \u306F "**" \u3092\u542B\u307F\u307E\u3059\u304C getter \u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002"**" \u306F\u8A08\u7B97\u30D1\u30B9\u306E\u65CF\u3092\u540D\u6307\u3059\u8A18\u53F7\u3067\u3059`;
+      case "structural":
+        return `"${key}" \u306F\u518D\u5E30\u306E\u69CB\u9020\u305D\u306E\u3082\u306E\uFF08\u30CE\u30FC\u30C9\u30FB\u5B50\u30EA\u30B9\u30C8\u30FB\u305D\u306E length\u30FB\u5B50\u30EA\u30B9\u30C8\u3078\u81F3\u308B\u9014\u4E2D\u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\uFF09\u3092\u540D\u6307\u3057\u3066\u3044\u307E\u3059\u3002\u518D\u5E30 getter \u306F\u5168\u6DF1\u3055\u3067\u5B9F\u30C7\u30FC\u30BF\u306E\u5B50\u30EA\u30B9\u30C8\u3092\u5F71\u306B\u3057\u3066\u3057\u307E\u3044\u307E\u3059\u3002"**" \u306F\u30CE\u30FC\u30C9\u306E\u4E0B\u306E\u8A08\u7B97\u30D1\u30B9\uFF08\u4F8B: "${anchor}.total"\uFF09\u3092\u540D\u6307\u3059\u8A18\u53F7\u3067\u3059`;
+      default:
+        return `"${key}" \u306F\u518D\u5E30\u30CE\u30FC\u30C9\u81EA\u8EAB\u3092\u540D\u6307\u3057\u3066\u3044\u307E\u3059\u3002"**" \u306F\u30CE\u30FC\u30C9\u306E\u4E0B\u306E\u8A08\u7B97\u30D1\u30B9\uFF08\u4F8B: "${anchor}.total"\uFF09\u3092\u540D\u6307\u3059\u8A18\u53F7\u3067\u3001\u30CE\u30FC\u30C9\u305D\u306E\u3082\u306E\u3067\u306F\u3042\u308A\u307E\u305B\u3093`;
+    }
+  },
+  recursionGetterCollision: (a, b, repeat) => `"${a}" \u3068 "${b}" \u306F\u7570\u306A\u308B\u6DF1\u3055\u3067\u540C\u3058\u5177\u4F53\u30D1\u30B9\u3078\u5C55\u958B\u3057\u307E\u3059\uFF08\u5DEE\u304C "${repeat}" \u306E\u6574\u6570\u56DE\u3076\u3093\u3067\u3059\uFF09\u3002\u3069\u3061\u3089\u304B\u306E\u540D\u524D\u3092\u5909\u3048\u3066\u304F\u3060\u3055\u3044`,
+  recursionConcreteCollision: (concreteKey, recursiveKey) => `"${concreteKey}" \u306F state \u306B\u5B9A\u7FA9\u6E08\u307F\u306A\u306E\u3067\u3001\u518D\u5E30 getter "${recursiveKey}" \u306F\u305D\u3053\u3078\u5C55\u958B\u3067\u304D\u307E\u305B\u3093\uFF08\u30E9\u30F3\u30BF\u30A4\u30E0\u306F\u5BA3\u8A00\u3092\u8AAD\u3093\u3060\u6642\u70B9\u3067 throw \u3057\u307E\u3059\uFF09\u3002\u3069\u3061\u3089\u304B\u306E\u540D\u524D\u3092\u5909\u3048\u3066\u304F\u3060\u3055\u3044`,
+  recursionInMountedComponent: (subject) => `${subject} \u306F\u30DE\u30A6\u30F3\u30C8\u3055\u308C\u305F\u30B3\u30F3\u30DD\u30FC\u30CD\u30F3\u30C8\uFF08bind-component\uFF09\u3067\u306F\u5B9F\u884C\u3055\u308C\u307E\u305B\u3093\uFF08\u30E9\u30F3\u30BF\u30A4\u30E0\u306F wcs/mount-dollar-declaration \u3067\u8B66\u544A\u3057\u3001\u9ED9\u3063\u3066\u6368\u3066\u307E\u3059\uFF09\u3002$recursion \u3068 "**" getter \u306F\u30EB\u30FC\u30C8\u306E state \u306B\u7F6E\u3044\u3066\u304F\u3060\u3055\u3044 \u2014 \u30A2\u30F3\u30AB\u30FC\u306E\u30D1\u30B9\u306F\u30EB\u30FC\u30C8\u306E\u6728\u306B\u5BFE\u3057\u3066\u89E3\u6C7A\u3055\u308C\u307E\u3059`
 };
 var EN_EXPECTED_LABEL = {
   array: "an array-typed path",
@@ -2571,6 +3213,33 @@ var en = {
   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)`,
+  scanNotObject: () => `$scan must be an object mapping output names to { from | on, initial, fold, resetOn? } (the runtime throws on this shape at load time)`,
+  scanOutputInvalid: (n) => `$scan output name "${n}" must be a flat property name ("." and "*" and a leading "$" are not allowed)`,
+  scanOutputReserved: (n) => `$scan output name "${n}" is a property name inherited from Object.prototype (e.g. "constructor")`,
+  scanOutputEmpty: () => `$scan output name must be a non-empty string`,
+  scanInVolume: (mountPath) => `$scan cannot be declared in a volume (mount="${mountPath}"); the runtime throws before grafting. Declare the scan on the root state`,
+  scanInMountedComponent: () => `$scan is not run by a mounted component (bind-component); the runtime warns with wcs/mount-dollar-declaration and drops it. Declare the scan on the root state`,
+  scanOutputConflict: (n, other) => other === "getter" ? `$scan output "${n}" conflicts with a getter or setter of the same name (the output is a property the runtime owns)` : other === "method" ? `$scan output "${n}" conflicts with a method of the same name (the output is a property the runtime owns, so the folded value would overwrite the method)` : `$scan output "${n}" conflicts with the $streams entry of the same name (each output has exactly one owner)`,
+  scanEntryNotObject: (n) => `$scan entry "${n}" must be an object { from | on, initial, fold, resetOn? }`,
+  scanSourceCount: (n) => `$scan entry "${n}" must declare exactly one of "from" (a state path) or "on" (an event-token name)`,
+  scanFromNotString: (n) => `$scan entry "${n}" "from" must be a non-empty state path string`,
+  scanOnNotString: (n) => `$scan entry "${n}" "on" must be a non-empty event-token name`,
+  scanResetNotString: (n) => `$scan entry "${n}" "resetOn" must contain only state path strings`,
+  scanOutputCycle: (chain) => `$scan entries ${chain.map((c) => `"${c}"`).join(" \u2192 ")} feed each other through "from" (each fold would re-trigger the next forever)`,
+  scanInitialMissing: (n) => `$scan entry "${n}" requires "initial" (the seed of the accumulator and the value resetOn returns to)`,
+  scanFoldNotFunction: (n) => `$scan entry "${n}" fold must be a function`,
+  scanOnUndeclared: (n, t) => `$scan entry "${n}" on "${t}" is not declared in $eventTokens`,
+  scanPathInvalid: (n, f, p) => `$scan entry "${n}" ${f} "${p}" is not a valid state path (a leading "$", "@" and empty segments are not allowed)`,
+  scanPathReserved: (n, f, p) => `$scan entry "${n}" ${f} "${p}" is a property name inherited from Object.prototype (e.g. "constructor")`,
+  scanFromSelf: (n, p) => `$scan entry "${n}" from "${p}" reads the entry's own output (it would fold its own writes forever)`,
+  scanResetNotArray: (n) => `$scan entry "${n}" "resetOn" must be an array of state paths`,
+  scanResetWildcard: (n, p) => `$scan entry "${n}" resetOn "${p}" must not contain "*" (a reset returns the whole output to initial)`,
+  scanResetIsFrom: (n, p) => `$scan entry "${n}" resetOn "${p}" is the entry's own from (every change would reset instead of fold)`,
+  scanResetUnderFrom: (n, p, from) => `$scan entry "${n}" resetOn "${p}" sits under the entry's own from "${from}" (every write of from also lands it, so the reset would win every time and nothing would fold)`,
+  scanResetReadsOutput: (n, p, o) => `$scan entry "${n}" resetOn "${p}" reads the $scan output "${o}" (a reset driven by an accumulator is a feedback loop). Reset on the plain inputs instead`,
+  scanSourceComputed: (n, f, p, g) => `$scan entry "${n}" ${f} "${p}" ${g === p ? "is a getter" : g.includes("**") ? `is computed by the recursive getter "${g}"` : `is under the getter "${g}"`}. A getter re-evaluates whenever its inputs change, so folding it counts re-evaluations, not events. Point at the plain value the getter reads, or use "on" with an event token`,
+  scanFromWriteOnly: (n, p, s) => `$scan entry "${n}" from "${p}" ${s === p ? "is a setter without a getter" : `is under the setter without a getter "${s}"`}, so it always reads undefined and every fold would receive undefined. Point at the plain value the setter writes, or use "on" with an event token`,
+  scanPathMissing: (n, f, p) => `$scan entry "${n}" ${f} "${p}" does not exist in the state definition (${f === "from" ? "it will never fold" : "it will never reset"})`,
   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.`,
@@ -2599,7 +3268,96 @@ var en = {
       default:
         return `"mount" path "${mountPath}" must not use reserved characters ($, #, @).`;
     }
-  }
+  },
+  recursionUnsupported: (p, where) => {
+    switch (where) {
+      case "binding":
+        return `"**" in "${p}" cannot be used in data-wcs. "**" is only meaningful in a $recursion declaration, in a recursive getter key, and in the path argument of $getAll / $setAll (the runtime throws when the binding is established). Write the expanded concrete path in HTML instead`;
+      case "watch":
+        return `$watch key "${p}" cannot contain "**" \u2014 watching is defined against a concrete path (a fixed number of "*")`;
+      case "resolve":
+        return `$resolve("${p}") cannot take "**" \u2014 it accepts only an expanded concrete path with an exactly matching index tuple`;
+      case "assignment":
+        return `this["${p}"] = \u2026 cannot use "**" (there are no recursive setters in this version; an assignment only resolves against an expanded concrete path). Broadcast with $setAll("${p}", [], value), or write a concrete path`;
+      case "postUpdate":
+        return `$postUpdate("${p}") cannot take "**" \u2014 a notification is defined against a concrete path (a fixed number of "*")`;
+      case "trackDependency":
+        return `$trackDependency("${p}") cannot take "**" \u2014 a dependency is registered against a concrete path (a fixed number of "*")`;
+      case "listKeys":
+        return `$listKeys key "${p}" cannot contain "**" \u2014 a keyed list is one concrete list path. Declare the key per depth instead (for example "nodes.*.children")`;
+      case "scan":
+        return `$scan path "${p}" cannot contain "**" \u2014 "from" and "resetOn" name a concrete path (a fixed number of "*")`;
+      default:
+        return `"${p}" contains "**" but this state declares no $recursion anchor. Declare $recursion = { "<anchor>": "<repeat>" } (for example { "nodes.*": "children.*" }) \u2014 without it a "**" key is silently ignored`;
+    }
+  },
+  recursionAnchorMismatch: (p, anchor) => `"${p}" does not match the declared recursion anchor "${anchor}" (this version supports exactly one self-recursive anchor per state, and "**" must be followed by a well-formed suffix: no second "**", no empty segment, no bare "*" right after "**")`,
+  recursionGetAllForm: (p, problem) => problem === "notArray" ? `$getAll("${p}", indexes) with "**" takes either no indexes (to read the depth of the recursive getter being evaluated) or [] (to walk every depth) \u2014 not null or a non-array value` : `$getAll("${p}", indexes) with "**" takes no partial prefix: a prefix cannot say which depth it applies to. Omit the indexes to read the depth of the recursive getter being evaluated, or pass [] to walk every depth`,
+  recursionSetAllForm: (p, problem) => {
+    switch (problem) {
+      case "prefix":
+        return `$setAll("${p}", indexes, \u2026) with "**" takes no partial prefix: a prefix cannot say which depth it applies to. Pass [] to broadcast to every depth`;
+      case "noIndexes":
+        return `$setAll("${p}", \u2026) with "**" requires an explicit empty indexes array ([]) \u2014 the write API takes no context`;
+      case "mapper":
+        return `$setAll("${p}", \u2026) with "**" does not take a mapper \u2014 the index tuple has a different length at each depth. Pass a constant value`;
+      default:
+        return `$setAll("${p}", \u2026) with "**" does not take { spread: true } \u2014 handing a flat array to a tree needs the author to know the walk order, which is not a usable contract`;
+    }
+  },
+  recursionStructuralWrite: (p, target, repeatList) => {
+    switch (target) {
+      case "node":
+        return `$setAll("${p}") writes the recursion structure itself (a node). This version broadcasts to leaf properties only \u2014 replacing a node would invalidate the child addresses already resolved for this write`;
+      case "branch":
+        return `$setAll("${p}") writes the recursion structure itself (an object on the way to the "${repeatList}" list). This version broadcasts to leaf properties only \u2014 replacing it would invalidate the child addresses already resolved below it`;
+      case "length":
+        return `$setAll("${p}") writes the recursion structure itself (the length of the "${repeatList}" list). Assigning length truncates the array, which invalidates the child addresses already resolved below it just like replacing the list`;
+      default:
+        return `$setAll("${p}") writes the recursion structure itself (the "${repeatList}" list). This version broadcasts to leaf properties only`;
+    }
+  },
+  recursionReadonly: (subject, getterPath) => `${subject} writes into the recursive getter "${getterPath}", which has no setter in this version (this spelling is that getter at one depth, or a path inside the value it derives). Write the values it derives from instead`,
+  recursionInVolume: (subject, mountPath) => `${subject} cannot be declared in a volume (mount="${mountPath}"); the runtime throws before grafting. Declare the recursion and its "**" getters on the root state \u2014 the anchor path is resolved against the root tree`,
+  recursionNotObject: () => `$recursion must be an object mapping one anchor path to its repeating sub-path (for example { "nodes.*": "children.*" }; the runtime throws at load time for this shape)`,
+  recursionAnchorCount: (count) => count === 0 ? `$recursion must declare exactly one anchor; it is empty` : `$recursion declares ${count} anchors. This version supports exactly one self-recursive anchor per state`,
+  recursionNodePathInvalid: (kind, path, problem) => {
+    const subject = kind === "anchor" ? "$recursion anchor" : "$recursion repeating sub-path";
+    switch (problem) {
+      case "empty":
+        return `${subject} must be a non-empty string`;
+      case "emptySegment":
+        return `${subject} "${path}" must not contain empty path segments`;
+      case "notElement":
+        return `${subject} "${path}" must name a list element: a property path ending with ".*" (for example "nodes.*")`;
+      case "reservedRoot":
+        return `${subject} "${path}" must not start with "$" \u2014 that namespace is reserved`;
+      case "reservedMount":
+        return `${subject} "${path}" must not contain "#" \u2014 that segment is reserved for mounts`;
+      case "midWildcard":
+        return `${subject} "${path}" must have exactly one "*", at the end (wildcards in the middle are not supported in this version)`;
+      case "indexSegment":
+        return `${subject} "${path}" must not contain an index segment \u2014 the recursion is declared over the shape of the tree, not over one row`;
+      default:
+        return `${subject} "${path}" must not contain "**" \u2014 the declaration is what gives "**" its meaning`;
+    }
+  },
+  recursionRepeatNotString: (anchor) => `$recursion entry "${anchor}" must map to the repeating sub-path as a string (for example "children.*")`,
+  recursionGetterInvalid: (key, problem, anchor) => {
+    switch (problem) {
+      case "setter":
+        return `Recursive setters are not supported in this version: "${key}". Declare a plain path setter, or write through the concrete path`;
+      case "notGetter":
+        return `"${key}" contains "**" but is not a getter. The recursion wildcard only names a family of computed paths`;
+      case "structural":
+        return `"${key}" names the recursion structure itself (a node, its child list, that list's length, or an object on the way to the list). A recursive getter would hide the real child list at every depth \u2014 "**" names a computed leaf under a node (for example "${anchor}.total")`;
+      default:
+        return `"${key}" names the recursive node itself. "**" names a computed path under a node (for example "${anchor}.total"), not the node`;
+    }
+  },
+  recursionGetterCollision: (a, b, repeat) => `"${a}" and "${b}" expand to the same concrete path at different depths (they differ by whole repetitions of "${repeat}"). Rename one of them`,
+  recursionConcreteCollision: (concreteKey, recursiveKey) => `"${concreteKey}" is already defined on the state, so the recursive getter "${recursiveKey}" cannot expand to it (the runtime throws when the declaration is read). Rename one of them`,
+  recursionInMountedComponent: (subject) => `${subject} is not run by a mounted component (bind-component); the runtime warns with wcs/mount-dollar-declaration and drops it. Declare $recursion and "**" getters on the root state \u2014 the anchor path is resolved against the root tree`
 };
 var CATALOGS = { ja, en };
 function getMessages(locale3) {
@@ -2729,7 +3487,11 @@ function validateBindings(html, attrName, stateTagName = "wcs-state", locale3, f
           }
           if (checkPath) {
             const schema = applicationSchema;
-            const verdict = schema !== void 0 ? validateSchemaPathExistence(checkPath, pathTrimmed, scopedPaths, scopedPathSet, commandNames, schema, msgs) : toMissingVerdict(validatePathExistence(checkPath, pathTrimmed, scopedPaths, scopedPathSet, commandNames, msgs));
+            const verdict = hasRecursionWildcard(checkPath) ? {
+              code: WcsDiagnosticCode.RecursionUnsupported,
+              message: msgs.recursionUnsupported(checkPath, "binding"),
+              severity: "error"
+            } : schema !== void 0 ? validateSchemaPathExistence(checkPath, pathTrimmed, scopedPaths, scopedPathSet, commandNames, schema, msgs) : toMissingVerdict(validatePathExistence(checkPath, pathTrimmed, scopedPaths, scopedPathSet, commandNames, msgs));
             if (verdict) {
               const pathOffset = binding.indexOf(parsed.path);
               const pathStart = bindingStart + pathOffset;
@@ -2748,7 +3510,7 @@ function validateBindings(html, attrName, stateTagName = "wcs-state", locale3, f
         const pathTrimmed = parsed.path.trim();
         const prop = parsed.property.replace(/#.*$/, "");
         const insideFor = isInsideForTemplate(html, attr.valueStart, attrName);
-        if (pathTrimmed && !prop.startsWith("on")) {
+        if (pathTrimmed && !prop.startsWith("on") && !hasRecursionWildcard(pathTrimmed)) {
           if (!insideFor && pathTrimmed.includes("*")) {
             const pathOffset = binding.indexOf(parsed.path);
             const pathStart = bindingStart + pathOffset;
@@ -3028,11 +3790,16 @@ function validatePathExistence(checkPath, displayPath, scopedPaths, scopedPathSe
     }
     return null;
   }
-  if (!scopedPathSet.has(checkPath)) {
+  if (!scopedPathSet.has(checkPath) && !matchesRecursionCandidates(scopedPaths, checkPath, scopedPathSet)) {
     return msgs.pathMissing(displayPath);
   }
   return null;
 }
+function matchesRecursionCandidates(scopedPaths, checkPath, scopedPathSet) {
+  const specs = collectRecursionSpecs(scopedPaths);
+  if (specs.length === 0) return false;
+  return matchesRecursion(specs, checkPath, (candidate) => scopedPathSet.has(candidate));
+}
 function toMissingVerdict(message) {
   return message ? { code: WcsDiagnosticCode.BindingPathMissing, message, severity: "warning" } : null;
 }
@@ -3041,6 +3808,7 @@ function validateSchemaPathExistence(checkPath, displayPath, scopedPaths, scoped
     return toMissingVerdict(validatePathExistence(checkPath, displayPath, scopedPaths, scopedPathSet, commandNames, msgs));
   }
   if (scopedPathSet.has(checkPath)) return null;
+  if (matchesRecursionCandidates(scopedPaths, checkPath, scopedPathSet)) return null;
   const resolution = resolveSchemaPath(schema, schema.$defs ?? {}, checkPath.split("."));
   if (resolution.kind === "nonexistent") {
     return { code: WcsDiagnosticCode.PathNonexistent, message: msgs.pathNonexistent(displayPath), severity: "error" };
@@ -3454,6 +4222,13 @@ function validateTemplateSyntax(html, stateTagName, bindAttrName = "data-wcs", l
   const allPaths = mergeSchemaCandidates(getStatePathsFromHtml(html, stateTagName, fileReader), applicationSchema);
   const defaultSchema = applicationSchema;
   const missingVerdict = (path, displayPath, pathSet2, scoped) => {
+    if (hasRecursionWildcard(path)) {
+      return {
+        code: WcsDiagnosticCode.RecursionUnsupported,
+        severity: "error",
+        message: msgs.recursionUnsupported(path, "binding")
+      };
+    }
     if (isValidTemplatePath(path, pathSet2, scoped)) return null;
     if (defaultSchema !== void 0 && !path.startsWith("$")) {
       const resolution = resolveSchemaPath(defaultSchema, defaultSchema.$defs ?? {}, path.split("."));
@@ -3586,7 +4361,7 @@ function isValidTemplatePath(path, pathSet, scopedPaths) {
     const hasNamespace = scopedPaths.some((p) => p.path.startsWith(prefix));
     return !hasNamespace || pathSet.has(path);
   }
-  return pathSet.has(path);
+  return pathSet.has(path) || matchesRecursionCandidates(scopedPaths, path, pathSet);
 }
 
 // src/service/generated/builtinTags.generated.ts
@@ -5258,96 +6033,873 @@ function collectSignalsRefs(html) {
       }
       continue;
     }
-    if (!/\btype\s*=\s*(["'])module\1/i.test(match[1])) continue;
-    const bodyStart = match.index + match[0].indexOf(">") + 1;
-    const body = blankJsComments(match[2]);
-    const importRegex = /(?:\bfrom\s*|\bimport\s*\(?\s*)(["'])([^"']*@wcstack\/signals[^"']*)\1/g;
-    let im;
-    while ((im = importRegex.exec(body)) !== null) {
-      const kind = classifySignalsSpecifier(im[2]);
-      if (!kind) continue;
-      const specStart = bodyStart + im.index + im[0].indexOf(im[1]) + 1;
-      refs.push({ kind, start: specStart, end: specStart + im[2].length });
+    if (!/\btype\s*=\s*(["'])module\1/i.test(match[1])) continue;
+    const bodyStart = match.index + match[0].indexOf(">") + 1;
+    const body = blankJsComments(match[2]);
+    const importRegex = /(?:\bfrom\s*|\bimport\s*\(?\s*)(["'])([^"']*@wcstack\/signals[^"']*)\1/g;
+    let im;
+    while ((im = importRegex.exec(body)) !== null) {
+      const kind = classifySignalsSpecifier(im[2]);
+      if (!kind) continue;
+      const specStart = bodyStart + im.index + im[0].indexOf(im[1]) + 1;
+      refs.push({ kind, start: specStart, end: specStart + im[2].length });
+    }
+  }
+  return refs;
+}
+function classifySignalsSpecifier(spec) {
+  if (!spec.includes("@wcstack/signals")) return null;
+  return /@wcstack\/signals\/dom\b/.test(spec) ? "dom" : "bare";
+}
+function extractSrc(openTag) {
+  const srcMatch = /\bsrc\s*=\s*(["'])(.*?)\1/i.exec(openTag);
+  if (!srcMatch) return null;
+  return {
+    value: srcMatch[2],
+    offsetInTag: srcMatch.index + srcMatch[0].indexOf(srcMatch[1]) + 1
+  };
+}
+function blankHtmlComments(html) {
+  return html.replace(/<!--[\s\S]*?-->/g, (m) => " ".repeat(m.length));
+}
+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", locale3) {
+  const msgs = getMessages(locale3);
+  const out = [];
+  for (const block of parseWcsScriptBlocks(html, stateTagName)) {
+    const nonObject = findNonObjectWatch(block.content);
+    if (nonObject !== null) {
+      out.push({
+        code: WcsDiagnosticCode.WatchDeclarationInvalid,
+        start: block.contentStart + nonObject.start,
+        end: block.contentStart + nonObject.end,
+        message: msgs.watchNotObject(),
+        severity: "error"
+      });
+    }
+    const entries = analyzeWatchEntries(block.content);
+    if (entries.length === 0) continue;
+    const paths = analyzeStatePaths(block.content);
+    const pathSet = new Set(paths.map((p) => p.path));
+    for (const entry of entries) {
+      const diagnostic = validateEntry(entry, pathSet, paths, 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, paths, 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 (hasRecursionWildcard(key)) {
+    return {
+      code: WcsDiagnosticCode.RecursionUnsupported,
+      message: msgs.recursionUnsupported(key, "watch"),
+      severity: "error"
+    };
+  }
+  if (entry.definitelyNotFunction) {
+    return invalid(msgs.watchHandlerNotFunction(key));
+  }
+  if (pathSet.size > 0 && !pathSet.has(key) && !matchesRecursion(collectRecursionSpecs(paths), key, (p) => pathSet.has(p))) {
+    return {
+      code: WcsDiagnosticCode.WatchPathMissing,
+      message: msgs.watchPathMissing(key),
+      severity: "warning"
+    };
+  }
+  return null;
+}
+
+// src/service/scanDeclarationValidator.ts
+function validateScanDeclarations(html, stateTagName = "wcs-state", locale3) {
+  const msgs = getMessages(locale3);
+  const out = [];
+  for (const element of parseWcsStateElements(html, stateTagName)) {
+    const mounted = element.bindComponent;
+    for (const block of element.scriptBlocks) {
+      if (block.mountPath !== null || mounted) {
+        const declaration = analyzeDeclarationSpans(block.content).find((span) => span.name === "$scan");
+        if (declaration !== void 0) {
+          out.push({
+            code: WcsDiagnosticCode.ScanDeclarationInvalid,
+            start: block.contentStart + declaration.start,
+            end: block.contentStart + declaration.end,
+            message: block.mountPath !== null ? msgs.scanInVolume(block.mountPath) : msgs.scanInMountedComponent(),
+            severity: block.mountPath !== null ? "error" : "warning"
+          });
+        }
+        continue;
+      }
+      const nonObject = findNonObjectScan(block.content);
+      if (nonObject !== null) {
+        out.push({
+          code: WcsDiagnosticCode.ScanDeclarationInvalid,
+          start: block.contentStart + nonObject.start,
+          end: block.contentStart + nonObject.end,
+          message: msgs.scanNotObject(),
+          severity: "error"
+        });
+      }
+      const entries = analyzeScanEntries(block.content);
+      if (entries.length === 0) continue;
+      const paths = analyzeStatePaths(block.content);
+      const context = {
+        paths,
+        pathSet: new Set(paths.map((p) => p.path)),
+        recursionSpecs: collectRecursionSpecs(paths),
+        tokens: readEventTokenNames(block.content),
+        outputs: new Set(entries.map((entry) => entry.name)),
+        msgs
+      };
+      const diagnostics = [
+        ...entries.flatMap((entry) => validateEntry2(entry, context)),
+        ...findOutputCycles(entries, context)
+      ];
+      for (const diagnostic of diagnostics) {
+        out.push({
+          code: diagnostic.code,
+          start: block.contentStart + diagnostic.start,
+          end: block.contentStart + diagnostic.end,
+          message: diagnostic.message,
+          severity: diagnostic.severity
+        });
+      }
+    }
+  }
+  return out;
+}
+function validateOutput(entry, context) {
+  const { name } = entry;
+  const invalid = (message) => ({ code: WcsDiagnosticCode.ScanDeclarationInvalid, message, severity: "error", start: entry.start, end: entry.end });
+  if (name.length === 0) {
+    return { ...invalid(context.msgs.scanOutputEmpty()), start: entry.start - 1, end: entry.end + 1 };
+  }
+  if (name.startsWith("$") || name.includes(".") || name.includes("*")) {
+    return invalid(context.msgs.scanOutputInvalid(name));
+  }
+  if (name in Object.prototype) {
+    return invalid(context.msgs.scanOutputReserved(name));
+  }
+  if (context.paths.some((p) => p.path === name && p.kind === "computed")) {
+    return invalid(context.msgs.scanOutputConflict(name, "getter"));
+  }
+  if (context.paths.some((p) => p.path === `$streamStatus.${name}`)) {
+    return invalid(context.msgs.scanOutputConflict(name, "stream"));
+  }
+  if (entry.notObject) {
+    return invalid(context.msgs.scanEntryNotObject(name));
+  }
+  if (context.paths.some((p) => p.path === name && p.kind === "method")) {
+    return invalid(context.msgs.scanOutputConflict(name, "method"));
+  }
+  return null;
+}
+function validateEntry2(entry, context) {
+  const outputProblem = validateOutput(entry, context);
+  if (outputProblem !== null) return [outputProblem];
+  if (!entry.readable) return [];
+  const { name } = entry;
+  const { msgs } = context;
+  const out = [];
+  const atName = (message) => ({ code: WcsDiagnosticCode.ScanDeclarationInvalid, message, severity: "error", start: entry.start, end: entry.end });
+  const atField = (field, message) => ({ code: WcsDiagnosticCode.ScanDeclarationInvalid, message, severity: "error", start: field.start, end: field.end });
+  if (entry.hasFrom === entry.hasOn) {
+    out.push(atName(msgs.scanSourceCount(name)));
+  }
+  if (entry.onNotString) {
+    out.push(atName(msgs.scanOnNotString(name)));
+  }
+  if (entry.fromNotString) {
+    out.push(atName(msgs.scanFromNotString(name)));
+  }
+  if (!entry.hasInitial) {
+    out.push(atName(msgs.scanInitialMissing(name)));
+  }
+  if (entry.foldMissingOrNotFunction) {
+    out.push(atName(msgs.scanFoldNotFunction(name)));
+  }
+  if (entry.on !== null && context.tokens !== null && !context.tokens.has(entry.on.value)) {
+    out.push(atField(entry.on, msgs.scanOnUndeclared(name, entry.on.value)));
+  }
+  const from = entry.from;
+  if (from !== null) {
+    const problem = checkPathForm(name, "from", from, msgs) ?? checkPathComputed(name, "from", from, context) ?? checkFromWriteOnly(name, from, context) ?? (from.value === name || from.value.startsWith(`${name}.`) ? atField(from, msgs.scanFromSelf(name, from.value)) : null) ?? checkPathMissing(name, "from", from, context);
+    if (problem !== null) out.push(problem);
+  }
+  if (entry.resetOnNotArray) {
+    out.push(atName(msgs.scanResetNotArray(name)));
+  }
+  if (entry.resetOnHasNonString) {
+    out.push(atName(msgs.scanResetNotString(name)));
+  }
+  for (const reset2 of entry.resetOn ?? []) {
+    const root = reset2.value.split(".")[0];
+    const problem = checkPathForm(name, "resetOn", reset2, msgs) ?? (reset2.value.includes("*") ? atField(reset2, msgs.scanResetWildcard(name, reset2.value)) : null) ?? checkPathComputed(name, "resetOn", reset2, context) ?? (from !== null && reset2.value === from.value ? atField(reset2, msgs.scanResetIsFrom(name, reset2.value)) : null) ?? (from !== null && reset2.value.startsWith(`${from.value}.`) ? atField(reset2, msgs.scanResetUnderFrom(name, reset2.value, from.value)) : null) ?? (context.outputs.has(root) ? atField(reset2, msgs.scanResetReadsOutput(name, reset2.value, root)) : null) ?? checkPathMissing(name, "resetOn", reset2, context);
+    if (problem !== null) out.push(problem);
+  }
+  return out;
+}
+function checkPathForm(name, field, target, msgs) {
+  const path = target.value;
+  const at2 = (code, message) => ({ code, message, severity: "error", start: target.start, end: target.end });
+  if (path.length === 0 || path.startsWith("$") || path.includes("@")) {
+    return at2(WcsDiagnosticCode.ScanDeclarationInvalid, msgs.scanPathInvalid(name, field, path));
+  }
+  if (path in Object.prototype) {
+    return at2(WcsDiagnosticCode.ScanDeclarationInvalid, msgs.scanPathReserved(name, field, path));
+  }
+  if (hasRecursionWildcard(path)) {
+    return at2(WcsDiagnosticCode.RecursionUnsupported, msgs.recursionUnsupported(path, "scan"));
+  }
+  if (path.split(".").some((segment) => segment.length === 0)) {
+    return at2(WcsDiagnosticCode.ScanDeclarationInvalid, msgs.scanPathInvalid(name, field, path));
+  }
+  return null;
+}
+function checkPathComputed(name, field, target, context) {
+  const segments = target.value.split(".");
+  const computed = new Set(context.paths.filter((p) => p.kind === "computed" && p.writeOnly !== true).map((p) => p.path));
+  const at2 = (getter) => ({
+    code: WcsDiagnosticCode.ScanSourceComputed,
+    message: context.msgs.scanSourceComputed(name, field, target.value, getter),
+    severity: "error",
+    start: target.start,
+    end: target.end
+  });
+  for (let i = 1; i <= segments.length; i++) {
+    const prefix = segments.slice(0, i).join(".");
+    if (computed.has(prefix)) {
+      return at2(prefix);
+    }
+  }
+  const recursive = new Set(context.paths.filter((p) => p.kind === "recursive").map((p) => p.path));
+  const found = { getter: null };
+  matchesRecursion(context.recursionSpecs, target.value, (candidate) => {
+    if (!recursive.has(candidate)) return false;
+    found.getter = candidate;
+    return true;
+  });
+  return found.getter === null ? null : at2(found.getter);
+}
+function checkFromWriteOnly(name, target, context) {
+  const writeOnly = new Set(context.paths.filter((p) => p.writeOnly === true).map((p) => p.path));
+  const segments = target.value.split(".");
+  for (let i = 1; i <= segments.length; i++) {
+    const prefix = segments.slice(0, i).join(".");
+    if (writeOnly.has(prefix)) {
+      return {
+        code: WcsDiagnosticCode.ScanDeclarationInvalid,
+        message: context.msgs.scanFromWriteOnly(name, target.value, prefix),
+        severity: "error",
+        start: target.start,
+        end: target.end
+      };
+    }
+  }
+  return null;
+}
+function checkPathMissing(name, field, target, context) {
+  const { paths, pathSet, recursionSpecs } = context;
+  if (paths.length > 0 && !pathSet.has(target.value) && // `$recursion` の展開形は、宣言済みの候補へ畳めれば存在する（`$watch` と同じ照合）
+  !matchesRecursion(recursionSpecs, target.value, (candidate) => pathSet.has(candidate))) {
+    return {
+      code: WcsDiagnosticCode.ScanPathMissing,
+      message: context.msgs.scanPathMissing(name, field, target.value),
+      severity: "warning",
+      start: target.start,
+      end: target.end
+    };
+  }
+  return null;
+}
+function findOutputCycles(entries, context) {
+  const fromByName = /* @__PURE__ */ new Map();
+  const next = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.from === null) continue;
+    const root = entry.from.value.split(".")[0];
+    if (root !== entry.name && context.outputs.has(root)) {
+      fromByName.set(entry.name, entry.from);
+      next.set(entry.name, root);
+    }
+  }
+  const out = [];
+  for (const [start, from] of fromByName) {
+    const chain = [start];
+    let current2 = next.get(start);
+    while (current2 !== void 0 && current2 !== start && chain.length <= next.size) {
+      chain.push(current2);
+      current2 = next.get(current2);
+    }
+    if (current2 === start) {
+      out.push({
+        code: WcsDiagnosticCode.ScanDeclarationInvalid,
+        message: context.msgs.scanOutputCycle([...chain, start]),
+        severity: "error",
+        start: from.start,
+        end: from.end
+      });
+    }
+  }
+  return out;
+}
+
+// src/service/scriptCallArgs.ts
+var STRING_LITERAL = /^\s*(["'])((?:\\.|(?!\1)[^\\])*)\1\s*$/;
+var TEMPLATE_NO_SUBST = /^\s*`((?:\\.|[^\\`$]|\$(?!\{))*)`\s*$/;
+function splitCallArgs(source, open) {
+  const args = [];
+  const starts = [];
+  let depth = 0;
+  let argStart = open;
+  let i = open;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote = ch;
+      i++;
+      while (i < source.length) {
+        if (source[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (source[i] === quote) {
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === ")" && depth === 0) {
+      args.push(source.slice(argStart, i));
+      starts.push(argStart);
+      return { args, starts, end: i + 1 };
+    }
+    if (ch === ")" || ch === "]" || ch === "}") {
+      depth--;
+      i++;
+      continue;
+    }
+    if (ch === "," && depth === 0) {
+      args.push(source.slice(argStart, i));
+      starts.push(argStart);
+      argStart = i + 1;
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return null;
+}
+function literalString(arg) {
+  const match = STRING_LITERAL.exec(arg);
+  if (match !== null) return match[2];
+  const template = TEMPLATE_NO_SUBST.exec(arg);
+  return template === null ? null : template[1];
+}
+function literalArrayLength(arg) {
+  const trimmed = arg.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return null;
+  const inner = trimmed.slice(1, -1);
+  if (inner.trim().length === 0) return 0;
+  if (/(^|[^.])\.\.\./.test(inner)) return null;
+  const parts = splitCallArgs(`${inner})`, 0);
+  if (parts === null) return null;
+  return parts.args.filter((part) => part.trim().length > 0).length;
+}
+function blankComments(source) {
+  const out = source.split("");
+  let i = 0;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote = ch;
+      i++;
+      while (i < source.length) {
+        if (source[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (source[i] === quote) {
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "/") {
+      while (i < source.length && source[i] !== "\n") {
+        out[i] = " ";
+        i++;
+      }
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "*") {
+      while (i < source.length && !(source[i] === "*" && source[i + 1] === "/")) {
+        out[i] = " ";
+        i++;
+      }
+      if (i < source.length) {
+        out[i] = " ";
+        out[i + 1] = " ";
+        i += 2;
+      }
+      continue;
+    }
+    i++;
+  }
+  return out.join("");
+}
+function createApiCallRegex(apis) {
+  return new RegExp(`\\.\\s*\\$(${apis.join("|")})\\s*\\(`, "g");
+}
+
+// src/service/recursionValidator.ts
+var RECURSION_APIS = ["getAll", "setAll", "resolve", "postUpdate", "trackDependency"];
+var UNSUPPORTED_API_SITE = {
+  $resolve: "resolve",
+  $postUpdate: "postUpdate",
+  $trackDependency: "trackDependency"
+};
+var BRACKET_ASSIGNMENT = new RegExp(`${ROOT_BRACKET}${ASSIGN_TAIL}`, "g");
+var PRE_BRACKET_INCDEC = new RegExp(`${PRE_INCDEC}${ROOT_BRACKET}`, "g");
+function validateRecursion(html, stateTagName = "wcs-state", locale3) {
+  const msgs = getMessages(locale3);
+  const out = [];
+  for (const element of parseWcsStateElements(html, stateTagName)) {
+    const mounted = element.bindComponent;
+    for (const block of element.scriptBlocks) {
+      if (!hasRecursionWildcard(block.content) && block.content.indexOf("$recursion") === -1) continue;
+      const declaration = analyzeRecursionDeclaration(block.content);
+      let spec = null;
+      let undeclared = false;
+      let getterSuffixes = [];
+      if (block.mountPath !== null) {
+        validateVolumeBlock(block.content, block.contentStart, block.mountPath, declaration, msgs, out);
+      } else if (mounted) {
+        validateMountedComponentBlock(block.content, block.contentStart, declaration, msgs, out);
+      } else {
+        spec = validateDeclaration(declaration, block.contentStart, msgs, out);
+        undeclared = declaration === null && hasDefaultExportObject(block.content) && !hasTopLevelSpread(block.content);
+        getterSuffixes = validateRecursiveGetters(block.content, block.contentStart, spec, undeclared, msgs, out);
+      }
+      validateListKeys(block.content, block.contentStart, msgs, out);
+      validateApiCalls(block.content, block.contentStart, spec, getterSuffixes, undeclared, msgs, out);
+      validateAssignments(block.content, block.contentStart, spec, getterSuffixes, msgs, out);
+    }
+  }
+  return out;
+}
+function push(out, code, start, end, message, severity = "error") {
+  out.push({ code, start, end, message, severity });
+}
+function validateVolumeBlock(script, offset2, mountPath, declaration, msgs, out) {
+  if (declaration !== null) {
+    push(
+      out,
+      WcsDiagnosticCode.RecursionDeclarationInvalid,
+      offset2 + declaration.start,
+      offset2 + declaration.end,
+      msgs.recursionInVolume("$recursion", mountPath)
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const span of analyzeDeclarationSpans(script)) {
+    if (!hasRecursionWildcard(span.name) || seen.has(span.name)) continue;
+    seen.add(span.name);
+    push(
+      out,
+      WcsDiagnosticCode.RecursionDeclarationInvalid,
+      offset2 + span.start,
+      offset2 + span.end,
+      msgs.recursionInVolume(`"${span.name}"`, mountPath)
+    );
+  }
+}
+function validateDeclaration(declaration, offset2, msgs, out) {
+  if (declaration === null) return null;
+  const code = WcsDiagnosticCode.RecursionDeclarationInvalid;
+  if (declaration.notObject) {
+    push(out, code, offset2 + declaration.start, offset2 + declaration.end, msgs.recursionNotObject());
+    return null;
+  }
+  if (declaration.entries.length !== 1) {
+    if (!declaration.objectLiteral) return null;
+    push(
+      out,
+      code,
+      offset2 + declaration.start,
+      offset2 + declaration.end,
+      msgs.recursionAnchorCount(declaration.entries.length)
+    );
+    return null;
+  }
+  const entry = declaration.entries[0];
+  const anchorProblem = checkNodePath(entry.anchor);
+  if (anchorProblem !== null) {
+    push(
+      out,
+      code,
+      offset2 + entry.start,
+      offset2 + entry.end,
+      msgs.recursionNodePathInvalid("anchor", entry.anchor, anchorProblem)
+    );
+    return null;
+  }
+  if (entry.repeat === null) {
+    if (entry.repeatDefinitelyNotString) {
+      push(
+        out,
+        code,
+        offset2 + entry.valueStart,
+        offset2 + entry.valueEnd,
+        msgs.recursionRepeatNotString(entry.anchor)
+      );
+    }
+    return null;
+  }
+  const repeatProblem = checkNodePath(entry.repeat);
+  if (repeatProblem !== null) {
+    push(
+      out,
+      code,
+      offset2 + entry.valueStart,
+      offset2 + entry.valueEnd,
+      msgs.recursionNodePathInvalid("repeat", entry.repeat, repeatProblem)
+    );
+    return null;
+  }
+  return makeRecursionSpec(entry.anchor, entry.repeat);
+}
+function validateRecursiveGetters(script, offset2, spec, undeclared, msgs, out) {
+  const seen = /* @__PURE__ */ new Set();
+  const spans = analyzeDeclarationSpans(script).filter((s) => hasRecursionWildcard(s.name)).filter((s) => seen.has(s.name) ? false : (seen.add(s.name), true));
+  if (spans.length === 0) return [];
+  const setterNames = new Set(
+    analyzeCallableBodies(script).filter((c) => c.accessor === "set").map((c) => c.name)
+  );
+  const suffixes = [];
+  const accepted = [];
+  for (const span of spans) {
+    const start = offset2 + span.start;
+    const end = offset2 + span.end;
+    if (spec === null) {
+      if (undeclared) {
+        push(
+          out,
+          WcsDiagnosticCode.RecursionUnsupported,
+          start,
+          end,
+          msgs.recursionUnsupported(span.name, "undeclared"),
+          "warning"
+        );
+      }
+      continue;
+    }
+    if (span.kind !== "getter") {
+      push(
+        out,
+        WcsDiagnosticCode.RecursionDeclarationInvalid,
+        start,
+        end,
+        msgs.recursionGetterInvalid(span.name, "notGetter", spec.recursiveAnchor)
+      );
+      continue;
+    }
+    if (setterNames.has(span.name)) {
+      push(
+        out,
+        WcsDiagnosticCode.RecursionDeclarationInvalid,
+        start,
+        end,
+        msgs.recursionGetterInvalid(span.name, "setter", spec.recursiveAnchor)
+      );
+      continue;
+    }
+    const suffix = splitRecursivePath(spec, span.name);
+    if (suffix === null) {
+      push(
+        out,
+        WcsDiagnosticCode.RecursionAnchor,
+        start,
+        end,
+        msgs.recursionAnchorMismatch(span.name, spec.recursiveAnchor)
+      );
+      continue;
+    }
+    if (suffix.length === 0) {
+      push(
+        out,
+        WcsDiagnosticCode.RecursionDeclarationInvalid,
+        start,
+        end,
+        msgs.recursionGetterInvalid(span.name, "nodeItself", spec.recursiveAnchor)
+      );
+      continue;
+    }
+    if (structuralWriteTarget(spec, foldSuffixIndexes(suffix)) !== null) {
+      push(
+        out,
+        WcsDiagnosticCode.RecursionDeclarationInvalid,
+        start,
+        end,
+        msgs.recursionGetterInvalid(span.name, "structural", spec.recursiveAnchor)
+      );
+      continue;
+    }
+    const collision = accepted.find((other) => sameFamily(spec, other.suffix, suffix));
+    if (collision !== void 0) {
+      push(
+        out,
+        WcsDiagnosticCode.RecursionDeclarationInvalid,
+        start,
+        end,
+        msgs.recursionGetterCollision(collision.name, span.name, spec.repeat)
+      );
+      continue;
     }
+    accepted.push({ name: span.name, suffix, start, end });
+    suffixes.push(suffix);
   }
-  return refs;
-}
-function classifySignalsSpecifier(spec) {
-  if (!spec.includes("@wcstack/signals")) return null;
-  return /@wcstack\/signals\/dom\b/.test(spec) ? "dom" : "bare";
-}
-function extractSrc(openTag) {
-  const srcMatch = /\bsrc\s*=\s*(["'])(.*?)\1/i.exec(openTag);
-  if (!srcMatch) return null;
-  return {
-    value: srcMatch[2],
-    offsetInTag: srcMatch.index + srcMatch[0].indexOf(srcMatch[1]) + 1
-  };
+  if (spec !== null && suffixes.length > 0) {
+    const reported = /* @__PURE__ */ new Set();
+    for (const span of analyzeDeclarationSpans(script)) {
+      if (hasRecursionWildcard(span.name) || reported.has(span.name)) continue;
+      const suffix = concreteExpansionSuffix(spec, suffixes, span.name);
+      if (suffix === null) continue;
+      reported.add(span.name);
+      push(
+        out,
+        WcsDiagnosticCode.RecursionDeclarationInvalid,
+        offset2 + span.start,
+        offset2 + span.end,
+        msgs.recursionConcreteCollision(span.name, spec.recursiveAnchor + suffix)
+      );
+    }
+  }
+  return suffixes;
 }
-function blankHtmlComments(html) {
-  return html.replace(/<!--[\s\S]*?-->/g, (m) => " ".repeat(m.length));
+function validateMountedComponentBlock(script, offset2, declaration, msgs, out) {
+  if (declaration !== null) {
+    push(
+      out,
+      WcsDiagnosticCode.RecursionDeclarationInvalid,
+      offset2 + declaration.start,
+      offset2 + declaration.end,
+      msgs.recursionInMountedComponent("$recursion"),
+      "warning"
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const span of analyzeDeclarationSpans(script)) {
+    if (!hasRecursionWildcard(span.name) || seen.has(span.name)) continue;
+    seen.add(span.name);
+    push(
+      out,
+      WcsDiagnosticCode.RecursionDeclarationInvalid,
+      offset2 + span.start,
+      offset2 + span.end,
+      msgs.recursionInMountedComponent(`"${span.name}"`),
+      "warning"
+    );
+  }
 }
-function blankJsComments(code) {
-  return code.replace(/\/\*[\s\S]*?\*\//g, (m) => " ".repeat(m.length)).replace(/(^|[^:])\/\/[^\n]*/g, (m, pre) => pre + " ".repeat(m.length - pre.length));
+function validateListKeys(script, offset2, msgs, out) {
+  for (const entry of analyzeListKeyEntries(script)) {
+    if (!hasRecursionWildcard(entry.key)) continue;
+    push(
+      out,
+      WcsDiagnosticCode.RecursionUnsupported,
+      offset2 + entry.start,
+      offset2 + entry.end,
+      msgs.recursionUnsupported(entry.key, "listKeys")
+    );
+  }
 }
-
-// src/service/watchDeclarationValidator.ts
-var STATE_NAME_SEPARATOR = "@";
-function validateWatchDeclarations(html, stateTagName = "wcs-state", locale3) {
-  const msgs = getMessages(locale3);
-  const out = [];
-  for (const block of parseWcsScriptBlocks(html, stateTagName)) {
-    const nonObject = findNonObjectWatch(block.content);
-    if (nonObject !== null) {
-      out.push({
-        code: WcsDiagnosticCode.WatchDeclarationInvalid,
-        start: block.contentStart + nonObject.start,
-        end: block.contentStart + nonObject.end,
-        message: msgs.watchNotObject(),
-        severity: "error"
-      });
+function validateApiCalls(script, offset2, spec, getterSuffixes, undeclared, msgs, out) {
+  const scan = blankComments(script);
+  const regex = createApiCallRegex(RECURSION_APIS);
+  let match;
+  while ((match = regex.exec(scan)) !== null) {
+    const api = `$${match[1]}`;
+    const parsed = splitCallArgs(scan, match.index + match[0].length);
+    if (parsed === null) continue;
+    regex.lastIndex = parsed.end;
+    if (parsed.args.length === 0) continue;
+    const pathArg = parsed.args[0];
+    const path = literalString(pathArg);
+    if (path === null) continue;
+    const leading = pathArg.length - pathArg.trimStart().length;
+    const start = offset2 + parsed.starts[0] + leading;
+    const end = offset2 + parsed.starts[0] + pathArg.trimEnd().length;
+    if (!hasRecursionWildcard(path)) {
+      const writes = api === "$setAll" || api === "$resolve" && parsed.args.length >= 3;
+      if (writes && spec !== null) {
+        const owning = owningGetterSuffix(spec, getterSuffixes, path);
+        if (owning !== null) {
+          push(
+            out,
+            WcsDiagnosticCode.RecursionReadonly,
+            start,
+            end,
+            msgs.recursionReadonly(`${api}("${path}")`, spec.recursiveAnchor + owning)
+          );
+        }
+      }
+      continue;
     }
-    const entries = analyzeWatchEntries(block.content);
-    if (entries.length === 0) continue;
-    const paths = analyzeStatePaths(block.content);
-    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
-      });
+    if (api in UNSUPPORTED_API_SITE) {
+      push(
+        out,
+        WcsDiagnosticCode.RecursionUnsupported,
+        start,
+        end,
+        msgs.recursionUnsupported(path, UNSUPPORTED_API_SITE[api])
+      );
+      continue;
+    }
+    if (spec === null) {
+      if (undeclared) {
+        push(out, WcsDiagnosticCode.RecursionUnsupported, start, end, msgs.recursionUnsupported(path, "undeclared"));
+      }
+      continue;
+    }
+    const suffix = splitRecursivePath(spec, path);
+    if (suffix === null) {
+      push(out, WcsDiagnosticCode.RecursionAnchor, start, end, msgs.recursionAnchorMismatch(path, spec.recursiveAnchor));
+      continue;
+    }
+    if (api === "$getAll") {
+      if (parsed.args.length > 1) {
+        const indexesArg = parsed.args[1];
+        const indexes = literalArrayLength(indexesArg);
+        if (indexes !== null && indexes > 0) {
+          push(out, WcsDiagnosticCode.RecursionGetAllForm, start, end, msgs.recursionGetAllForm(path, "prefix"));
+        } else if (indexes === null && isDefiniteNonArrayLiteral2(indexesArg)) {
+          push(out, WcsDiagnosticCode.RecursionGetAllForm, start, end, msgs.recursionGetAllForm(path, "notArray"));
+        }
+      }
+      continue;
     }
+    validateSetAllForm(path, suffix, parsed.args, spec, getterSuffixes, start, end, msgs, out);
   }
-  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));
+function validateSetAllForm(path, suffix, args, spec, getterSuffixes, start, end, msgs, out) {
+  const formCode = WcsDiagnosticCode.RecursionSetAllForm;
+  const indexesArg = args.length > 1 ? args[1].trim() : "";
+  if (args.length < 2 || indexesArg === "undefined" || indexesArg === "null") {
+    push(out, formCode, start, end, msgs.recursionSetAllForm(path, "noIndexes"));
+    return;
   }
-  if (key.startsWith("$")) {
-    return invalid(msgs.watchKeyReserved(key));
+  const indexes = literalArrayLength(args[1]);
+  if (indexes !== null && indexes > 0) {
+    push(out, formCode, start, end, msgs.recursionSetAllForm(path, "prefix"));
+    return;
   }
-  if (key.split(".").some((segment) => segment.length === 0)) {
-    return invalid(msgs.watchKeyEmptySegment(key));
+  if (args.length > 2 && isFunctionLiteral(args[2])) {
+    push(out, formCode, start, end, msgs.recursionSetAllForm(path, "mapper"));
+    return;
   }
-  if (entry.definitelyNotFunction) {
-    return invalid(msgs.watchHandlerNotFunction(key));
+  if (args.length > 3 && /\bspread\s*:\s*true\b/.test(args[3])) {
+    push(out, formCode, start, end, msgs.recursionSetAllForm(path, "spread"));
+    return;
   }
-  if (pathSet.size > 0 && !pathSet.has(key)) {
-    return {
-      code: WcsDiagnosticCode.WatchPathMissing,
-      message: msgs.watchPathMissing(key),
-      severity: "warning"
-    };
+  const checkedSuffix = foldSuffixIndexes(suffix);
+  const structural = structuralWriteTarget(spec, checkedSuffix);
+  if (structural !== null) {
+    push(
+      out,
+      WcsDiagnosticCode.RecursionStructuralWrite,
+      start,
+      end,
+      msgs.recursionStructuralWrite(path, structural, spec.repeatList)
+    );
+    return;
+  }
+  const conflicting = conflictingGetterSuffix(spec, getterSuffixes, checkedSuffix);
+  if (conflicting !== null) {
+    push(
+      out,
+      WcsDiagnosticCode.RecursionReadonly,
+      start,
+      end,
+      msgs.recursionReadonly(`$setAll("${path}")`, spec.recursiveAnchor + conflicting)
+    );
+  }
+}
+function validateAssignments(script, offset2, spec, getterSuffixes, msgs, out) {
+  const masked = maskCommentsAndStrings(script);
+  const found = [];
+  for (const source of [BRACKET_ASSIGNMENT, PRE_BRACKET_INCDEC]) {
+    const regex = new RegExp(source.source, "g");
+    let match;
+    while ((match = regex.exec(masked)) !== null) {
+      const pathStart = match.index + match[0].search(/["']/) + 1;
+      found.push({ pathStart, length: match[1].length });
+    }
+  }
+  found.sort((a, b) => a.pathStart - b.pathStart);
+  let last = -1;
+  for (const { pathStart, length } of found) {
+    if (pathStart === last) continue;
+    last = pathStart;
+    const path = script.slice(pathStart, pathStart + length);
+    const start = offset2 + pathStart;
+    const end = start + path.length;
+    if (hasRecursionWildcard(path)) {
+      push(out, WcsDiagnosticCode.RecursionUnsupported, start, end, msgs.recursionUnsupported(path, "assignment"));
+      continue;
+    }
+    if (spec === null) continue;
+    const owning = owningGetterSuffix(spec, getterSuffixes, path);
+    if (owning !== null) {
+      push(
+        out,
+        WcsDiagnosticCode.RecursionReadonly,
+        start,
+        end,
+        msgs.recursionReadonly(`this["${path}"] = \u2026`, spec.recursiveAnchor + owning)
+      );
+    }
   }
-  return null;
+}
+function isDefiniteNonArrayLiteral2(arg) {
+  const trimmed = arg.trim();
+  return trimmed === "null" || /^["'`]/.test(trimmed) || /^-?\d/.test(trimmed) || /^(?:true|false)$/.test(trimmed) || trimmed.startsWith("{");
+}
+function isFunctionLiteral(arg) {
+  const trimmed = arg.trim();
+  if (trimmed.length === 0) return false;
+  return /^(?:async\s+)?function\b/.test(trimmed) || /^(?:async\s+)?\([^()]*\)\s*=>/.test(trimmed) || /^(?:async\s+)?[$\w]+\s*=>/.test(trimmed);
 }
 
 // src/service/namedStateValidator.ts
@@ -11274,7 +12826,7 @@ function enterFunction(fn, outer, thisIsState) {
 function isThisRoot(node, scope) {
   return node.type === "ThisExpression" && scope.thisIsState || node.type === "Identifier" && scope.aliases.has(node.name);
 }
-function literalString(node) {
+function literalString2(node) {
   if (node.type === "Literal" && typeof node.value === "string") return node.value;
   if (node.type === "TemplateLiteral" && node.expressions.length === 0 && node.quasis.length === 1) {
     return node.quasis[0].value.cooked ?? null;
@@ -11289,7 +12841,7 @@ function segmentOf(member) {
   if (property.type === "Literal" && typeof property.value === "number") {
     return { text: String(property.value), dynamic: null };
   }
-  const text = literalString(property);
+  const text = literalString2(property);
   if (text !== null) return { text, dynamic: null };
   return property.type === "PrivateIdentifier" ? { text: null, dynamic: null } : { text: null, dynamic: property };
 }
@@ -11385,7 +12937,7 @@ function visitCall(node, scope, out) {
       if (api === UNTRACK_API) return;
       if (PATH_ARG_APIS.has(api)) {
         const first = node.arguments[0];
-        const path = first !== void 0 && first.type !== "SpreadElement" ? literalString(first) : null;
+        const path = first !== void 0 && first.type !== "SpreadElement" ? literalString2(first) : null;
         if (path !== null && path.length > 0 && !path.startsWith("$")) {
           out.push({
             path,
@@ -11451,7 +13003,7 @@ function visitDestructure(pattern, prefix, scope, out) {
     if (property.type === "RestElement") continue;
     let key = null;
     if (!property.computed && property.key.type === "Identifier") key = property.key.name;
-    else key = literalString(property.key);
+    else key = literalString2(property.key);
     let value = property.value;
     if (value.type === "AssignmentPattern") {
       visit(value.right, scope, out);
@@ -11484,6 +13036,10 @@ for (let i = 0; i < MAX_WILDCARD_DEPTH2; i++) {
   tmpIndexByIndexName2[`${INDEX_PARAM_PREFIX2}${i + 1}`] = i;
 }
 Object.freeze(tmpIndexByIndexName2);
+var RECURSION_WILDCARD2 = "**";
+function raiseError2(message) {
+  throw new Error(`[@wcstack/state] ${message}`);
+}
 var _cache = /* @__PURE__ */ new Map();
 function clearPathInfoCacheForTooling() {
   _cache.clear();
@@ -11494,6 +13050,9 @@ function getPathInfo(path) {
   if (typeof pathInfo !== "undefined") {
     return pathInfo;
   }
+  if (path.indexOf(RECURSION_WILDCARD2) !== -1) {
+    raiseError2(`[wcs/recursion-unsupported] "${path}" uses "${RECURSION_WILDCARD2}", which is not accepted here. It is only meaningful in a $recursion declaration, in a recursive getter key, and in the path argument of $getAll / $setAll \u2014 and only when the state declares a $recursion anchor.`);
+  }
   pathInfo = Object.freeze(new PathInfo(path));
   _cache.set(path, pathInfo);
   return pathInfo;
@@ -11617,9 +13176,6 @@ function didYouMean(input, candidates) {
   return best !== null ? ` Did you mean "${best}"?` : "";
 }
 var LINT_HINT = " Validate statically: npx @wcstack/lint <file>.";
-function raiseError2(message) {
-  throw new Error(`[@wcstack/state] ${message}`);
-}
 var STRUCTURAL_BINDING_TYPE_SET2 = /* @__PURE__ */ new Set([
   "if",
   "elseif",
@@ -12623,71 +14179,6 @@ function buildReferenceIndex(html, options = {}) {
 // src/service/semanticValidator.ts
 var STATE_UPDATED_CALLBACK = "$updatedCallback";
 var API_CALL = /\.\s*\$(getAll|setAll|resolve)\s*\(/g;
-var STRING_LITERAL = /^\s*(["'])((?:\\.|(?!\1)[^\\])*)\1\s*$/;
-function splitCallArgs(source, open) {
-  const args = [];
-  const starts = [];
-  let depth = 0;
-  let argStart = open;
-  let i = open;
-  while (i < source.length) {
-    const ch = source[i];
-    if (ch === '"' || ch === "'" || ch === "`") {
-      const quote = ch;
-      i++;
-      while (i < source.length) {
-        if (source[i] === "\\") {
-          i += 2;
-          continue;
-        }
-        if (source[i] === quote) {
-          i++;
-          break;
-        }
-        i++;
-      }
-      continue;
-    }
-    if (ch === "(" || ch === "[" || ch === "{") {
-      depth++;
-      i++;
-      continue;
-    }
-    if (ch === ")" && depth === 0) {
-      args.push(source.slice(argStart, i));
-      starts.push(argStart);
-      return { args, starts, end: i + 1 };
-    }
-    if (ch === ")" || ch === "]" || ch === "}") {
-      depth--;
-      i++;
-      continue;
-    }
-    if (ch === "," && depth === 0) {
-      args.push(source.slice(argStart, i));
-      starts.push(argStart);
-      argStart = i + 1;
-      i++;
-      continue;
-    }
-    i++;
-  }
-  return null;
-}
-function literalString2(arg) {
-  const match = STRING_LITERAL.exec(arg);
-  return match === null ? null : match[2];
-}
-function literalArrayLength(arg) {
-  const trimmed = arg.trim();
-  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return null;
-  const inner = trimmed.slice(1, -1);
-  if (inner.trim().length === 0) return 0;
-  if (/(^|[^.])\.\.\./.test(inner)) return null;
-  const parts = splitCallArgs(`${inner})`, 0);
-  if (parts === null) return null;
-  return parts.args.filter((part) => part.trim().length > 0).length;
-}
 function validateIndexArity(script, scriptStart, locale3) {
   const msgs = getMessages(locale3);
   const out = [];
@@ -12699,8 +14190,9 @@ function validateIndexArity(script, scriptStart, locale3) {
     if (parsed === null) continue;
     API_CALL.lastIndex = parsed.end;
     if (parsed.args.length < 2) continue;
-    const path = literalString2(parsed.args[0]);
+    const path = literalString(parsed.args[0]);
     if (path === null) continue;
+    if (hasRecursionWildcard(path)) continue;
     const actual = literalArrayLength(parsed.args[1]);
     if (actual === null) continue;
     const wildcardCount = countWildcardSegments(path);
@@ -12807,7 +14299,7 @@ function validateGetterUntrackedReads(script, scriptStart, nestedWriteRoots, loc
 }
 var TWO_WAY_PROPS = /* @__PURE__ */ new Set(["value", "checked"]);
 var BRACKET_WRITE = new RegExp(`${ROOT_BRACKET}${ASSIGN_TAIL}`, "g");
-var PRE_BRACKET_INCDEC = new RegExp(`${PRE_INCDEC}${ROOT_BRACKET}`, "g");
+var PRE_BRACKET_INCDEC2 = new RegExp(`${PRE_INCDEC}${ROOT_BRACKET}`, "g");
 function collectNestedWriteRoots(html, stateTagName, bindAttrName, blocks) {
   const roots = /* @__PURE__ */ new Set();
   const addPrefixes = (path, inclusive) => {
@@ -12843,7 +14335,7 @@ function collectNestedWriteRoots(html, stateTagName, bindAttrName, blocks) {
   for (const block of blocks) {
     if (block.mountPath !== null) addPrefixes(block.mountPath, true);
     const scan = blankComments(block.content);
-    for (const regex of [BRACKET_WRITE, PRE_BRACKET_INCDEC]) {
+    for (const regex of [BRACKET_WRITE, PRE_BRACKET_INCDEC2]) {
       regex.lastIndex = 0;
       let match;
       while ((match = regex.exec(scan)) !== null) addPrefixes(match[1], false);
@@ -12856,57 +14348,13 @@ function collectNestedWriteRoots(html, stateTagName, bindAttrName, blocks) {
       const parsed = splitCallArgs(scan, call.index + call[0].length);
       if (parsed === null) continue;
       API_CALL.lastIndex = parsed.end;
-      const path = parsed.args.length > 0 ? literalString2(parsed.args[0]) : null;
+      const path = parsed.args.length > 0 ? literalString(parsed.args[0]) : null;
       if (path === null) continue;
       if (api === "setAll" || parsed.args.length >= 3) addPrefixes(path, false);
     }
   }
   return roots;
 }
-function blankComments(source) {
-  const out = source.split("");
-  let i = 0;
-  while (i < source.length) {
-    const ch = source[i];
-    if (ch === '"' || ch === "'" || ch === "`") {
-      const quote = ch;
-      i++;
-      while (i < source.length) {
-        if (source[i] === "\\") {
-          i += 2;
-          continue;
-        }
-        if (source[i] === quote) {
-          i++;
-          break;
-        }
-        i++;
-      }
-      continue;
-    }
-    if (ch === "/" && source[i + 1] === "/") {
-      while (i < source.length && source[i] !== "\n") {
-        out[i] = " ";
-        i++;
-      }
-      continue;
-    }
-    if (ch === "/" && source[i + 1] === "*") {
-      while (i < source.length && !(source[i] === "*" && source[i + 1] === "/")) {
-        out[i] = " ";
-        i++;
-      }
-      if (i < source.length) {
-        out[i] = " ";
-        out[i + 1] = " ";
-        i += 2;
-      }
-      continue;
-    }
-    i++;
-  }
-  return out.join("");
-}
 var PATH_TEST_LITERAL = /(?:\.\s*(?:includes|indexOf)\s*\(\s*|[!=]==\s*)(["'])((?:\\.|(?!\1)[^\\])*)\1/g;
 function validateUpdatedCallbackDemand(html, stateTagName, bindAttrName, locale3) {
   const blocks = parseWcsScriptBlocks(html, stateTagName);
@@ -13011,6 +14459,8 @@ function validateDocument(text, options = {}) {
   out.push(...validateSemantics(text, stateTagName, locale3, bindAttribute));
   out.push(...validateArrayMutations(text, stateTagName, locale3));
   out.push(...validateWatchDeclarations(text, stateTagName, locale3));
+  out.push(...validateScanDeclarations(text, stateTagName, locale3));
+  out.push(...validateRecursion(text, stateTagName, locale3));
   out.push(...validateNamedState(text, bindAttribute, stateTagName, locale3));
   out.push(...validateMountAttributes(text, stateTagName, locale3));
   for (const d of validateStateTypes(text, stateTagName, locale3)) {