@wcstack/state 1.30.0 → 1.32.0

package/dist/index.esm.js

@@ -1,3 +1,60 @@
+// ===========================================================================
+// AUTO-GENERATED FILE - DO NOT EDIT.
+// Generated from /protocol/ssr-snapshot.ts by scripts/sync-protocol-types.mjs.
+// Run `node scripts/sync-protocol-types.mjs` after editing the source.
+// ===========================================================================
+// ssr-snapshot protocol — how the SSR renderer asks whoever owns reactive
+// state to build hydration snapshots (<wcs-ssr>) as a final pass, after every
+// DOM inserter (router route content, late custom elements) has settled.
+//
+// Without this, the snapshot is built inside <wcs-state>'s connectedCallback
+// and races DOM inserted by other packages: whether a route's structural
+// templates make it into the snapshot depends on document order and state's
+// load mechanism (docs/ssr-router-design.md §5).
+//
+// The provider (@wcstack/state) installs itself on a well-known global symbol
+// at bootstrap. The renderer (@wcstack/server) looks the builder up after
+// running bootstraps: if present it announces orchestration by setting
+// `data-wcs-server="orchestrated"` on the document element BEFORE parsing, and
+// calls build() right before serialization. The provider keeps its inline
+// per-element fallback whenever the attribute value is anything else, so:
+//   - old renderer + new provider  -> inline build, yesterday's behavior
+//   - new renderer + old provider  -> no builder found, attribute stays "",
+//     the old provider builds inline as before
+//   - new renderer + new provider  -> orchestrated: snapshots are built last
+//     and therefore always see settled DOM
+//
+// The symbol (rather than a package import) also pins the builder to the state
+// copy that actually runs on the page — its module-scoped fragment registries
+// are the ones the snapshot must read.
+//
+// SINGLE SOURCE OF TRUTH: edit only this file (/protocol/ssr-snapshot.ts), then
+// run `node scripts/sync-protocol-types.mjs` to regenerate the per-package
+// copies (packages/<pkg>/src/protocol/ssrSnapshot.ts). Those copies are
+// generated — do not edit them.
+/**
+ * Global key the snapshot builder installs itself under. `Symbol.for` so
+ * independently loaded copies of this file (state's and server's) still agree.
+ */
+const SSR_SNAPSHOT_BUILDER_KEY = Symbol.for("wcstack.ssr.snapshotBuilder");
+/**
+ * `data-wcs-server` attribute value announcing that the renderer will call the
+ * builder as a final pass. Providers must skip their inline per-element build
+ * when they see this value, and keep it for any other value (including "").
+ */
+const SSR_ORCHESTRATED_VALUE = "orchestrated";
+
+/**
+ * サーバー主導スナップショット（orchestrated）の判定
+ * （docs/ssr-router-design.md §5）。renderToString が snapshot builder を
+ * 見つけたときだけ `data-wcs-server="orchestrated"` を宣言する — 値が他の
+ * もの（旧 server の "" を含む）なら inline 生成が従来どおり働く。
+ * inSsr と同じ理由でキャッシュしない。
+ */
+function isOrchestratedSsr() {
+    const html = document.documentElement;
+    return html ? html.getAttribute('data-wcs-server') === SSR_ORCHESTRATED_VALUE : false;
+}
 function inSsr() {
     // キャッシュしない: SSR モードはプロセスの属性ではなく「現在の document」の
     // 属性。@wcstack/server はグローバル document を差し替えてサーバーレンダリング
@@ -351,14 +408,7 @@ function getCustomElement(node) {
     }
 }
 
-/**
- * Resolve the registry at operation time so importing the runtime remains safe
- * when browser globals are absent. The owner hook is reserved for scoped
- * registries; current callers fall back to the global registry.
- */
-function getCustomElementRegistry(owner = null) {
-    const globalRegistry = globalThis.customElements;
-    const registry = owner?.customElements ?? globalRegistry;
+function toAdapter(registry) {
     if (typeof registry !== "object" || registry === null)
         return null;
     const candidate = registry;
@@ -367,6 +417,33 @@ function getCustomElementRegistry(owner = null) {
     }
     return candidate;
 }
+/**
+ * Resolve the registry that governs `owner` at operation time, so importing the
+ * runtime stays safe when browser globals are absent.
+ *
+ * Pass the node the operation is about (the bound element, its shadow root):
+ * with scoped custom element registries the same tag name can resolve to a
+ * different constructor per tree, so "is this tag defined?" is only meaningful
+ * relative to a node. Nodes on platforms without scoped registries report
+ * `undefined` and fall back to the global registry, which keeps every existing
+ * caller on today's behaviour.
+ */
+function getCustomElementRegistry(owner = null) {
+    if (owner !== null && typeof owner !== "undefined") {
+        const { customElementRegistry: scoped, customElements: owned } = owner;
+        // A node in a null-registry subtree resolves to no registry at all. Falling
+        // back to the global one would report globally-defined tags as usable and
+        // let us write own properties onto elements that are still un-upgraded --
+        // exactly the accessor shadowing the deferred-apply path exists to avoid.
+        if (scoped === null)
+            return null;
+        if (typeof scoped !== "undefined")
+            return toAdapter(scoped);
+        if (typeof owned !== "undefined")
+            return toAdapter(owned);
+    }
+    return toAdapter(globalThis.customElements);
+}
 function upgradeCustomElement(registry, root) {
     registry.upgrade?.(root);
 }
@@ -544,7 +621,7 @@ function expandSpread(node, results, options = {}) {
         if (tagName === null) {
             raiseError(`Spread binding "${result.statePathName}" requires a custom element with wcBindable, but <${element.tagName.toLowerCase()}> is not a custom element.`);
         }
-        const registry = getCustomElementRegistry();
+        const registry = getCustomElementRegistry(element);
         if (registry === null) {
             raiseError(`CustomElementRegistry is unavailable for <${tagName}>.`);
         }
@@ -1122,16 +1199,33 @@ const fix = (options) => {
 /**
  * Locale number filter - formats number according to locale.
  *
+ * ロケール依存フィルタ（`locale` / `date` / `time` / `datetime`）は
+ * **明示引数だけを構築時に確定し、既定の `config.locale` は適用のたびに読む**。
+ *
+ * 以前は `options?.[0] ?? config.locale` を返り値の関数の**外**で解決していた。
+ * フィルタ関数はバインド構築時に一度だけ作られるので、これはロケールを
+ * クロージャに焼き込むことを意味する。`config.locale` の確定がバインド構築より
+ * 遅れると、それ以降どう直しても「同じページの中で日付だけ既定ロケール」が
+ * 永続し、しかも `config.locale` は依存グラフに載らないので再描画で回復もしない。
+ * 症状（日付だけ英語）は原因（起動順序）から遠く、追いにくい。
+ *
+ * 適用のたびに読めば、少なくとも**再適用されたバインドは回復する**。ロケールは
+ * 起動時に確定する前提（docs/i18n-design.md D1）なので通常この差は現れず、
+ * これは順序事故から復帰できるようにするための保険である。
+ *
+ * 明示引数（`|date(ja-JP)`）は構築時に固定でよい — バインド式の一部であり、
+ * 実行中に変わらない。
+ *
  * @param options - Array with locale string as first element (default: config.locale)
  * @returns Filter function that returns localized number string
  */
 const locale = (options) => {
-    const opt = options?.[0] ?? config.locale;
+    const explicit = options?.[0];
     return (value) => {
         if (typeof value !== 'number') {
             valueMustBeNumber('locale');
         }
-        return value.toLocaleString(opt);
+        return value.toLocaleString(explicit ?? config.locale);
     };
 };
 /**
@@ -1444,12 +1538,13 @@ const truncate = (options) => {
  * @returns Filter function that returns date string
  */
 const date = (options) => {
-    const opt = options?.[0] ?? config.locale;
+    // 既定ロケールは適用のたびに読む（`locale` フィルタの注記を参照）
+    const explicit = options?.[0];
     return (value) => {
         if (!(value instanceof Date)) {
             valueMustBeDate('date');
         }
-        return value.toLocaleDateString(opt);
+        return value.toLocaleDateString(explicit ?? config.locale);
     };
 };
 /**
@@ -1459,12 +1554,13 @@ const date = (options) => {
  * @returns Filter function that returns time string
  */
 const time = (options) => {
-    const opt = options?.[0] ?? config.locale;
+    // 既定ロケールは適用のたびに読む（`locale` フィルタの注記を参照）
+    const explicit = options?.[0];
     return (value) => {
         if (!(value instanceof Date)) {
             valueMustBeDate('time');
         }
-        return value.toLocaleTimeString(opt);
+        return value.toLocaleTimeString(explicit ?? config.locale);
     };
 };
 /**
@@ -1474,12 +1570,13 @@ const time = (options) => {
  * @returns Filter function that returns datetime string
  */
 const datetime = (options) => {
-    const opt = options?.[0] ?? config.locale;
+    // 既定ロケールは適用のたびに読む（`locale` フィルタの注記を参照）
+    const explicit = options?.[0];
     return (value) => {
         if (!(value instanceof Date)) {
             valueMustBeDate('datetime');
         }
-        return value.toLocaleString(opt);
+        return value.toLocaleString(explicit ?? config.locale);
     };
 };
 /**
@@ -2302,6 +2399,23 @@ function setLoopContextByNode(node, loopContext) {
     loopContextByNode.set(node, loopContext);
 }
 
+/**
+ * devtools/sink.ts
+ *
+ * 計装点が参照するホットパス唯一の接点。依存ゼロの葉モジュールにすることで、
+ * 計装される側（stateElementByName / setByAddress / binding / token）と
+ * bridge の間の循環 import を避ける。
+ *
+ * コスト規範（protocol §1-1）: フック未接続時、計装点のコストは
+ * `devtoolsSink !== null` の分岐 1 個。イベントオブジェクトの生成は
+ * 必ずこのチェックの内側で行うこと。
+ */
+/** live binding としてエクスポート。計装点は `if (devtoolsSink !== null)` で参照する */
+let devtoolsSink = null;
+function setDevtoolsSink(sink) {
+    devtoolsSink = sink;
+}
+
 const lastListValueByAbsoluteStateAddress = new WeakMap();
 function getLastListValueByAbsoluteStateAddress(address) {
     return lastListValueByAbsoluteStateAddress.get(address) ?? [];
@@ -2576,23 +2690,6 @@ function clearAbsoluteStateAddressByBinding(binding) {
     absoluteStateAddressByBinding.delete(binding);
 }
 
-/**
- * devtools/sink.ts
- *
- * 計装点が参照するホットパス唯一の接点。依存ゼロの葉モジュールにすることで、
- * 計装される側（stateElementByName / setByAddress / binding / token）と
- * bridge の間の循環 import を避ける。
- *
- * コスト規範（protocol §1-1）: フック未接続時、計装点のコストは
- * `devtoolsSink !== null` の分岐 1 個。イベントオブジェクトの生成は
- * 必ずこのチェックの内側で行うこと。
- */
-/** live binding としてエクスポート。計装点は `if (devtoolsSink !== null)` で参照する */
-let devtoolsSink = null;
-function setDevtoolsSink(sink) {
-    devtoolsSink = sink;
-}
-
 /**
  * 絶対アドレス → 登録 binding の台帳。
  *
@@ -3100,7 +3197,7 @@ function attachEventTokenHandler(binding) {
     const element = binding.node;
     // カスタム要素が未定義なら定義後に再試行（wcBindable が必要なため）。
     const customTagName = getCustomElement(element);
-    const registry = getCustomElementRegistry();
+    const registry = getCustomElementRegistry(element);
     if (customTagName !== null && registry?.get(customTagName) === undefined) {
         if (registry === null) {
             raiseError(`CustomElementRegistry is unavailable for <${customTagName}>.`);
@@ -3396,7 +3493,7 @@ function isPossibleTwoWay(node, propName) {
     }
     const customTagName = getCustomElement(element);
     if (customTagName !== null) {
-        const customClass = getCustomElementRegistry()?.get(customTagName);
+        const customClass = getCustomElementRegistry(element)?.get(customTagName);
         if (typeof customClass === "undefined") {
             raiseError(`Custom element <${customTagName}> is not defined. Cannot determine if property "${propName}" is suitable for two-way binding.`);
         }
@@ -3579,7 +3676,7 @@ function getEventName(binding) {
     // 2.wcBindable protocol
     const customTagName = getCustomElement(binding.node);
     if (customTagName !== null) {
-        const customClass = getCustomElementRegistry()?.get(customTagName);
+        const customClass = getCustomElementRegistry(binding.node)?.get(customTagName);
         if (typeof customClass === "undefined") {
             raiseError(`Custom element <${customTagName}> is not defined. Cannot determine event name for two-way binding.`);
         }
@@ -3751,7 +3848,7 @@ function addTwowayValueObserver(node, propName, observer) {
 function attachTwowayEventHandler(binding) {
     const customTagName = getCustomElement(binding.node);
     if (customTagName !== null) {
-        const registry = getCustomElementRegistry();
+        const registry = getCustomElementRegistry(binding.node);
         const customClass = registry?.get(customTagName);
         if (typeof customClass === "undefined") {
             if (registry === null) {
@@ -3777,7 +3874,7 @@ function attachTwowayEventHandler(binding) {
 function detachTwowayEventHandler(binding) {
     const customTagName = getCustomElement(binding.node);
     if (customTagName !== null) {
-        const registry = getCustomElementRegistry();
+        const registry = getCustomElementRegistry(binding.node);
         const customClass = registry?.get(customTagName);
         if (typeof customClass === "undefined") {
             if (registry === null) {
@@ -4162,7 +4259,9 @@ function propagateListPathToOuterState(innerStateElement, innerPath) {
     if (outerAbsPathInfo === null || outerAbsPathInfo.stateElement === innerStateElement) {
         return;
     }
-    outerAbsPathInfo.stateElement.setPathInfo(outerAbsPathInfo.pathInfo.path, "for");
+    // source="internal": 翻訳済みの外側パスであり、書き手が書いた文字列ではない。
+    // 存在検査に掛けても直せる相手が居ないので掛けない（pathDiagnostics.ts）。
+    outerAbsPathInfo.stateElement.setPathInfo(outerAbsPathInfo.pathInfo.path, "for", "internal");
 }
 /**
  * 子スコープのリスト行パス（`items.*.name`）に対応する親スコープの絶対パス情報を返す。
@@ -4546,6 +4645,16 @@ function addInterestedSession(node, session) {
     }
     interestedSessionsByNode.set(node, new Set([current, session]));
 }
+/**
+ * このノードに既にバインドが張られているか。
+ *
+ * binder プロトコル（`bind()`）の冪等判定に使う。`remember` が binding ごとに
+ * `addInterestedSession(binding.replaceNode, …)` を呼ぶので、バインド済みノードは
+ * 必ずこの台帳に載っている。新しい台帳を足さずに済むぶん、二重管理の齟齬が無い。
+ */
+function hasInterestedSession(node) {
+    return interestedSessionsByNode.has(node);
+}
 function forEachInterestedSession(node, callback) {
     const current = interestedSessionsByNode.get(node);
     if (typeof current === "undefined")
@@ -4799,7 +4908,7 @@ class BindingSession {
         return true;
     }
     deferUntilDefined(node, tagName, callback, reject = () => undefined) {
-        const registry = getCustomElementRegistry();
+        const registry = getCustomElementRegistry(node);
         if (registry === null) {
             raiseError(`CustomElementRegistry is unavailable for <${tagName}>.`);
         }
@@ -5253,7 +5362,7 @@ class BindingSession {
             attach();
             return;
         }
-        const registry = getCustomElementRegistry();
+        const registry = getCustomElementRegistry(record.info.node);
         if (registry === null) {
             raiseError(`CustomElementRegistry is unavailable for <${tagName}>.`);
         }
@@ -5626,7 +5735,7 @@ function getWcBindable(element) {
     if (customTagName === null) {
         return null;
     }
-    const customClass = getCustomElementRegistry()?.get(customTagName);
+    const customClass = getCustomElementRegistry(element)?.get(customTagName);
     if (typeof customClass === "undefined") {
         raiseError(`Custom element <${customTagName}> is not defined for command binding.`);
     }
@@ -6430,8 +6539,23 @@ class Content {
             let anchor = targetNode;
             for (const node of this._movableNodes()) {
                 if (anchor.nextSibling !== node) {
+                    // moveBefore も childList mutation record を出すため、マークは両分岐の前
                     markObserverSkipOnAdd(node);
-                    parentNode.insertBefore(node, anchor.nextSibling);
+                    // moveBefore は取り外しを伴わない移動 — 接続済み行の reorder で
+                    // フォーカス・iframe・アニメーション状態を保存する（docs/a11y-design.md §4-1）。
+                    // この 1 文は 4 つのノード状態を共有する: (a) 接続済み reorder、
+                    // (b) clone フラグメント由来（root 違い）、(c) プール/unmount 済み（親なし）、
+                    // (d) バッチフラグメント内。moveBefore は「同一ツリー・親あり」を要求し
+                    // (b)(c)(d) では HierarchyRequestError を投げるため、same-parent ガード
+                    // （同 root かつ親が非 null の同時証明 = フォーカス保存が意味を持つ (a) と
+                    // 正確に一致）は外せない。ガードを外す「簡略化」をしてはならない。
+                    const mover = parentNode;
+                    if (node.parentNode === parentNode && typeof mover.moveBefore === "function") {
+                        mover.moveBefore(node, anchor.nextSibling);
+                    }
+                    else {
+                        parentNode.insertBefore(node, anchor.nextSibling);
+                    }
                 }
                 anchor = node;
             }
@@ -6643,6 +6767,157 @@ function createContent(bindingInfo) {
     return content;
 }
 
+// ===========================================================================
+// AUTO-GENERATED FILE - DO NOT EDIT.
+// Generated from /protocol/transition-runner.ts by scripts/sync-protocol-types.mjs.
+// Run `node scripts/sync-protocol-types.mjs` after editing the source.
+// ===========================================================================
+// transition-runner protocol — how a package that mutates the DOM hands that
+// mutation to whoever is arbitrating view transitions on the page.
+//
+// @wcstack/state and @wcstack/router must not depend on @wcstack/view-transition
+// (zero runtime dependencies, independently publishable), so the arbiter installs
+// itself on a well-known global symbol and the participants look it up lazily.
+// No arbiter installed means the mutation is invoked directly, synchronously —
+// byte-for-byte the behavior these packages had before the protocol existed.
+//
+// docs/view-transition-design.md §4 is the normative description.
+//
+// SINGLE SOURCE OF TRUTH: edit only this file (/protocol/transition-runner.ts), then run
+// `node scripts/sync-protocol-types.mjs` to regenerate the per-package copies
+// (packages/<pkg>/src/protocol/transitionRunner.ts). Those copies are generated — do not edit them.
+/**
+ * Global key the arbiter installs itself under. `Symbol.for` so independently
+ * loaded copies of this file (two CDN bundles on one page) still agree.
+ */
+const TRANSITION_RUNNER_KEY = Symbol.for("wcstack.transition-runner");
+/**
+ * The installed arbiter, or null when there is none, it speaks a version this
+ * reader does not, or it does not accept this participant.
+ *
+ * Looked up on every call rather than cached: the tag can be added, removed, or
+ * reconfigured at any point in a page's life, and a stale cache would either
+ * animate what the author just switched off or miss what they switched on.
+ */
+function getTransitionRunner(source) {
+    const candidate = globalThis[TRANSITION_RUNNER_KEY];
+    if (candidate === undefined || candidate === null)
+        return null;
+    if (candidate.protocol !== "wcs-transition-runner")
+        return null;
+    if (typeof candidate.version !== "number" || candidate.version < 1)
+        return null;
+    if (typeof candidate.run !== "function")
+        return null;
+    if (typeof candidate.accepts !== "function" || !candidate.accepts(source))
+        return null;
+    return candidate;
+}
+/**
+ * Run `mutate` under the installed arbiter, or directly when there is none.
+ *
+ * Returns `undefined` in the no-arbiter case instead of a resolved promise: the
+ * state drain calls this on every batch, and awaiting is a caller's choice, not
+ * an allocation the common path should pay for. `await` accepts both.
+ */
+function runTransition(source, mutate, types) {
+    const runner = getTransitionRunner(source);
+    if (runner === null) {
+        mutate();
+        return undefined;
+    }
+    return runner.run(mutate, { source, types });
+}
+
+/** Elements that already carry a generated name (never renamed). */
+const namedElements = new WeakSet();
+/**
+ * The generated-name ledger is per *document*, not per module instance.
+ *
+ * `view-transition-name` has to be unique across the whole document: the moment
+ * two elements share one, the browser aborts the transition outright. A
+ * module-scope counter breaks that as soon as `@wcstack/state` is loaded twice on
+ * one page (two CDN bundles), because both copies would start minting
+ * `wcs-row-1`. The transition-runner key is a `Symbol.for` for exactly this
+ * reason, and the counter needs the same protection.
+ *
+ * Sharing the cap is right for the same reason: the cost a cap exists to bound —
+ * one snapshot group per named element — is a document-wide cost, not a
+ * per-bundle one.
+ */
+const NAMING_LEDGER_KEY = Symbol.for("wcstack.state.view-transition-naming");
+function getLedger() {
+    const slot = globalThis;
+    return (slot[NAMING_LEDGER_KEY] ??= { counter: 0, assigned: 0, warned: false });
+}
+/**
+ * The active auto-naming policy, or null when names are the author's business
+ * (the default) — one arbiter lookup per structural apply, not per row.
+ */
+function getAutoNaming() {
+    const runner = getTransitionRunner("state");
+    if (runner === null || runner.naming !== "auto") {
+        return null;
+    }
+    return { limit: runner.namingLimit };
+}
+function firstElementOf(content) {
+    const first = content.firstNode;
+    if (first === null) {
+        return null;
+    }
+    const last = content.lastNode;
+    for (let node = first; node !== null; node = node.nextSibling) {
+        if (node.nodeType === Node.ELEMENT_NODE) {
+            return node;
+        }
+        if (node === last) {
+            break;
+        }
+    }
+    return null;
+}
+/**
+ * Give this content's first element a unique name plus a class for group
+ * styling, unless it already has one or the cap has been reached.
+ *
+ * The cap exists because every named element becomes its own snapshot group; a
+ * few hundred of them make a transition visibly slow. Past it naming stops and
+ * says so once — silently degrading would leave the author wondering why only
+ * the first part of a list animates.
+ */
+function applyTransitionName(content, kind, naming) {
+    const element = firstElementOf(content);
+    if (element === null || namedElements.has(element)) {
+        return;
+    }
+    // A node without `style` (anything outside HTMLElement / SVGElement) cannot
+    // carry a name. Bail before touching the ledger: consuming the cap and marking
+    // the element as named would burn a slot for a name that was never written,
+    // and leave that element permanently ineligible.
+    const style = element.style;
+    if (style === undefined) {
+        return;
+    }
+    const ledger = getLedger();
+    if (ledger.assigned >= naming.limit) {
+        if (!ledger.warned) {
+            ledger.warned = true;
+            console.warn(`[@wcstack/state] auto view-transition-name limit (${naming.limit}) reached; ` +
+                "further elements are left unnamed. Raise naming-limit on <wcs-view-transition>, " +
+                'or switch to naming="manual" and name only what should morph.');
+        }
+        return;
+    }
+    namedElements.add(element);
+    ledger.assigned += 1;
+    ledger.counter += 1;
+    style.setProperty("view-transition-name", `wcs-${kind}-${ledger.counter}`);
+    // Group handle for CSS (`::view-transition-group(*.wcs-row)`). Ignored by
+    // engines that predate view-transition-class, which costs nothing.
+    style.setProperty("view-transition-class", `wcs-${kind}`);
+}
+
 const lastNodeByNode = new WeakMap();
 const contentByListIndexByNode = new WeakMap();
 const pooledContentsByNode = new WeakMap();
@@ -6810,6 +7085,10 @@ function applyChangeToFor(bindingInfo, context, newValue) {
         setRootNodeByFragment(fragment, context.rootNode);
     }
     const ssrMode = inSsr();
+    // 自動命名ポリシーは行ごとではなく apply ごとに 1 回だけ引く
+    // （docs/view-transition-design.md §6）。既定の manual では null で、
+    // 以降の行ループは分岐 1 つ分しか増えない。
+    const autoNaming = getAutoNaming();
     const uuid = bindingInfo.uuid ?? '';
     // 追加行ごとの WeakMap 解決を避けるためプール配列も 1 回だけ引く（プールの配列
     // 実体は setPooledContent が一度作ったら不変なので、delete ループ後の参照で安定）
@@ -6853,6 +7132,9 @@ function applyChangeToFor(bindingInfo, context, newValue) {
                 }
                 // コンテントを活性化
                 activateContent(content, loopContext, context);
+                if (autoNaming !== null) {
+                    applyTransitionName(content, "row", autoNaming);
+                }
             });
             if (typeof content === 'undefined') {
                 raiseError(`Content not found for ListIndex: ${index.index} at path "${listPathInfo.path}"`);
@@ -6952,6 +7234,11 @@ function applyChangeToIf(bindingInfo, context, rawNewValue) {
         }
         const loopContext = getLoopContextByNode(bindingInfo.node);
         activateContent(content, loopContext, context);
+        // 自動命名（docs/view-transition-design.md §6）。manual（既定）では null。
+        const autoNaming = getAutoNaming();
+        if (autoNaming !== null) {
+            applyTransitionName(content, "branch", autoNaming);
+        }
     }
 }
 
@@ -6969,7 +7256,7 @@ function getInputAttributeMirror(element, propName) {
     if (customTagName === null) {
         return null;
     }
-    const customClass = getCustomElementRegistry()?.get(customTagName);
+    const customClass = getCustomElementRegistry(element)?.get(customTagName);
     if (typeof customClass === "undefined") {
         return null;
     }
@@ -7329,6 +7616,281 @@ function applyChangeToWebComponent(binding, _context, _newValue) {
     });
 }
 
+/**
+ * pathDiagnostics.ts — バインド / `$watch` 対象パスの存在検査（silent failure の可視化）。
+ *
+ * なぜ必要か:
+ * `getByAddress` は「親が null / undefined のパスの読み」を undefined で返し、
+ * undefined はプロパティ書き込みがスキップされる値なので、`user.nmae` のような
+ * 打ち間違いは**エラーも警告も出さずに DOM が更新されない**だけになる。一方で
+ * トップレベルの打ち間違い（`cout`）は parentAddress を辿れず raiseError で落ちる。
+ * 同じ「パスを打ち間違えた」という 1 つの失敗が、パスの深さで silent / loud に
+ * 割れており、書き手からは区別がつかない。ここはその silent 側を埋める。
+ *
+ * 精度方針（過小近似）:
+ * 「確実に存在しない」と言い切れる場合にだけ報告する。getter の戻り値の先・
+ * 空配列・null 親・mapped な `bind-component` など、静的に決められない形はすべて
+ * `"unknown"` に倒して黙る（偽陽性ゼロ優先。docs/static-wiring-dx-design.md D7 /
+ * [ADR-06](../../docs/architecture-hardening/06-path-type-safety.md) の精度哲学）。
+ *
+ * 診断 code はコンソール → lint → IDE の三面で共有する（errorGuidance.ts の規約）。
+ */
+const UNKNOWN = Object.freeze({
+    existence: "unknown",
+    missingSegment: "",
+    candidates: Object.freeze([]),
+});
+const EXISTS = Object.freeze({
+    existence: "exists",
+    missingSegment: "",
+    candidates: Object.freeze([]),
+});
+/**
+ * `obj` 自身＋プロトタイプチェーン（Object.prototype 手前まで）から descriptor を引く。
+ * 打ち切り位置は getAllPropertyDescriptors と同じ — 「state が宣言したもの」だけを
+ * 存在とみなし、`toString` 等の Object.prototype 由来を存在扱いしない。
+ */
+function findDescriptor(obj, key) {
+    let proto = obj;
+    while (proto !== null && proto !== Object.prototype) {
+        const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+        if (typeof descriptor !== "undefined") {
+            return descriptor;
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return undefined;
+}
+/** `obj` 自身＋プロトタイプチェーンのキー名（did-you-mean の候補集合） */
+function ownKeys(obj) {
+    const keys = [];
+    let proto = obj;
+    while (proto !== null && proto !== Object.prototype) {
+        for (const key of Object.getOwnPropertyNames(proto)) {
+            keys.push(key);
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return keys;
+}
+/**
+ * 失敗した階層の兄弟候補。生オブジェクトのキーに加え、その階層にフラット宣言
+ * （ドットパス getter）されているものも混ぜる — `cart.items.*.subtotl` の正解
+ * `subtotal` は行オブジェクトには無く getterPaths にしか居ないため。
+ */
+function collectCandidates(container, parentPrefix, declaredPaths) {
+    const candidates = ownKeys(container);
+    const prefix = parentPrefix.length > 0 ? parentPrefix + DELIMITER : "";
+    for (const declared of declaredPaths) {
+        if (prefix.length > 0 && !declared.startsWith(prefix)) {
+            continue;
+        }
+        const rest = declared.slice(prefix.length);
+        // 直下の 1 セグメントだけを候補にする（孫は別階層の名前なので提案しない）
+        if (rest.length > 0 && rest.indexOf(DELIMITER) === -1) {
+            candidates.push(rest);
+        }
+    }
+    return candidates;
+}
+/**
+ * `target` に対して `path` が解決しうるかを、値を読まずに（getter を評価せずに）判定する。
+ *
+ * 解決の順序は `getByAddress` の実装に合わせる: まず「パス文字列そのものがキーか」
+ * （ドットパス getter がこれ）、次にセグメントを 1 つずつ降りる。
+ */
+function resolvePathExistence(target, path, declaredPaths) {
+    // ドットパス getter / フラットキーの完全一致（`get "users.*.fullName"()` 等）
+    if (findDescriptor(target, path) !== undefined) {
+        return EXISTS;
+    }
+    const segments = getPathInfo(path).segments;
+    let current = target;
+    let prefix = "";
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const parentPrefix = prefix;
+        prefix = i === 0 ? segment : prefix + DELIMITER + segment;
+        // 途中のプレフィックスがフラット宣言されている（`cart.totalPrice` が getter で、
+        // その戻り値のサブプロパティを読む形）。戻り値の形は評価しないと分からない
+        if (i > 0 && i < segments.length - 1 && findDescriptor(target, prefix) !== undefined) {
+            return UNKNOWN;
+        }
+        // null / undefined / primitive より深い読みは実行時 undefined 解決 = 判定不能。
+        // 「初期値 null のオブジェクトに後から代入する」形を偽陽性で潰さないため
+        if (Object(current) !== current) {
+            return UNKNOWN;
+        }
+        if (segment === WILDCARD) {
+            // 行の形は「いま入っている要素」からしか分からない。空配列・非配列は判定不能
+            if (!Array.isArray(current) || current.length === 0) {
+                return UNKNOWN;
+            }
+            current = current[0];
+            continue;
+        }
+        const descriptor = findDescriptor(current, segment);
+        if (typeof descriptor === "undefined") {
+            return {
+                existence: "missing",
+                missingSegment: segment,
+                candidates: collectCandidates(current, parentPrefix, declaredPaths),
+            };
+        }
+        if (typeof descriptor.get === "function") {
+            // getter の戻り値の先は評価しないと分からない（末尾なら存在は確定）
+            return i === segments.length - 1 ? EXISTS : UNKNOWN;
+        }
+        current = descriptor.value;
+    }
+    return EXISTS;
+}
+/** 診断 code は lint / IDE と同一語彙（errorGuidance.ts の三面共有規約） */
+const DIAGNOSTIC_CODE = {
+    binding: "wcs/binding-path-missing",
+    watch: "wcs/watch-path-missing",
+};
+const SUBJECT = {
+    binding: "Bound path",
+    watch: "$watch path",
+};
+/**
+ * ルート直下（単一セグメント）のパスが state に無いときのエラーメッセージ。
+ *
+ * この形だけは親アドレスを辿れないので読み取りが throw する ＝ 元から loud だが、
+ * 文面が `address.parentAddress is undefined path: cout` という内部実装の言葉で、
+ * 「打ち間違い」だと分からず did-you-mean も lint 誘導も無かった。深いパスの
+ * `console.warn` と同じ語彙に揃える。
+ */
+function missingRootPathMessage(stateName, path, target, declaredPaths) {
+    return `[${DIAGNOSTIC_CODE.binding}] Path "${path}" does not exist on state "${stateName}".` +
+        `${didYouMean(path, collectCandidates(target, "", declaredPaths))}${LINT_HINT}`;
+}
+/**
+ * `$resolve` / `$getAll` に渡した添字の本数がワイルドカードの本数と噛み合わない。
+ *
+ * 不足（`$resolve`）は元から throw していたが、**超過は両 API とも黙って無視**され、
+ * 取り違えた添字のまま「もっともらしい値」を返していた。本数はパス文字列から
+ * 決まるので、噛み合わないことは常にプログラマのミス。
+ */
+function indexArityMessage(api, path, wildcardCount, actual) {
+    // `$getAll` / `$setAll` の添字は前方一致の接頭辞なので上限、`$resolve` だけが厳密一致
+    // （docs/state-set-all-design.md §4）。
+    const requirement = api === "$resolve"
+        ? `exactly ${wildcardCount}`
+        : `at most ${wildcardCount}`;
+    return `[wcs/index-arity] ${api}("${path}") requires ${requirement} index(es) ` +
+        `("*" appears ${wildcardCount} time(s) in the path) but got ${actual}.${LINT_HINT}`;
+}
+/**
+ * `$getAll(path)`（添字省略）の既定値はループ文脈の添字 `[$1..$n]` だが、それを
+ * 敷けるのは path と文脈がワイルドカード連鎖を共有している場合だけ。共有ゼロなのに
+ * 文脈が添字を持っている場合、黙って全展開に倒すと「文脈で絞られている」という
+ * 書き手の期待と食い違い、異なる文脈の添字の流用とも区別が付かないため throw する。
+ *
+ * 実行時の評価文脈に依存する（`$setAll` の spread 長と同種）ので lint へは誘導しない。
+ */
+function getAllContextMismatchMessage(path, contextPath) {
+    return `$getAll("${path}") was called without indexes inside the loop context of ` +
+        `"${contextPath}", but the path shares no wildcard level with that context, ` +
+        `so the context indexes ($1..$n) do not apply. ` +
+        `Pass indexes explicitly ([] expands every level).`;
+}
+/**
+ * `$setAll(path, indexes, values, { spread: true })` の配列長がマッチ件数と噛み合わない。
+ *
+ * 静的には件数が分からない（実行時のリスト長に依存する）ので lint へは誘導しない。
+ * 黙って切り詰める／余りを捨てると誤配が通ってしまうため throw する
+ * （docs/state-set-all-design.md §3-3）。
+ */
+function setAllSpreadArityMessage(path, matched, actual) {
+    return `$setAll("${path}", …, { spread: true }) requires the values array to have ` +
+        `exactly one entry per matched address (matched ${matched}) but got ${actual}. ` +
+        `Did the list change between $getAll and $setAll?`;
+}
+/**
+ * `$setAll` の値と `options` の組み合わせが意味を成さない。
+ * （docs/state-set-all-design.md §3-1）
+ */
+function setAllValueKindMessage(path, reason) {
+    return `$setAll("${path}") ${reason}`;
+}
+/**
+ * ワイルドカードを解決するループ文脈が足りない（＝パスの階数 > スコープの階数）。
+ *
+ * `matrix.*.*` を 1 段の `for` の中で読む、`$2` を 1 段のループの中で読む、といった
+ * 取り違えがこれ。元の文面は `address.listIndex?.index is undefined path: matrix.*` /
+ * `Index not found at position 1 for loopContext:` という内部実装の言葉で、
+ * **何を間違えたのかが書かれていなかった**。
+ */
+function wildcardScopeMessage(subject, needed, available) {
+    return `[wcs/wildcard-rank] ${subject} needs ${needed} enclosing loop level(s) but the current ` +
+        `scope provides ${available}. Wrap it in that many "for" templates, or use $resolve(path, indexes) ` +
+        `to name the row explicitly.${LINT_HINT}`;
+}
+/** 同じ (state 要素, パス) の報告は 1 回だけにする台帳 */
+const reportedPathsByStateElement = new WeakMap();
+function alreadyReported(stateElement, path) {
+    let reported = reportedPathsByStateElement.get(stateElement);
+    if (typeof reported === "undefined") {
+        reported = new Set();
+        reportedPathsByStateElement.set(stateElement, reported);
+    }
+    if (reported.has(path)) {
+        return true;
+    }
+    reported.add(path);
+    return false;
+}
+/**
+ * バインド確立時 / `$watch` 宣言時にパスの存在を検査し、確実に存在しないものだけ報告する。
+ *
+ * 報告は `console.warn` に留める（`raiseError` にしない）:
+ * 判定は過小近似とはいえ動的にキーが生える形まで排除できたわけではなく、
+ * 既存ページを起動不能にする代償に見合わない。silent を破ることが目的であり、
+ * 停止させることではない。
+ */
+function checkDeclaredPath(stateElement, state, path, source) {
+    if (source === "internal" || typeof state === "undefined") {
+        return;
+    }
+    // `$command` / `$streamStatus` / `$1` 等の予約名前空間は raw state に実体を持たない
+    if (path.startsWith("$")) {
+        return;
+    }
+    // mapped な bind-component の子スコープはパスの正本を持たない（親側で解決される）
+    if (stateElement.hasMappedComponentState === true) {
+        return;
+    }
+    // 単一セグメントのバインディングは読み取り時に raiseError で loud に落ちるので、
+    // ここで二重に報告しない。`$watch` は落ちずに黙って発火しないだけなので検査する
+    const segments = getPathInfo(path).segments;
+    if (source === "binding" && segments.length < 2) {
+        return;
+    }
+    if (alreadyReported(stateElement, path)) {
+        return;
+    }
+    const result = resolvePathExistence(state, path, stateElement.getterPaths);
+    if (result.existence !== "missing") {
+        return;
+    }
+    // 接頭辞は raiseError と同じ `[@wcstack/state] [wcs/...]` の並び（コンソールの
+    // grep 単位をパッケージで揃える）
+    console.warn(`[@wcstack/state] [${DIAGNOSTIC_CODE[source]}] ${SUBJECT[source]} "${path}" does not resolve on state "${stateElement.name}": ` +
+        `"${result.missingSegment}" is not declared.${didYouMean(result.missingSegment, result.candidates)}` +
+        ` Updates to this path will be silently dropped.${LINT_HINT}`);
+    if (devtoolsSink !== null) {
+        devtoolsSink({
+            type: "state:path-unresolved",
+            source,
+            stateName: stateElement.name,
+            path,
+            missingSegment: result.missingSegment,
+        });
+    }
+}
+
 // indexName ... $1, $2, ...
 function getIndexValueByLoopContext(loopContext, indexName) {
     if (loopContext.listIndex === null) {
@@ -7340,7 +7902,10 @@ function getIndexValueByLoopContext(loopContext, indexName) {
     }
     const listIndex = listIndexAtWildcard(loopContext.listIndex, indexPos, loopContext.pathInfo.wildcardCount);
     if (listIndex === null) {
-        raiseError(`Index not found at position ${indexPos} for loopContext:`);
+        // 位置が範囲外 ＝ `$2` を 1 段のループの中で読んだ、という取り違え。
+        // 元の文面（`Index not found at position 1 for loopContext:`）は内部の言葉で、
+        // 何段必要で何段あるのかが書かれていなかった。
+        raiseError(wildcardScopeMessage(`"${indexName}"`, indexPos + 1, loopContext.pathInfo.wildcardCount));
     }
     return listIndex.index;
 }
@@ -7392,7 +7957,7 @@ function scheduleDeferredApply(binding, tagName) {
         return;
     }
     // Compatibility fallback for direct applyChange() callers outside a session.
-    const registry = getCustomElementRegistry();
+    const registry = getCustomElementRegistry(binding.replaceNode);
     if (registry === null) {
         scheduledBindings.delete(binding);
         reportFailure(tagName, new Error("CustomElementRegistry is unavailable."));
@@ -7536,7 +8101,7 @@ function applyChange(binding, context) {
     if (definedApplyVerifiedByBinding.get(binding) !== true) {
         const customTag = getCustomElement(binding.replaceNode);
         if (customTag) {
-            if (getCustomElementRegistry()?.get(customTag) === undefined) {
+            if (getCustomElementRegistry(binding.replaceNode)?.get(customTag) === undefined) {
                 // 未 define のカスタム要素へは今は適用できない（accessor 未確立の要素に
                 // 素の own property を書くと upgrade 後に class accessor を隠してしまう）。
                 // whenDefined 後に最新 state 値で再適用する（two-way attach / deferred
@@ -7587,6 +8152,26 @@ function applyChange(binding, context) {
     }
 }
 
+/**
+ * バインディング 1 本の適用失敗を報告する（握り潰しではない）。
+ *
+ * `console.error` だけだと devtools からは「静かに握られた失敗」が見えないため、
+ * 同じ地点から sink にも流す（`state:watch-error` と同じ位置づけ）。
+ * 値と DOM は巻き戻さない — 伝播 hop 上限超過・watch 連鎖打ち切りと同じ姿勢。
+ */
+function reportBindingApplyError(binding, error) {
+    console.error(`[@wcstack/state] binding "${binding.bindingType}: ${binding.statePathName}" failed to apply; ` +
+        `the rest of this batch continues.`, { node: binding.node, error });
+    if (devtoolsSink !== null) {
+        devtoolsSink({
+            type: "state:binding-apply-error",
+            stateName: binding.stateName,
+            path: binding.statePathName,
+            bindingType: binding.bindingType,
+            error,
+        });
+    }
+}
 /**
  * バインディング情報の配列を処理し、各バインディングに対して状態の変更を適用する。
  *
@@ -7642,7 +8227,16 @@ function applyChangeFromBindings(bindings, propagationContextByBinding) {
                 propagationContextByBinding: propagationContextByBinding,
             };
             do {
-                applyChange(binding, context);
+                // 1 本の失敗を 1 本に閉じ込める（§ エラー隔離）。隔離しないと、stale な
+                // アドレスを読んだ 1 本の throw がバッチの残り・$updatedCallback・drain
+                // リスナー（$watch / $streams restart）まで道連れにし、「値は新しいのに
+                // DOM は途中まで」という再現困難な半端状態を作る。
+                try {
+                    applyChange(binding, context);
+                }
+                catch (error) {
+                    reportBindingApplyError(binding, error);
+                }
                 bindingIndex++;
                 const nextBindingInfo = bindings[bindingIndex];
                 if (!nextBindingInfo)
@@ -7658,7 +8252,12 @@ function applyChangeFromBindings(bindings, propagationContextByBinding) {
     // applyChangeToProperty は propagationContextByBinding 以外の context を
     // 参照しないため、遅延分は最小 context を渡す
     for (const { binding, value } of deferredSelectBindings) {
-        applyChangeToProperty(binding, { propagationContextByBinding }, value);
+        try {
+            applyChangeToProperty(binding, { propagationContextByBinding }, value);
+        }
+        catch (error) {
+            reportBindingApplyError(binding, error);
+        }
     }
     for (const [absAddress, newListValue] of newListValueByAbsAddress.entries()) {
         setLastListValueByAbsoluteStateAddress(absAddress, newListValue);
@@ -8109,7 +8708,13 @@ function collectStructuralFragments(rootNode, walkRoot, forPath) {
 async function waitForStateInitialize(root) {
     const elements = root.querySelectorAll(config.tagNames.state);
     const promises = [];
-    await customElements.whenDefined(config.tagNames.state);
+    const registry = getCustomElementRegistry(root);
+    if (registry === null) {
+        // null レジストリのサブツリーでは <wcs-state> が upgrade されないので
+        // initializePromise が生えず、待っても永久に初期化されない。
+        raiseError(`CustomElementRegistry is unavailable for <${config.tagNames.state}>.`);
+    }
+    await registry.whenDefined(config.tagNames.state);
     for (const element of elements) {
         // Light DOM の mapped コンポーネントの state は待たない。それはこの root の
         // バインディングが張られてからでないと初期化できず（自分を束ねるホスト binding を
@@ -8148,7 +8753,7 @@ async function buildBindings(root) {
     }
 }
 
-var version = "1.30.0";
+var version = "1.32.0";
 var pkg = {
 	version: version};
 
@@ -8871,28 +9476,262 @@ async function hydrateBindings(root) {
     return true;
 }
 
-const stateElementByNameByNode = new WeakMap();
-const bindingsReadyByNode = new WeakMap();
-// devtools 用の列挙可能な登録簿（protocol §4.1 — 唯一の常時 ON 台帳）。
-// サイズは <wcs-state> 要素数に拘束され、unregister（disconnectedCallback）で
-// 必ず削除されるためリークしない。
-const liveStateElements = new Set();
-function getLiveStateElements() {
-    return liveStateElements;
-}
-function getStateElementByName(rootNode, name) {
-    let stateElementByName = stateElementByNameByNode.get(rootNode);
-    if (!stateElementByName) {
-        return null;
-    }
-    return stateElementByName.get(name) || null;
-}
+// ===========================================================================
+// AUTO-GENERATED FILE - DO NOT EDIT.
+// Generated from /protocol/binder.ts by scripts/sync-protocol-types.mjs.
+// Run `node scripts/sync-protocol-types.mjs` after editing the source.
+// ===========================================================================
+// binder protocol — how a package that inserts DOM hands those nodes to whoever
+// owns data bindings on the page.
+//
+// The dual of transition-runner: that one hands a *mutation* to whoever animates
+// it, this one hands *new nodes* to whoever binds them.
+//
+// A `data-wcs` binding exists only for nodes @wcstack/state walked when it built
+// its bindings. Nodes that arrive later — the content of a route that was not
+// active at that moment, a <wcs-head> child reflected into <head> — were never
+// walked, so their bindings silently do nothing, however often they are inserted.
+// @wcstack/router must not depend on @wcstack/state (zero runtime dependencies,
+// independently publishable), so state installs a binder on a well-known global
+// symbol and inserters look it up lazily.
+//
+// No binder installed means nothing happens — byte-for-byte the behavior these
+// packages had before the protocol existed.
+//
+// docs/binder-protocol-design.md is the normative description.
+//
+// SINGLE SOURCE OF TRUTH: edit only this file (/protocol/binder.ts), then run
+// `node scripts/sync-protocol-types.mjs` to regenerate the per-package copies
+// (packages/<pkg>/src/protocol/binder.ts). Those copies are generated — do not edit them.
+/**
+ * Global key the binder installs itself under. `Symbol.for` so independently
+ * loaded copies of this file (two CDN bundles on one page) still agree.
+ */
+const BINDER_KEY = Symbol.for("wcstack.binder");
+/**
+ * The installed binder, or null when there is none or it speaks a version this
+ * reader does not.
+ *
+ * Looked up on every call rather than cached, for the same reason
+ * transition-runner does: the page's composition can change at any point, and a
+ * stale cache would keep calling into a binder that is no longer there.
+ */
+function getBinder() {
+    const candidate = globalThis[BINDER_KEY];
+    if (candidate === undefined || candidate === null)
+        return null;
+    if (candidate.protocol !== "wcs-binder")
+        return null;
+    if (typeof candidate.version !== "number" || candidate.version < 1)
+        return null;
+    if (typeof candidate.bind !== "function")
+        return null;
+    return candidate;
+}
+/**
+ * Subtrees offered before a binder existed, and the set of everything a binder
+ * has taken. Both live on global symbols so that independently loaded copies of
+ * this file — the router's and state's — share one queue.
+ *
+ * The queue is needed because of load order: the router's auto bundle runs
+ * before state's, so `<wcs-head>` reflects its children into `<head>` while
+ * there is still nothing to bind them. Offering them to a binder that arrives
+ * later is the difference between working and silently blank.
+ */
+const PENDING_KEY = Symbol.for("wcstack.binder.pending");
+const TAKEN_KEY = Symbol.for("wcstack.binder.taken");
+function pendingQueue() {
+    const globals = globalThis;
+    let queue = globals[PENDING_KEY];
+    if (queue === undefined) {
+        queue = [];
+        globals[PENDING_KEY] = queue;
+    }
+    return queue;
+}
+function takenSet() {
+    const globals = globalThis;
+    let taken = globals[TAKEN_KEY];
+    if (taken === undefined) {
+        taken = new WeakSet();
+        globals[TAKEN_KEY] = taken;
+    }
+    return taken;
+}
+/**
+ * Bind everything offered before this binder existed. Called by the binder right
+ * after it installs itself.
+ */
+function flushPendingBinds() {
+    const binder = getBinder();
+    if (binder === null)
+        return;
+    const queue = pendingQueue();
+    if (queue.length === 0)
+        return;
+    const pending = queue.splice(0, queue.length);
+    const taken = takenSet();
+    for (const subtree of pending) {
+        taken.add(subtree);
+        binder.bind(subtree);
+    }
+}
+
+/**
+ * binder プロトコルの提供側（docs/binder-protocol-design.md）。
+ *
+ * `buildBindings` は起動時に `document.body` を 1 回走査するだけなので、そのとき
+ * document に居なかったノードのバインドは存在しない。router が後から差し込む
+ * ルート内容や `<wcs-head>` のクローンがこれに当たり、書いたバインドが黙って
+ * 何もしない状態になっていた。`bind()` はその取りこぼしを 1 サブツリー分だけ
+ * 埋める。
+ *
+ * **走査を勝手に広げない。** MutationObserver が見た全追加ノードを走査する形に
+ * すると、バインドを 1 個も持たない挿入（大多数）にコストが乗り、さらに
+ * `innerHTML` で入れた外部由来の DOM が `data-wcs` を発火させることになる。
+ * ここで束ねるのは**明示的に渡されたものだけ**である。
+ */
+const BIND_ATTRIBUTE_SELECTOR = () => `[${config.bindAttributeName}]`;
+/**
+ * このサブツリーは既にバインド済みか。
+ *
+ * ルート内容は「起動時に active だったので全部バインド済み」か「一度も走査されて
+ * いないので全部未バインド」のどちらかで、途中の状態を取らない。したがって
+ * **宣言を持つ最初のノード 1 個**を見れば足りる。全ノードを走査して判定するのは
+ * 同じ結論により高いコストを払うだけになる。
+ */
+function alreadyBound(subtree) {
+    if (hasInterestedSession(subtree)) {
+        return true;
+    }
+    if (!isElement(subtree)) {
+        return false;
+    }
+    if (subtree.hasAttribute(config.bindAttributeName)) {
+        // 属性を持つのに台帳に居ない ＝ 未バインド
+        return false;
+    }
+    const first = subtree.querySelector(BIND_ATTRIBUTE_SELECTOR());
+    return first !== null && hasInterestedSession(first);
+}
+function isElement(node) {
+    return node.nodeType === 1;
+}
+function bindNow(subtree) {
+    if (alreadyBound(subtree)) {
+        return;
+    }
+    convertMustacheToComments(subtree);
+    collectStructuralFragments(subtree.getRootNode(), subtree);
+    // `getSubscriberNodes` の TreeWalker は**ルート自身を返さない**。`buildBindings` は
+    // `document.body` を渡すので今まで問題にならなかったが、ここには宣言をルートに
+    // 持つノードが来る（`<wcs-head>` が head へ入れる `<title data-wcs="…">`）。
+    // そのときだけ親から走査して、ルートを走査範囲に含める。兄弟の重複登録は
+    // `registeredNodeSet` が弾くので、余計なバインドは生まれない。
+    // 親は Element とは限らない（ShadowRoot 直下なら DocumentFragment、head 直下なら
+    // Element）。`parentElement` だと前者で null になり、ルートを含められない。
+    const declaresOnRoot = subtree.hasAttribute(config.bindAttributeName);
+    const parent = subtree.parentNode;
+    const canWalkFromParent = parent !== null
+        && (parent.nodeType === 1 || parent.nodeType === 9 || parent.nodeType === 11);
+    const walkRoot = declaresOnRoot && canWalkFromParent
+        ? parent
+        : subtree;
+    initializeBindings(walkRoot, null);
+}
+/**
+ * 初期バインド構築より前に差し出されたサブツリー。
+ *
+ * `<wcs-head>` は `connectedCallback` の中でクローンを head へ入れるので、
+ * state / router のどちらを先に読み込んでも「まだ構築が終わっていない」時点で
+ * bind を求めてくる。そこで同期に束ねても `<wcs-state>` の登録が済んでおらず、
+ * バインドは state を見つけられない。**構築の完了を唯一の合図にする。**
+ */
+const beforeFirstBuild = [];
+function bind(subtree) {
+    if (!isElement(subtree) || alreadyBound(subtree)) {
+        return;
+    }
+    if (!areBindingsBuilt(subtree.getRootNode())) {
+        beforeFirstBuild.push(subtree);
+        return;
+    }
+    bindNow(subtree);
+}
+/**
+ * 初期バインド構築の完了時に呼ぶ（stateElementByName.ts）。binder が居ない時点で
+ * 差し出された分（プロトコルの保留キュー）と、居たが早すぎた分をまとめて束ねる。
+ */
+function drainPendingBinds() {
+    const pending = beforeFirstBuild.splice(0, beforeFirstBuild.length);
+    for (const subtree of pending) {
+        bindNow(subtree);
+    }
+    flushPendingBinds();
+}
+const binder = {
+    protocol: "wcs-binder",
+    version: 1,
+    bind,
+};
+/**
+ * グローバル symbol へ自分を載せる。`bootstrapState` から呼ぶ。
+ *
+ * 既に別のコピーが載っているなら譲る。1 ページに 2 つの state バンドルが載る構成
+ * （CDN の取り違え）で、後から読まれた側が先客を追い出すと、先客がバインドした
+ * ノードの台帳と食い違う。
+ */
+function registerBinder() {
+    const globals = globalThis;
+    if (globals[BINDER_KEY] === undefined) {
+        globals[BINDER_KEY] = binder;
+    }
+    // ここでは引き取らない。`<wcs-state>` の登録は connectedCallback の await より
+    // 後なので、この時点ではまだ state が居ない。保留分は初期バインド構築の完了時に
+    // 流す（stateElementByName.ts）。そこが「state が確実に居る」最初の瞬間である。
+}
+
+const stateElementByNameByNode = new WeakMap();
+const bindingsReadyByNode = new WeakMap();
+// devtools 用の列挙可能な登録簿（protocol §4.1 — 唯一の常時 ON 台帳）。
+// サイズは <wcs-state> 要素数に拘束され、unregister（disconnectedCallback）で
+// 必ず削除されるためリークしない。
+const liveStateElements = new Set();
+function getLiveStateElements() {
+    return liveStateElements;
+}
+function getStateElementByName(rootNode, name) {
+    let stateElementByName = stateElementByNameByNode.get(rootNode);
+    if (!stateElementByName) {
+        return null;
+    }
+    return stateElementByName.get(name) || null;
+}
 /**
  * 指定された rootNode のバインディング初期化が完了するまで待機する Promise を返す。
  */
 function getBindingsReady(rootNode) {
     return bindingsReadyByNode.get(rootNode) ?? Promise.resolve();
 }
+const bindingsBuiltRoots = new WeakSet();
+/**
+ * この rootNode の初期バインド構築が完了しているか。
+ *
+ * binder プロトコル（`bind()`）が使う。router の `<wcs-head>` はクローンを
+ * `connectedCallback` の中で head へ入れるので、**state が最初の走査を終える前**に
+ * bind を求めてくる。そこで同期に束ねても state 要素の初期化が済んでおらず、
+ * 結果は空のままになる。完了までは binder 側で保留する。
+ *
+ * 「まだ登録も済んでいない」と「もう構築が終わった」を取り違えないよう、判定は
+ * 完了の側で持つ。<wcs-state> の登録は connectedCallback の await より後に起きるので、
+ * 「エントリの有無」で進行中かを測ると読み込み順によって逆の答えを返す。
+ */
+function areBindingsBuilt(rootNode) {
+    return bindingsBuiltRoots.has(rootNode);
+}
+function markBindingsBuilt(rootNode) {
+    bindingsBuiltRoots.add(rootNode);
+}
 function setStateElementByName(rootNode, name, element) {
     let stateElementByName = stateElementByNameByNode.get(rootNode);
     if (element === null) {
@@ -8945,6 +9784,11 @@ function setStateElementByName(rootNode, name, element) {
                             else {
                                 await buildBindings(rootNode);
                             }
+                            markBindingsBuilt(rootNode);
+                            // binder が居ない時点で差し出されたサブツリーを引き取る。ここが
+                            // 「state が確実に居る」最初の瞬間で、router の auto バンドルが
+                            // state のそれより先に走る順序を吸収できる唯一の場所である。
+                            drainPendingBinds();
                             resolve();
                         }
                         catch (error) {
@@ -8959,6 +9803,11 @@ function setStateElementByName(rootNode, name, element) {
                     queueMicrotask(async () => {
                         try {
                             await buildBindings(rootNode);
+                            markBindingsBuilt(rootNode);
+                            // binder が居ない時点で差し出されたサブツリーを引き取る。ここが
+                            // 「state が確実に居る」最初の瞬間で、router の auto バンドルが
+                            // state のそれより先に走る順序を吸収できる唯一の場所である。
+                            drainPendingBinds();
                             resolve();
                         }
                         catch (error) {
@@ -9068,6 +9917,17 @@ function notifyUpdateBatchListeners(batch) {
         registered.listener(batch);
     }
 }
+/**
+ * 遷移越しの適用が失敗したときの報告。
+ *
+ * 遷移の中では例外を同期的に呼び出し元へ投げ返せない。今日の drain は
+ * queueMicrotask の中で throw する ＝ uncaught として観測されるので、それと同じ
+ * 「loud に出す」挙動へ揃える。握り潰すと `$updatedCallback` の throw が黙って
+ * 消える（README の 3 層表が定める伝播の契約が破れる）。
+ */
+function reportDeferredApplyFailure(error) {
+    queueMicrotask(() => { throw error; });
+}
 class Updater {
     _queueUpdateRecords = [];
     constructor() {
@@ -9166,17 +10026,49 @@ class Updater {
                 }
             }
         }
-        // context が無い場合は従来どおり 1 引数で呼ぶ（呼び出し契約の互換維持）
-        if (propagationContextByBinding.size > 0) {
-            applyChangeFromBindings(processBindings, propagationContextByBinding);
-        }
-        else {
-            applyChangeFromBindings(processBindings);
-        }
         // drain 終了フック: binding 適用後に dedup 済みバッチを通知する（設計書 §3-2）。
         // testApplyChange も同じ _applyChange を通るため、テストから同期に駆動できる。
         // quarantine された address も state 値は適用済みのため通知対象に含める。
-        notifyUpdateBatchListeners(new Set(contextByAbsoluteAddress.keys()));
+        //
+        // try/finally なのは、適用側が throw しても `$watch` / `$streams` restart を
+        // 落とさないため。binding 1 本の失敗は applyChangeFromBindings が隔離するので
+        // ここへ来るのは $updatedCallback の throw（契約どおり loud に伝播させる）等に
+        // 限られるが、そのとき drain フックまで道連れにすると「機構間の順序は固定」
+        // （README の 3 層表）が黙って破れる。例外は握らない ＝ 伝播は維持する。
+        try {
+            const applyBindings = () => {
+                // context が無い場合は従来どおり 1 引数で呼ぶ（呼び出し契約の互換維持）
+                if (propagationContextByBinding.size > 0) {
+                    applyChangeFromBindings(processBindings, propagationContextByBinding);
+                }
+                else {
+                    applyChangeFromBindings(processBindings);
+                }
+            };
+            // View transition 参加点（docs/view-transition-design.md §7.2）。arbiter が
+            // 居なければ runTransition はその場で applyBindings を呼び、undefined を返す
+            // ＝ 従来と完全に同じ同期適用。SSR では遷移そのものを持たない（G5）。
+            //
+            // 適用する binding が 0 本のバッチは arbiter へ渡さない。書き込みはバインドの
+            // 有無に関わらず enqueue される（setByAddress）ため、headless なパス
+            // （`$watch` 専用・`$streams` の内部状態・リスト置換の中間アドレス）への
+            // 書き込みだけでもここへ到達する。それでページ全体をスナップショットするのは
+            // 無駄なだけでなく、既定の mode="latest" では「アニメーションすべき DOM 変更が
+            // 無い遷移」が実行中の本物の遷移をスキップしてしまう（ルート遷移が毎回途中で
+            // 切れる／active が空撃ちで振動する）。
+            if (inSsr() || processBindings.length === 0) {
+                applyBindings();
+            }
+            else {
+                const pending = runTransition("state", applyBindings);
+                if (pending !== undefined) {
+                    pending.catch(reportDeferredApplyFailure);
+                }
+            }
+        }
+        finally {
+            notifyUpdateBatchListeners(new Set(contextByAbsoluteAddress.keys()));
+        }
     }
 }
 const updater = new Updater();
@@ -9566,6 +10458,58 @@ function registerDevtoolsSource() {
     getOrCreateHookRegistry().register(source);
 }
 
+/**
+ * ssr-snapshot プロトコルの提供側（docs/ssr-router-design.md §5）。
+ *
+ * `<wcs-ssr>` スナップショットを document 全体に対する最終パスとして生成する。
+ * connectedCallback 内の inline 生成は「その時点の DOM」しか見えず、router が
+ * 後から挿入するルート内容の構造テンプレートを取り逃がすレースがあった
+ * （state のロード方式と文書順に依存）。renderToString が全要素の完了と
+ * バインディング構築の後にこれを呼ぶことで、スナップショットは常に確定後の
+ * DOM を見る。
+ *
+ * 複数 `enable-ssr` state の意味論は inline 生成と同一に保つ（文書順に生成・
+ * fragment レジストリはモジュール共有・props store は生成ごとにクリア）。
+ * その整理は本プロトコルの範囲外の既存挙動として引き継ぐ。
+ */
+function buildSsrDocument(root) {
+    const stateTag = config.tagNames.state;
+    const ssrTag = config.tagNames.ssr;
+    const stateElements = root.querySelectorAll(`${stateTag}[enable-ssr]`);
+    for (const stateEl of stateElements) {
+        const name = stateEl.getAttribute("name") || "default";
+        // 既に直前へ生成済み（旧 server との組み合わせで inline 生成された等）なら
+        // 何もしない — build() は冪等でなければならない（プロトコル契約）
+        const prev = stateEl.previousElementSibling;
+        if (prev !== null &&
+            prev.tagName.toLowerCase() === ssrTag &&
+            (prev.getAttribute("name") || "default") === name) {
+            continue;
+        }
+        const ssrEl = document.createElement(ssrTag);
+        ssrEl.setAttribute("name", name);
+        ssrEl.setAttribute("version", VERSION);
+        Ssr.buildContent(ssrEl, Ssr.extractStateData(stateEl));
+        stateEl.parentNode?.insertBefore(ssrEl, stateEl);
+    }
+}
+const builder = {
+    protocol: "wcs-ssr-snapshot",
+    version: 1,
+    build: buildSsrDocument,
+};
+/**
+ * グローバル symbol へ自分を載せる。`bootstrapState` から呼ぶ。
+ * binder（registerBinder）と同じ規範 — 既に別のコピーが載っているなら譲る
+ * （そのコピーのレジストリが、そのページの正本だからである）。
+ */
+function registerSsrSnapshotBuilder() {
+    const globals = globalThis;
+    if (globals[SSR_SNAPSHOT_BUILDER_KEY] === undefined) {
+        globals[SSR_SNAPSHOT_BUILDER_KEY] = builder;
+    }
+}
+
 const CSP_GUIDE = "https://github.com/wcstack/wcstack/blob/main/docs/csp.md";
 /**
  * インライン `<script>` の評価失敗を、原因の分かるメッセージに変換する。
@@ -9646,9 +10590,26 @@ async function loadFromJsonFile(url) {
     }
 }
 
+/**
+ * `src` の値を **document の base URL** に対して解決する。
+ *
+ * `import(url)` の相対解決は「import を書いたモジュール」を基準にする。ここは
+ * `@wcstack/state` の中なので、素の `import(url)` は `<wcs-state src>` を
+ * **state パッケージの所在**から解決してしまう。同一オリジンに置いたページでは
+ * たまたま一致して見えるが、CDN 一発（`https://esm.run/@wcstack/state/auto`）で
+ * 読み込んだ瞬間に `src="/app.js"` が CDN 側の URL を指して 404 になる。
+ *
+ * `src` は HTML 属性なので、正しい基準は document の base URL である
+ * （`src="*.json"` 側は `fetch` がそう解決しており、同じ属性が形式によって
+ * 違う基準で解決されていた）。絶対 URL・`data:`・`blob:` は URL 解決で
+ * そのまま素通りするため、既存の使い方は影響を受けない。
+ */
+function resolveAgainstDocument(url) {
+    return new URL(url, document.baseURI).href;
+}
 async function loadFromScriptFile(url) {
     try {
-        const module = await import(/* @vite-ignore */ url);
+        const module = await import(/* @vite-ignore */ resolveAgainstDocument(url));
         return module.default || {};
     }
     catch (e) {
@@ -10988,7 +11949,9 @@ function processWatchDeclaration(stateElement, state) {
         paths.add(path);
         // 依存グラフ登録（§8）。"for" 以外の bindingType は親 → 子の staticDependency
         // チェーンを生やすだけで listPaths / elementPaths を触らない（State.setPathInfo 参照）。
-        stateElement.setPathInfo(path, "prop");
+        // source="watch" は存在検査の診断 code を `wcs/watch-path-missing` に切り替える
+        // （watch キーの miss は raiseError にも掛からず、黙って発火しないだけになる）。
+        stateElement.setPathInfo(path, "prop", "watch");
     }
     setWatchEntries(stateElement, entries);
     return paths.size > 0 ? paths : null;
@@ -11579,11 +12542,18 @@ function defineDCC(hostElement, shadowRoot, state) {
     if (!tagName.includes("-")) {
         raiseError(`DCC: "${tagName}" is not a valid custom element name (must contain a hyphen).`);
     }
-    if (customElements.get(tagName)) {
+    // 定義先は「定義元ホストを支配するレジストリ」。scoped registry を持つツリーで
+    // global に define すると、その定義は自分の兄弟にすら適用されない。
+    const definitionRegistry = getCustomElementRegistry(hostElement);
+    if (definitionRegistry === null || typeof definitionRegistry.define !== "function") {
+        raiseError(`DCC: CustomElementRegistry is unavailable for "${tagName}".`);
+    }
+    if (definitionRegistry.get(tagName)) {
         // 重複定義は authoring error として落とす。従来は warn してスキップしていたが、
         // 先勝ちで別テンプレートのインスタンスが生えるため「動いているように見えて中身が違う」
         // 状態になる。state 名の重複（stateElementByName）が raiseError なのと作法を揃える
         // （docs/architecture-hardening/15-state-component-mechanism-consistency.md §3.4）。
+        // 一意性はレジストリ単位なので、別スコープの同名 DCC は衝突しない。
         raiseError(`DCC: "${tagName}" is already registered. A custom element name can only be defined once.`);
     }
     // ShadowRoot は cloneNode 不可のため、template 経由で内容をクローン
@@ -11638,7 +12608,7 @@ function defineDCC(hostElement, shadowRoot, state) {
             // カスタム要素として upgrade されていない。ホストが接続済みなら appendChild の時点で
             // upgrade されるが、未接続の shadow に挿した場合は upgrade 契機が無く、内側の
             // <wcs-state> が素の HTMLElement のまま残って createState が生えない。明示的に upgrade する。
-            const registry = getCustomElementRegistry();
+            const registry = getCustomElementRegistry(this._shadow);
             if (registry !== null) {
                 upgradeCustomElement(registry, this._shadow);
             }
@@ -11705,7 +12675,7 @@ function defineDCC(hostElement, shadowRoot, state) {
         });
     }
     // カスタム要素登録
-    customElements.define(tagName, DCCElement);
+    definitionRegistry.define(tagName, DCCElement);
 }
 
 /**
@@ -11852,6 +12822,41 @@ function disconnectedCallback(target, _prop, receiver, _handler) {
     }
 }
 
+/**
+ * getContextListIndex.ts
+ *
+ * Stateの内部APIとして、現在のプロパティ参照スコープにおける
+ * 指定したstructuredPath（ワイルドカード付きプロパティパス）に対応する
+ * リストインデックス（IListIndex）を取得する関数です。
+ *
+ * 主な役割:
+ * - handlerの最後にアクセスされたAddressから、指定パスに対応するリストインデックスを取得
+ * - ワイルドカード階層に対応し、多重ループやネストした配列バインディングにも利用可能
+ *
+ * 設計ポイント:
+ * - 直近のプロパティ参照情報を取得
+ * - info.indexByWildcardPathからstructuredPathのインデックスを特定
+ * - listIndex.at(index)で該当階層のリストインデックスを取得
+ * - パスが一致しない場合や参照が存在しない場合はnullを返す
+ */
+function getContextListIndex(handler, structuredPath) {
+    if (handler.addressStackLength === 0) {
+        return null;
+    }
+    const address = handler.lastAddressStack;
+    if (address === null) {
+        return null;
+    }
+    const index = address.pathInfo.indexByWildcardPath[structuredPath];
+    if (typeof index === "undefined") {
+        return null;
+    }
+    if (address.listIndex === null) {
+        return null;
+    }
+    return listIndexAtWildcard(address.listIndex, index, address.pathInfo.wildcardCount);
+}
+
 const cacheEntryByAbsoluteStateAddress = new WeakMap();
 function getCacheEntryByAbsoluteStateAddress(address) {
     return cacheEntryByAbsoluteStateAddress.get(address) ?? null;
@@ -12077,7 +13082,10 @@ function _getByAddress(target, address, receiver, handler, stateElement) {
         }
     }
     else {
-        const parentAddress = address.parentAddress ?? raiseError(`address.parentAddress is undefined path: ${address.pathInfo.path}`);
+        // 親アドレスが無い ＝ 単一セグメントのパスが state に存在しない。ここは元から
+        // throw していたが、文面が内部実装の言葉だったので打ち間違いだと分からなかった。
+        // 深いパスの console.warn（pathDiagnostics.checkDeclaredPath）と語彙を揃える。
+        const parentAddress = address.parentAddress ?? raiseError(missingRootPathMessage(stateElement.name, address.pathInfo.path, target, stateElement.getterPaths));
         const parentValue = getByAddress(target, parentAddress, receiver, handler);
         // 親が居ないパスの読みは undefined（＝「state に意見が無い」）。`Reflect.get` に
         // そのまま渡すと生の `TypeError: Reflect.get called on non-object` になり、
@@ -12095,7 +13103,11 @@ function _getByAddress(target, address, receiver, handler, stateElement) {
         }
         const lastSegment = address.pathInfo.segments[address.pathInfo.segments.length - 1];
         if (lastSegment === WILDCARD) {
-            const index = address.listIndex?.index ?? raiseError(`address.listIndex?.index is undefined path: ${address.pathInfo.path}`);
+            // listIndex が無いまま末尾ワイルドカードに到達 ＝ そのパスの階数を満たす
+            // ループ文脈が無い（`matrix.*.*` を 1 段の `for` の中で読む等）。元の文面は
+            // 内部の言葉（address.listIndex?.index is undefined）で、何段必要なのかが
+            // 書かれていなかった（pathDiagnostics.ts）。
+            const index = address.listIndex?.index ?? raiseError(wildcardScopeMessage(`path "${address.pathInfo.path}"`, address.pathInfo.wildcardCount, address.listIndex?.length ?? 0));
             return Reflect.get(parentValue, index);
         }
         else {
@@ -12132,38 +13144,112 @@ function getByAddress(target, address, receiver, handler) {
 }
 
 /**
- * getContextListIndex.ts
+ * wildcardIndexes.ts
  *
- * Stateの内部APIとして、現在のプロパティ参照スコープにおける
- * 指定したstructuredPath（ワイルドカード付きプロパティパス）に対応する
- * リストインデックス（IListIndex）を取得する関数です。
+ * ワイルドカードを含むパスから「解決済み添字タプルの集合」を列挙する共有走査。
+ * `$getAll`（読み）と `$setAll`（書き）が**同じ展開規則・同じ順序**で動くための単一の正本
+ * （docs/state-set-all-design.md §6-1）。
  *
- * 主な役割:
- * - handlerの最後にアクセスされたAddressから、指定パスに対応するリストインデックスを取得
- * - ワイルドカード階層に対応し、多重ループやネストした配列バインディングにも利用可能
+ * 添字は**前方一致の接頭辞**で、足りない分は「その階層を全部展開する」という意味を持つ
+ * （README の `$getAll("scores.*", [])` がこれ）。返るタプルは常にワイルドカードの本数と
+ * 同じ長さになるので、そのまま `$resolve` の厳密一致な添字として使える。
  *
- * 設計ポイント:
- * - 直近のプロパティ参照情報を取得
- * - info.indexByWildcardPathからstructuredPathのインデックスを特定
- * - listIndex.at(index)で該当階層のリストインデックスを取得
- * - パスが一致しない場合や参照が存在しない場合はnullを返す
+ * 順序は**深さ優先・添字昇順**（ネストは添字タプルの辞書順）で決定的。
+ * `$getAll(p, i)` の戻り順と `$setAll(p, i, …)` の適用順が一致する根拠がこれであり、
+ * `$setAll` の `{ spread: true }` 形はこの順序に乗っている。
+ *
+ * Throws: LIST-201（インデックス未解決）、BIND-201（ワイルドカード情報不整合）
  */
-function getContextListIndex(handler, structuredPath) {
-    if (handler.addressStackLength === 0) {
-        return null;
-    }
-    const address = handler.lastAddressStack;
-    if (address === null) {
-        return null;
-    }
-    const index = address.pathInfo.indexByWildcardPath[structuredPath];
-    if (typeof index === "undefined") {
-        return null;
-    }
-    if (address.listIndex === null) {
-        return null;
+/**
+ * 各ワイルドカード階層で最後に観測したリスト値。**次の読みの差分基準**であり、
+ * ListIndex の同一性を跨いで保つために使う。
+ *
+ * 所有権は読み（`$getAll`）側にある。書き（`$setAll`）はこの走査を借りるだけで
+ * 記録を更新しない（`commitDiffBaseline: false`。設計 §6-2）。
+ */
+// ToDo: IAbsoluteStateAddressに変更する
+const lastValueByListAddress = new WeakMap();
+/**
+ * `pathInfo` のワイルドカードを `indexes`（前方一致の接頭辞）で絞り込みつつ展開し、
+ * マッチする添字タプルを列挙する。
+ *
+ * 添字の本数検査（上限）は呼び出し側の責務 — API 名を診断メッセージに出すため。
+ */
+function collectWildcardIndexes(target, receiver, handler, pathInfo, indexes, options) {
+    const newValueByAddress = new Map();
+    const walkWildcardPattern = (wildcardParentPathInfos, wildcardIndexPos, listIndex, indexes, indexPos, parentIndexes, results) => {
+        const wildcardParentPathInfo = wildcardParentPathInfos[wildcardIndexPos] ?? null;
+        if (wildcardParentPathInfo === null) {
+            results.push(parentIndexes);
+            return;
+        }
+        const wildcardAddress = createStateAddress(wildcardParentPathInfo, listIndex);
+        const oldValue = lastValueByListAddress.get(wildcardAddress);
+        const newValue = getByAddress(target, wildcardAddress, receiver, handler);
+        const listDiff = createListDiff(getListParentListIndex(handler.stateElement, listIndex), oldValue, newValue);
+        const listIndexes = listDiff.newIndexes;
+        const index = indexes[indexPos] ?? null;
+        newValueByAddress.set(wildcardAddress, newValue);
+        if (index === null) {
+            for (let i = 0; i < listIndexes.length; i++) {
+                const listIndex = listIndexes[i];
+                walkWildcardPattern(wildcardParentPathInfos, wildcardIndexPos + 1, listIndex, indexes, indexPos + 1, parentIndexes.concat(listIndex.index), results);
+            }
+        }
+        else {
+            // 範囲外 index はリスト自体の不在と別原因なので index を含める
+            // （docs/state-bind-component-nested-for-design.md §8.4）
+            const listIndex = listIndexes[index] ??
+                raiseError(`ListIndex not found at index ${index} of ${wildcardParentPathInfo.path}`);
+            if ((wildcardIndexPos + 1) < wildcardParentPathInfos.length) {
+                walkWildcardPattern(wildcardParentPathInfos, wildcardIndexPos + 1, listIndex, indexes, indexPos + 1, parentIndexes.concat(listIndex.index), results);
+            }
+            else {
+                // 最終ワイルドカード層まで到達しているので、結果を確定
+                results.push(parentIndexes.concat(listIndex.index));
+            }
+        }
+    };
+    const resultIndexes = [];
+    walkWildcardPattern(pathInfo.wildcardParentPathInfos, 0, null, indexes, 0, [], resultIndexes);
+    if (options.commitDiffBaseline) {
+        for (const [address, newValue] of newValueByAddress.entries()) {
+            lastValueByListAddress.set(address, newValue);
+        }
     }
-    return listIndexAtWildcard(address.listIndex, index, address.pathInfo.wildcardCount);
+    return resultIndexes;
+}
+
+/**
+ * getListIndexByIndexes.ts
+ *
+ * 解決済みの添字タプル（ワイルドカード 1 段につき 1 個）から、対応する ListIndex を
+ * **正本レジストリ**（listIndexesByList）経由で引き当てる。
+ *
+ * `$resolve` と `$setAll` の共有部分。列挙側（wildcardIndexes.ts）が走査中に生成した
+ * ListIndex をそのまま書き込み先にせず、ここで引き直すことで、binding が使っている
+ * ListIndex と同一の同一性に載る（docs/state-set-all-design.md §6-2）。
+ *
+ * 添字の本数がワイルドカードの本数と一致していることは呼び出し側の責務。
+ */
+function getListIndexByIndexes(target, receiver, handler, pathInfo, indexes) {
+    // ワイルドカード階層ごとにListIndexを解決していく
+    let listIndex = null;
+    for (let i = 0; i < pathInfo.wildcardParentPathInfos.length; i++) {
+        const wildcardParentPathInfo = pathInfo.wildcardParentPathInfos[i];
+        const wildcardAddress = createStateAddress(wildcardParentPathInfo, listIndex);
+        const tmpValue = getByAddress(target, wildcardAddress, receiver, handler);
+        const listIndexes = getListIndexesByList(tmpValue);
+        if (listIndexes == null) {
+            raiseError(`ListIndexes not found: ${wildcardParentPathInfo.path}`);
+        }
+        const index = indexes[i];
+        // 範囲外 index はリスト自体の不在と別原因なので index を含める
+        // （docs/state-bind-component-nested-for-design.md §8.4）
+        listIndex = listIndexes[index] ??
+            raiseError(`ListIndex not found at index ${index} of ${wildcardParentPathInfo.path}`);
+    }
+    return listIndex;
 }
 
 /**
@@ -12891,7 +13977,8 @@ function _setByAddress(target, address, absAddress, value, receiver, handler, ke
             const parentValue = getByAddress(target, parentAddress, receiver, handler);
             const lastSegment = address.pathInfo.segments[address.pathInfo.segments.length - 1];
             if (lastSegment === WILDCARD) {
-                const index = address.listIndex?.index ?? raiseError(`address.listIndex?.index is undefined path: ${address.pathInfo.path}`);
+                // 読み取り側（getByAddress）と同じ取り違え。書き込みでも何段必要かを言う。
+                const index = address.listIndex?.index ?? raiseError(wildcardScopeMessage(`path "${address.pathInfo.path}"`, address.pathInfo.wildcardCount, address.listIndex?.length ?? 0));
                 return Reflect.set(parentValue, index, value);
             }
             else {
@@ -13060,7 +14147,9 @@ function setByAddressCore(target, address, value, receiver, handler, keyedMergeP
             recordWatchPrevValue(stateElement, path, absAddress, devOldValue, devHasOldValue);
             try {
                 if (key === undefined) {
-                    raiseError(`address.listIndex?.index is undefined path: ${path}`);
+                    // fast path 版の同じ取り違え（末尾ワイルドカードに listIndex が無い）。
+                    // 通常経路と同じ語彙で「何段必要か」を言う（pathDiagnostics.ts）。
+                    raiseError(wildcardScopeMessage(`path "${path}"`, address.pathInfo.wildcardCount, address.listIndex?.length ?? 0));
                 }
                 return Reflect.set(parentValue, key, value);
             }
@@ -13159,25 +14248,15 @@ function resolve(target, _prop, receiver, handler) {
                 }
             }
         }
-        if (pathInfo.wildcardParentPathInfos.length > indexes.length) {
-            raiseError(`indexes length is insufficient: ${path}`);
-        }
-        // ワイルドカード階層ごとにListIndexを解決していく
-        let listIndex = null;
-        for (let i = 0; i < pathInfo.wildcardParentPathInfos.length; i++) {
-            const wildcardParentPathInfo = pathInfo.wildcardParentPathInfos[i];
-            const wildcardAddress = createStateAddress(wildcardParentPathInfo, listIndex);
-            const tmpValue = getByAddress(target, wildcardAddress, receiver, handler);
-            const listIndexes = getListIndexesByList(tmpValue);
-            if (listIndexes == null) {
-                raiseError(`ListIndexes not found: ${wildcardParentPathInfo.path}`);
-            }
-            const index = indexes[i];
-            // 範囲外 index はリスト自体の不在と別原因なので index を含める
-            // （docs/state-bind-component-nested-for-design.md §8.4）
-            listIndex = listIndexes[index] ??
-                raiseError(`ListIndex not found at index ${index} of ${wildcardParentPathInfo.path}`);
+        // 添字の本数はワイルドカードの本数と**厳密に一致**する必要がある。
+        // 不足は元から throw していたが、超過は黙って無視されていた（余分な要素を
+        // 誰も読まないため）＝ `$resolve("items.*.price", [row, col])` のような
+        // 「1 本しか無いのに 2 本渡す」取り違えが、間違った値を返したまま通っていた。
+        if (indexes.length !== pathInfo.wildcardParentPathInfos.length) {
+            raiseError(indexArityMessage("$resolve", path, pathInfo.wildcardParentPathInfos.length, indexes.length));
         }
+        // ワイルドカード階層ごとにListIndexを解決していく（`$setAll` と共有）
+        const listIndex = getListIndexByIndexes(target, receiver, handler, pathInfo, indexes);
         // ToDo:WritableかReadonlyかを判定して適切なメソッドを呼び出す
         const address = createStateAddress(pathInfo, listIndex);
         const hasSetValue = typeof value !== "undefined";
@@ -13194,14 +14273,18 @@ function resolve(target, _prop, receiver, handler) {
  * getAllReadonly
  *
  * ワイルドカードを含む State パスから、対象となる全要素を配列で取得する。
- * Throws: LIST-201（インデックス未解決）、BIND-201（ワイルドカード情報不整合）
+ * 走査そのものは `$setAll` と共有する（wildcardIndexes.ts）。
+ *
+ * `indexes` 省略時の既定はループ文脈の添字 `[$1..$n]`。正確には「path と文脈が
+ * 共有するワイルドカード連鎖の分だけ文脈の添字を接頭辞として敷く」（整合最長接頭辞）。
+ * 共有が無いのに文脈が添字を持つ場合は throw する — 異なる文脈の添字は流用しない。
+ *
+ * Throws: LIST-201（インデックス未解決）、BIND-201（ワイルドカード情報不整合）、
+ * 添字本数超過（wcs/index-arity）、省略時の文脈不整合（getAllContextMismatchMessage）
  */
-// ToDo: IAbsoluteStateAddressに変更する
-const lastValueByListAddress = new WeakMap();
 function getAll(target, prop, receiver, handler) {
     const resolveFn = resolve(target, prop, receiver, handler);
     return (path, indexes) => {
-        const newValueByAddress = new Map();
         const pathInfo = getPathInfo(path);
         if (handler.addressStackLength > 0) {
             const lastInfo = handler.lastAddressStack?.pathInfo ?? null;
@@ -13213,61 +14296,48 @@ function getAll(target, prop, receiver, handler) {
                 }
             }
         }
+        // 明示的に渡された添字だけを検査する。`$getAll` の添字は**前方一致の接頭辞**で、
+        // 足りない分は「その階層を全部展開する」という正しい意味を持つ（README の
+        // `$getAll("scores.*", [])` がこれ）。一方**超過は意味を持たず黙って捨てられ**、
+        // ワイルドカードの本数を取り違えたまま部分集合が返っていた。
+        // 省略時に下で導出する添字は文脈由来なので、この検査には掛けない。
+        if (typeof indexes !== "undefined" && indexes.length > pathInfo.wildcardParentPathInfos.length) {
+            raiseError(indexArityMessage("$getAll", path, pathInfo.wildcardParentPathInfos.length, indexes.length));
+        }
         if (typeof indexes === "undefined") {
-            for (let i = 0; i < pathInfo.wildcardParentPathInfos.length; i++) {
-                const wildcardPattern = pathInfo.wildcardParentPathInfos[i];
-                const listIndex = getContextListIndex(handler, wildcardPattern.path);
+            // 省略時の既定はループ文脈の添字 `[$1..$n]`。ただし敷けるのは path と文脈が
+            // **共有するワイルドカード連鎖**の分だけなので、path のワイルドカードを
+            // 内側（最深）から探し、最初に文脈にヒットした階層の scoped indexes を接頭辞にする。
+            // ワイルドカードパスの序数はパス文字列自身の `*` の本数で決まるため、深い側が
+            // ヒットすれば浅い側は必ず含まれ、これが整合する最長の接頭辞になる。文脈が
+            // path より深い分は自然に切り詰められ、導出した接頭辞は path のワイルドカード
+            // 本数を超えないので、上の本数検査には掛けない。
+            for (let i = pathInfo.wildcardPaths.length - 1; i >= 0; i--) {
+                const listIndex = getContextListIndex(handler, pathInfo.wildcardPaths[i]);
                 if (listIndex) {
                     indexes = getScopedIndexes(listIndex, listIndex.length - getBaseDepth(handler.stateElement));
                     break;
                 }
             }
             if (typeof indexes === "undefined") {
+                // 共有ゼロ。文脈が自スコープの添字を実際に持っているなら、既定の `[...$n]` は
+                // **異なる文脈の添字の流用（混入）**になるため、黙って全展開へ倒さず throw する。
+                // 文脈そのものが無い（トップレベル getter / メソッド直下）なら全展開が既定。
+                const lastAddress = handler.addressStackLength > 0 ? handler.lastAddressStack : null;
+                const contextListIndex = lastAddress?.listIndex ?? null;
+                if (pathInfo.wildcardCount > 0 && lastAddress !== null && contextListIndex !== null &&
+                    contextListIndex.length - getBaseDepth(handler.stateElement) > 0) {
+                    raiseError(getAllContextMismatchMessage(path, lastAddress.pathInfo.path));
+                }
                 indexes = [];
             }
         }
-        const walkWildcardPattern = (wildcardParentPathInfos, wildcardIndexPos, listIndex, indexes, indexPos, parentIndexes, results) => {
-            const wildcardParentPathInfo = wildcardParentPathInfos[wildcardIndexPos] ?? null;
-            if (wildcardParentPathInfo === null) {
-                results.push(parentIndexes);
-                return;
-            }
-            const wildcardAddress = createStateAddress(wildcardParentPathInfo, listIndex);
-            const oldValue = lastValueByListAddress.get(wildcardAddress);
-            const newValue = getByAddress(target, wildcardAddress, receiver, handler);
-            const listDiff = createListDiff(getListParentListIndex(handler.stateElement, listIndex), oldValue, newValue);
-            const listIndexes = listDiff.newIndexes;
-            const index = indexes[indexPos] ?? null;
-            newValueByAddress.set(wildcardAddress, newValue);
-            if (index === null) {
-                for (let i = 0; i < listIndexes.length; i++) {
-                    const listIndex = listIndexes[i];
-                    walkWildcardPattern(wildcardParentPathInfos, wildcardIndexPos + 1, listIndex, indexes, indexPos + 1, parentIndexes.concat(listIndex.index), results);
-                }
-            }
-            else {
-                // 範囲外 index はリスト自体の不在と別原因なので index を含める
-                // （docs/state-bind-component-nested-for-design.md §8.4）
-                const listIndex = listIndexes[index] ??
-                    raiseError(`ListIndex not found at index ${index} of ${wildcardParentPathInfo.path}`);
-                if ((wildcardIndexPos + 1) < wildcardParentPathInfos.length) {
-                    walkWildcardPattern(wildcardParentPathInfos, wildcardIndexPos + 1, listIndex, indexes, indexPos + 1, parentIndexes.concat(listIndex.index), results);
-                }
-                else {
-                    // 最終ワイルドカード層まで到達しているので、結果を確定
-                    results.push(parentIndexes.concat(listIndex.index));
-                }
-            }
-        };
-        const resultIndexes = [];
-        walkWildcardPattern(pathInfo.wildcardParentPathInfos, 0, null, indexes, 0, [], resultIndexes);
+        // 読みなので差分基準を更新する（`$setAll` は更新しない。設計 §6-2）
+        const resultIndexes = collectWildcardIndexes(target, receiver, handler, pathInfo, indexes, { commitDiffBaseline: true });
         const resultValues = [];
         for (let i = 0; i < resultIndexes.length; i++) {
             resultValues.push(resolveFn(pathInfo.path, resultIndexes[i]));
         }
-        for (const [address, newValue] of newValueByAddress.entries()) {
-            lastValueByListAddress.set(address, newValue);
-        }
         return resultValues;
     };
 }
@@ -13351,6 +14421,83 @@ function postUpdate(target, _prop, receiver, handler) {
     };
 }
 
+/**
+ * setAll.ts
+ *
+ * ワイルドカードを含む State パスにマッチする**全アドレスへ一括で書き込む**。
+ * `$getAll`（読み）の対称形（docs/state-set-all-design.md）。
+ *
+ * 存在理由は糖衣ではなく「**リスト全置換の回避**」（設計 §1-1）。
+ * `this.users = this.users.map(...)` は配列を作り直すので ListIndex・行 getter
+ * キャッシュ・差分描画がまとめて作り直しになる。`$setAll` は意味としては一括更新、
+ * 実体は in-place な個別書き込みで、同じことを差分に載せたまま行う。
+ *
+ * 3 つの形（設計 §2）:
+ * - ブロードキャスト  `$setAll(path, indexes, value)`
+ * - mapper（第一級）  `$setAll(path, indexes, (current, ...indexes) => next)`
+ * - spread            `$setAll(path, indexes, values, { spread: true })`
+ */
+function setAll(target, _prop, receiver, handler) {
+    return (path, indexes, value, options) => {
+        const pathInfo = getPathInfo(path);
+        // 書き込み API に暗黙の文脈依存は持たせない。`for` の中で `[]` と書けば
+        // 「現在行」ではなく「全行」を意味する（設計 §4-1）。
+        if (!Array.isArray(indexes)) {
+            raiseError(setAllValueKindMessage(path, "requires an explicit indexes array (pass [] to expand every level)."));
+        }
+        // 添字は前方一致の接頭辞なので不足は正当。超過だけを弾く（`$getAll` と同じ規則）。
+        if (indexes.length > pathInfo.wildcardParentPathInfos.length) {
+            raiseError(indexArityMessage("$setAll", path, pathInfo.wildcardParentPathInfos.length, indexes.length));
+        }
+        const spread = options?.spread === true;
+        const isMapper = typeof value === "function";
+        if (spread && isMapper) {
+            raiseError(setAllValueKindMessage(path, "cannot combine { spread: true } with a mapper function."));
+        }
+        if (spread && !Array.isArray(value)) {
+            raiseError(setAllValueKindMessage(path, "requires an array as the value when { spread: true } is set."));
+        }
+        // --- 第 1 相: 書き込み先を全部確定する（設計 §6） ---
+        // 走査しながら書くと書き込みが ListIndex 集合を動かしうる。
+        // 差分基準（lastValueByListAddress）は読みの持ち物なので commit しない（§6-2）。
+        const resultIndexes = collectWildcardIndexes(target, receiver, handler, pathInfo, indexes, { commitDiffBaseline: false });
+        if (spread && value.length !== resultIndexes.length) {
+            raiseError(setAllSpreadArityMessage(path, resultIndexes.length, value.length));
+        }
+        const addresses = [];
+        for (let i = 0; i < resultIndexes.length; i++) {
+            const listIndex = getListIndexByIndexes(target, receiver, handler, pathInfo, resultIndexes[i]);
+            addresses.push(createStateAddress(pathInfo, listIndex));
+        }
+        // --- 第 2 相: 確定したアドレスにだけ書く ---
+        let written = 0;
+        for (let i = 0; i < addresses.length; i++) {
+            const address = addresses[i];
+            let nextValue;
+            if (isMapper) {
+                // 現在値は書く直前に読む。先行する書き込みが getter 経由で他行に及ぶ場合、
+                // mapper が見るべきなのは最新値。
+                const currentValue = getByAddress(target, address, receiver, handler);
+                nextValue = value(currentValue, ...resultIndexes[i]);
+            }
+            else if (spread) {
+                nextValue = value[i];
+            }
+            else {
+                nextValue = value;
+            }
+            // undefined は常にスキップ（設計 §5）。mapper の return 忘れで全行を潰さないため、
+            // かつ「この行は変えない」を表現できるようにするため。クリアは null。
+            if (typeof nextValue === "undefined") {
+                continue;
+            }
+            setByAddress(target, address, nextValue, receiver, handler);
+            written++;
+        }
+        return written;
+    };
+}
+
 /**
  * trackDependency.ts
  *
@@ -13525,7 +14672,7 @@ function setLoopContext(handler, loopContext, callback) {
  * StateClassのProxyトラップとして、プロパティアクセス時の値取得処理を担う関数（get）の実装です。
  *
  * 主な役割:
- * - 文字列プロパティの場合、特殊プロパティ（$1〜、$stateElement, $getAll, $postUpdate,
+ * - 文字列プロパティの場合、特殊プロパティ（$1〜、$stateElement, $getAll, $setAll, $postUpdate,
  *   $resolve, $trackDependency, $command, $streamStatus, $streamError）に応じた値やAPIを返却
  * - 通常のプロパティはgetResolvedPathInfoでパス情報を解決し、getListIndexでリストインデックスを取得
  * - getByRefで構造化パス・リストインデックスに対応した値を取得
@@ -13588,6 +14735,11 @@ function get(target, prop, receiver, handler) {
                         return getAll(target, prop, receiver, handler)(path, indexes);
                     };
                 }
+                case "$setAll": {
+                    return (path, indexes, value, options) => {
+                        return setAll(target, prop, receiver, handler)(path, indexes, value, options);
+                    };
+                }
                 case "$postUpdate": {
                     return (path) => {
                         return postUpdate(target, prop, receiver, handler)(path);
@@ -13719,6 +14871,8 @@ function set(target, prop, value, receiver, handler) {
     }
 }
 
+/** 循環報告に載せるスタック末尾の段数（当事者が見える最小限） */
+const CYCLE_REPORT_DEPTH = 8;
 class StateHandler {
     _stateElement;
     _stateName;
@@ -13759,12 +14913,36 @@ class StateHandler {
         return this._loopContext;
     }
     pushAddress(address) {
-        this._addressStackIndex++;
-        if (this._addressStackIndex >= MAX_LOOP_DEPTH) {
-            raiseError(`Exceeded maximum address stack depth of ${MAX_LOOP_DEPTH}. Possible infinite loop.`);
+        // 上限判定は **increment より前**に行う。後にすると、深さ超過で throw した時点で
+        // `_addressStackIndex` だけが進み `_addressStack[index]` は未代入のまま残る。
+        // 呼び出し側（getByAddress）は `pushAddress` を try の外で呼ぶので自分では pop
+        // しないが、外側フレームの finally が順に pop していき、その 1 本目が未代入の枠を
+        // 引いて `Address stack at index N is undefined.` を投げる ＝ **本来の
+        // 「無限ループの疑い」という診断が巻き戻しの最中に上書きされて消える**。
+        // getter の相互参照（`get a(){return this.b}` / `get b(){return this.a}`）は
+        // 実際にこれを踏み、原因と無関係な文面だけが残っていた。
+        if (this._addressStackIndex + 1 >= MAX_LOOP_DEPTH) {
+            raiseError(`Exceeded maximum address stack depth of ${MAX_LOOP_DEPTH}. ` +
+                `Possible circular dependency between path getters: ${this._describeAddressCycle()}`);
         }
+        this._addressStackIndex++;
         this._addressStack[this._addressStackIndex] = address;
     }
+    /**
+     * スタック末尾の繰り返し区間をパス名で示す（循環の当事者だけを見せる）。
+     * 上限に達したときのみ呼ばれるので、コストは異常系に閉じている。
+     */
+    _describeAddressCycle() {
+        const paths = [];
+        for (let i = this._addressStackIndex; i >= 0 && paths.length < CYCLE_REPORT_DEPTH; i--) {
+            const entry = this._addressStack[i];
+            if (entry) {
+                paths.push(entry.pathInfo.path);
+            }
+        }
+        const unique = Array.from(new Set(paths));
+        return `${unique.reverse().join(" -> ")} -> ...`;
+    }
     popAddress() {
         if (this._addressStackIndex < 0) {
             return null;
@@ -14353,7 +15531,13 @@ class State extends HTMLElementBase {
                 raiseError(`"bind-component" cannot be combined with ${conflicting.join(", ")}. The component's "${this.getAttribute("bind-component")}" property is the only state source.`);
             }
             const boundComponentStateProp = this.getAttribute("bind-component");
-            await customElements.whenDefined(customTagName.toLowerCase());
+            const componentRegistry = getCustomElementRegistry(boundComponent);
+            if (componentRegistry === null) {
+                // null レジストリのサブツリーではホストは永久に upgrade されない。
+                // whenDefined を待つと無言でウェッジするので落とす。
+                raiseError(`CustomElementRegistry is unavailable for <${customTagName}>.`);
+            }
+            await componentRegistry.whenDefined(customTagName.toLowerCase());
             // data-wcs属性がある場合は、上位の状態によりbinding情報の設定が完了するまで待機する
             if (boundComponent.hasAttribute(config.bindAttributeName)) {
                 await waitInitializeBinding(boundComponent);
@@ -14518,8 +15702,12 @@ class State extends HTMLElementBase {
         if (!this.hasAttribute('enable-ssr') || inSsr()) {
             await this._callStateConnectedCallback();
         }
-        // サーバーモード + enable-ssr: バインディング完了後に <wcs-ssr> を生成
-        if (inSsr() && this.hasAttribute('enable-ssr')) {
+        // サーバーモード + enable-ssr: バインディング完了後に <wcs-ssr> を生成。
+        // orchestrated（サーバー主導の最終パス、docs/ssr-router-design.md §5）では
+        // 生成しない — renderToString が全要素の完了後にまとめて生成するため。
+        // ここで生成すると、router 等が後から挿入した内容の構造テンプレートを
+        // 取り逃がすレースがある（state のロード方式と文書順に依存）
+        if (inSsr() && this.hasAttribute('enable-ssr') && !isOrchestratedSsr()) {
             try {
                 await getBindingsReady(this.rootNode);
                 const name = this.getAttribute('name') || 'default';
@@ -14727,7 +15915,7 @@ class State extends HTMLElementBase {
     addStaticDependency(sourcePath, targetPath) {
         return this._addDependency(this._staticDependency, sourcePath, targetPath);
     }
-    setPathInfo(path, bindingType) {
+    setPathInfo(path, bindingType, source = "binding") {
         if (bindingType === "for") {
             const isNewListPath = !this._listPaths.has(path);
             this._listPaths.add(path);
@@ -14742,6 +15930,10 @@ class State extends HTMLElementBase {
         if (!this._pathSet.has(path)) {
             const pathInfo = getPathInfo(path);
             this._pathSet.add(path);
+            // 存在しないパスへの配線は「黙って更新されない」だけで終わるため、
+            // 新規パスを 1 回だけ検査して確実な miss を報告する（pathDiagnostics.ts）。
+            // パスごとに 1 回・バインド確立時のみで、更新のホットパスには乗らない。
+            checkDeclaredPath(this, this.__state, path, source);
             if (pathInfo.parentPath !== null) {
                 let currentPathInfo = pathInfo;
                 while (currentPathInfo.parentPath !== null) {
@@ -14803,20 +15995,77 @@ class State extends HTMLElementBase {
     }
 }
 
-function registerComponents() {
-    if (!customElements.get(config.tagNames.ssr)) {
-        customElements.define(config.tagNames.ssr, Ssr);
+/**
+ * Register this package's tags. Pass a scoped `CustomElementRegistry` to define
+ * them for a single shadow tree -- scoped registries do not inherit the global
+ * one, so a tree using one needs its own definitions.
+ */
+function registerComponents(registry = customElements) {
+    if (!registry.get(config.tagNames.ssr)) {
+        registry.define(config.tagNames.ssr, Ssr);
     }
-    if (!customElements.get(config.tagNames.state)) {
-        customElements.define(config.tagNames.state, State);
+    if (!registry.get(config.tagNames.state)) {
+        registry.define(config.tagNames.state, State);
     }
 }
 
-function bootstrapState(config) {
-    if (config) {
-        setConfig(config);
+/**
+ * `<html lang>` を既定ロケールとして採る。
+ *
+ * ロケール依存フィルタ（`locale` / `date` / `time` / `datetime`）は `config.locale`
+ * を読むが、それを設定できる公開の入口は `bootstrapState({ locale })` しかない。
+ * 一方 `auto` エントリは `bootstrapState()` を引数なしで呼ぶため、CDN 一発
+ * （`<script src=".../@wcstack/state/auto">`）で読み込んだページには**ロケールを
+ * 渡す口が無かった**。auto バンドルは SRI のため自己完結で、別途 `@wcstack/state`
+ * を import して `bootstrapState` を呼んでも別インスタンスになり効かない。
+ *
+ * `<html lang>` はページのロケールを書く HTML 標準の場所であり、SSR ではサーバーが、
+ * 静的ページでは head のスニペットが DOM 解析前に書く。そこを既定にすると
+ * **ロケールの正本が 1 つになり**、「設定を早く呼ぶ」という守りにくい順序の約束が
+ * 「`<html lang>` が state のロードより前にある」という構造的な保証に変わる。
+ *
+ * 明示指定（`bootstrapState({ locale })`）が常に優先する。
+ */
+function localeFromDocument() {
+    const lang = document.documentElement?.lang;
+    if (!lang) {
+        return undefined;
+    }
+    try {
+        // 妥当な BCP-47 タグでなければ Intl が RangeError を投げる。不正な lang を
+        // そのまま採ると、これまで既定 'en' で動いていたページのフィルタが実行時に
+        // 落ちる。既定へ落として警告するほうが、黙って壊すより回復しやすい。
+        Intl.getCanonicalLocales(lang);
+        return lang;
+    }
+    catch {
+        console.warn(`[@wcstack/state] <html lang="${lang}"> is not a valid BCP-47 language tag. ` +
+            `Falling back to the default locale for filters.`);
+        return undefined;
+    }
+}
+function resolveConfig(config) {
+    if (typeof config?.locale === "string") {
+        return config;
+    }
+    const locale = localeFromDocument();
+    if (locale === undefined) {
+        return config;
+    }
+    return { ...config, locale };
+}
+function bootstrapState(config, registry) {
+    const resolved = resolveConfig(config);
+    if (resolved) {
+        setConfig(resolved);
     }
-    registerComponents();
+    registerComponents(registry);
+    // binder プロトコルの提供（docs/binder-protocol-design.md）。router が後から
+    // 差し込むノードをバインドできるようにする。登録は冪等。
+    registerBinder();
+    // ssr-snapshot プロトコルの提供（docs/ssr-router-design.md §5）。renderToString が
+    // <wcs-ssr> 生成をサーバー主導の最終パスへ回せるようにする。登録は冪等。
+    registerSsrSnapshotBuilder();
     // DevTools Hook Protocol への source 登録（SSR では no-op・冪等）
     registerDevtoolsSource();
 }