@wcstack/state 1.31.0 → 1.33.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 を差し替えてサーバーレンダリング
@@ -1142,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);
     };
 };
 /**
@@ -1464,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);
     };
 };
 /**
@@ -1479,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);
     };
 };
 /**
@@ -1494,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);
     };
 };
 /**
@@ -1851,6 +1928,32 @@ function parsePropPart(propPart) {
     };
 }
 
+/**
+ * 名前付き State（`<wcs-state name>` / `path@name`）の deprecation 通知。
+ *
+ * v2 では名前の次元そのものが消え、`<wcs-state mount="path">` と接頭辞付きパスに
+ * 置き換わる（docs/state-mount-design.md D1 / D16）。1.x には `mount=` が無く、
+ * warn を出しても利用者は動けないので、**既定では出さない**（`config.debug` 下だけ）。
+ * 主経路は lint（`wcs/named-state-deprecated`）と README の告知。
+ *
+ * 出すときは種別 × 対象ごとに 1 回（起動のたびに同じ行が並ばないように）。
+ */
+const reported$1 = new Set();
+function warnNamedStateDeprecated(kind, subject) {
+    if (!config.debug) {
+        return;
+    }
+    const key = `${kind}:${subject}`;
+    if (reported$1.has(key)) {
+        return;
+    }
+    reported$1.add(key);
+    const hint = kind === 'attribute'
+        ? `<wcs-state name="${subject}"> will be removed in v2. Mount the state onto the root tree with <wcs-state mount="${subject}"> and read it as "${subject}.<path>".`
+        : `"${subject}" uses the "@name" state selector, which will be removed in v2. Read the mounted tree as "<name>.<path>" instead.`;
+    console.warn(`[@wcstack/state] [wcs/named-state-deprecated] ${hint} See docs/state-mount-design.md §9.`);
+}
+
 const cacheFilterInfos = new Map();
 // format: statePath@stateName|filter|filter
 // statePath-format: path.to.property (e.g., user.name.first, users.*.name, users.0.name, not include @)
@@ -1877,6 +1980,10 @@ function parseStatePart(statePart) {
     else {
         stateAndPath = statePart.trim();
     }
+    if (stateAndPath.indexOf(STATE_NAME_SEPARATOR) !== -1) {
+        // `path@name` は v2 で消える（docs/state-mount-design.md D16。既定では黙る）
+        warnNamedStateDeprecated('path', stateAndPath);
+    }
     const [statePathName, stateName = 'default'] = stateAndPath.split(STATE_NAME_SEPARATOR).map(trimFn);
     const pathInfo = getPathInfo(statePathName);
     return {
@@ -3942,11 +4049,12 @@ const outerMappingByElement = new WeakMap();
 const primaryMappingRuleSetByElement = new WeakMap();
 const primaryBindingByMappingRule = new WeakMap();
 function createMappingRuleByBinding(innerState, binding) {
-    const innerPathInfo = getPathInfo(binding.propSegments.slice(1).join(DELIMITER));
+    const innerPath = binding.propSegments.slice(1).join(DELIMITER);
+    const innerPathInfo = getPathInfo(innerPath);
     const innerAbsPathInfo = getAbsolutePathInfo(innerState, innerPathInfo);
     const outerAbsStateAddress = getAbsoluteStateAddressByBinding(binding);
     const outerAbsPathInfo = outerAbsStateAddress.absolutePathInfo;
-    return { innerAbsPathInfo, outerAbsPathInfo };
+    return { innerAbsPathInfo, outerAbsPathInfo, isRoot: innerPath.length === 0 };
 }
 function buildPrimaryMappingRule(webComponent, stateName, bindings) {
     if (bindings.length === 0) {
@@ -3958,8 +4066,16 @@ function buildPrimaryMappingRule(webComponent, stateName, bindings) {
     }
     const innerMappingRule = new Map();
     const outerMappingRule = new Map();
+    // 同じ内側パスを 2 つの規則が指す形（`state.x: b; state.x: c`、`state: a; state: b`）は
+    // どちらが勝つか書き手に見えないので、導出時ではなく構築時に落とす（設計書 §4-7 / M6）。
+    const seenInnerPaths = new Set();
     for (const binding of bindings) {
         const mappingRule = createMappingRuleByBinding(innerState, binding);
+        const innerPath = mappingRule.innerAbsPathInfo.pathInfo.path;
+        if (seenInnerPaths.has(innerPath)) {
+            raiseError('Duplicate mapping rule for web component.');
+        }
+        seenInnerPaths.add(innerPath);
         let primaryMappingRuleSet = primaryMappingRuleSetByElement.get(webComponent);
         if (typeof primaryMappingRuleSet === 'undefined') {
             primaryMappingRuleSetByElement.set(webComponent, new Set([mappingRule]));
@@ -4007,11 +4123,14 @@ function resetDerivedMappingRules(webComponent) {
     outerMappingByElement.set(webComponent, outerMappingRule);
 }
 /**
- * このコンポーネントに張られたプライマリ規則の**内側パス**を列挙する。
+ * このコンポーネントに張られたプライマリ規則の**内側パス**を列挙する（ルート規則を除く）。
  *
  * 切断 → 再接続を跨いだ子（行 content の再利用で起きる）は、切断中に親で起きた変更の
  * 通知を受け取れていない。再接続時に「束ねているパスを読み直せ」と撃つための入力で、
  * 何が変わったかは分からないのでプライマリ規則の粒度で丸ごと読み直す（§1.9）。
+ *
+ * ルート規則は内側パスが空で `$postUpdate("")` に意味が無いため含めない。ルート規則の
+ * 読み直しは子の登録済みパス全部（`getRootReloadPaths`）で行う。
  */
 function getPrimaryInnerPaths(webComponent) {
     const primaryMappingRuleSet = primaryMappingRuleSetByElement.get(webComponent);
@@ -4020,13 +4139,37 @@ function getPrimaryInnerPaths(webComponent) {
     }
     const paths = [];
     for (const rule of primaryMappingRuleSet) {
+        if (rule.isRoot) {
+            continue;
+        }
         paths.push(rule.innerAbsPathInfo.pathInfo.path);
     }
     return paths;
 }
+/** このコンポーネントのプライマリ規則の集合。無ければ null（plain）。 */
+function getPrimaryMappingRules(webComponent) {
+    return primaryMappingRuleSetByElement.get(webComponent) ?? null;
+}
+/** ルート規則（`state: path` の丸ごとマウント）があるか。 */
+function hasRootMappingRule(webComponent) {
+    const primaryMappingRuleSet = primaryMappingRuleSetByElement.get(webComponent);
+    if (typeof primaryMappingRuleSet === 'undefined') {
+        return false;
+    }
+    for (const rule of primaryMappingRuleSet) {
+        if (rule.isRoot) {
+            return true;
+        }
+    }
+    return false;
+}
 /**
  * 内側のパスを外側のパスへ翻訳する。規則が無ければプライマリ規則から導出する。
  *
+ * 導出は**最長接頭辞一致**。ルート規則（接頭辞長 0）はあらゆる内側パスに一致するが、
+ * 部分規則（`state.theme: theme`）がより長い接頭辞で一致すればそちらが勝つ
+ * （`state: rows; state.theme: theme` の併用 — 設計書 §3-2）。
+ *
  * `registerSubscriber` は導出に**副作用を持たせるか**の切り替え。既定（子の read /
  * write からの呼び出し）では導出した規則を台帳に memo し、対応するバインディングを
  * 親スコープの購読者として登録する。`false` を渡すと**参照専用**になり、台帳にも
@@ -4061,16 +4204,28 @@ function getOuterAbsolutePathInfo(webComponent, innerAbsPathInfo, registerSubscr
         return null;
     }
     let primaryMappingRule = null;
+    let matchedPrefixLength = -1;
     for (const currentPrimaryMappingRule of primaryMappingRuleSet) {
+        if (currentPrimaryMappingRule.isRoot) {
+            // ルート規則は接頭辞長 0 で常に一致。部分規則が無ければこれが採られる
+            if (matchedPrefixLength < 0) {
+                primaryMappingRule = currentPrimaryMappingRule;
+                matchedPrefixLength = 0;
+            }
+            continue;
+        }
         // innerPathInfoがprimaryMappingRuleのinnerPathInfoを包含しているか
         if (!innerAbsPathInfo.pathInfo.cumulativePathInfoSet.has(currentPrimaryMappingRule.innerAbsPathInfo.pathInfo)) {
             continue;
         }
-        if (currentPrimaryMappingRule.innerAbsPathInfo.pathInfo.segments.length === innerAbsPathInfo.pathInfo.segments.length) {
+        const prefixLength = currentPrimaryMappingRule.innerAbsPathInfo.pathInfo.segments.length;
+        if (prefixLength === innerAbsPathInfo.pathInfo.segments.length) {
             raiseError('Duplicate mapping rule for web component.');
         }
-        primaryMappingRule = currentPrimaryMappingRule;
-        break;
+        if (prefixLength > matchedPrefixLength) {
+            primaryMappingRule = currentPrimaryMappingRule;
+            matchedPrefixLength = prefixLength;
+        }
     }
     if (primaryMappingRule === null) {
         // マッピングルールに一致しない場合はnullを返し、ローカル状態へのフォールバックを許可する
@@ -4083,7 +4238,7 @@ function getOuterAbsolutePathInfo(webComponent, innerAbsPathInfo, registerSubscr
         raiseError('Binding not found for primary mapping rule on web component.');
     }
     /* c8 ignore stop */
-    const outerRemainingSegments = innerAbsPathInfo.pathInfo.segments.slice(primaryMappingRule.innerAbsPathInfo.pathInfo.segments.length);
+    const outerRemainingSegments = innerAbsPathInfo.pathInfo.segments.slice(matchedPrefixLength);
     const outerSegments = primaryMappingRule.outerAbsPathInfo.pathInfo.segments.concat(outerRemainingSegments);
     const outerPathInfo = getPathInfo(outerSegments.join(DELIMITER));
     const rootNode = webComponent.getRootNode();
@@ -4568,6 +4723,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")
@@ -5583,6 +5748,33 @@ function markWebComponentAsComplete(webComponent, stateProp) {
 function isWebComponentComplete(webComponent, stateProp) {
     return completedStatePropsByWebComponent.get(webComponent)?.has(stateProp) === true;
 }
+/**
+ * `<wcs-state bind-component="<prop>">` が接続され、(webComponent, stateProp) を束ねると
+ * **宣言した**台帳。完了（上）より前 — ホストの `whenDefined` / `waitInitializeBinding` を
+ * 待つ前 — に記録する。
+ *
+ * 用途は丸ごとマウント `data-wcs="state: user"` の**完了前の初期適用の抑止**。完了前の
+ * 1 セグメントバインディングは applyChangeToProperty が `element.state = userObject` と
+ * 親のオブジェクトそのものをコンポーネントの state プロパティに書いてしまい、
+ * bindWebComponent がそれを子 state の実体として取り込む — own data key が親のキー全部に
+ * なり、R1 では全部が私有に化ける。宣言済みなら値を書かずに完了を待つ（子は完了後に
+ * innerState 経由でライブに読む — docs/state-mount-design.md §3-2 / impl-plan P1-1）。
+ *
+ * 未宣言（子がまだ接続していない）の間は従来どおり書く。未 upgrade 要素への own property は
+ * upgrade 時のクラスフィールド初期化で置き換わるので、実害は無い。
+ */
+const declaredStatePropsByWebComponent = new WeakMap();
+function markWebComponentStatePropDeclared(webComponent, stateProp) {
+    let declaredStateProps = declaredStatePropsByWebComponent.get(webComponent);
+    if (!declaredStateProps) {
+        declaredStateProps = new Set();
+        declaredStatePropsByWebComponent.set(webComponent, declaredStateProps);
+    }
+    declaredStateProps.add(stateProp);
+}
+function isWebComponentStatePropDeclared(webComponent, stateProp) {
+    return declaredStatePropsByWebComponent.get(webComponent)?.has(stateProp) === true;
+}
 
 function applyChangeToAttribute(binding, _context, newValue) {
     const element = binding.node;
@@ -6452,8 +6644,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;
             }
@@ -6665,6 +6872,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();
@@ -6832,6 +7190,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 ループ後の参照で安定）
@@ -6875,6 +7237,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}"`);
@@ -6974,6 +7339,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);
+        }
     }
 }
 
@@ -7027,6 +7397,68 @@ function applyMirrorAttribute(element, attributeName, value) {
     element.setAttribute(attributeName, formatted);
 }
 
+/**
+ * `bind-component` の**完了前**に親スコープの初期適用がコンポーネントの state プロパティへ
+ * 行った書き込みの控え（docs/state-mount-design.md D19 / impl-plan P1-1・P1-10）。
+ *
+ * 完了前の親→子の適用は `applyChangeToProperty` が素のプロパティに値を積む
+ * （webComponent/completeWebComponent.ts）。丸ごとマウントと R1 が入って、この積みが
+ * 2 つの取り違えを生むようになった。
+ *
+ * 1. **丸ごと（1 セグメント・`state: user`）**: `element.state = userObject` と親の
+ *    オブジェクトそのもので state プロパティを**置き換える**。子がまだ宣言していない
+ *    タイミング（happy-dom の template clone は upgrade 済みで、挿入前に適用が走る）では
+ *    宣言台帳のガードが効かず、作者の state オブジェクト（getter / 私有キー）が失われる。
+ *    → 置き換え前のオブジェクトを控え、子の初期化時に戻す（`takeOverwrittenObject`）。
+ * 2. **部分（2 セグメント・`state.theme: theme`）**: `element.state.theme = themeObject` と
+ *    作者のオブジェクトに**キーを注入する**。R1 の判定はこれを own data key と区別できない。
+ *    → 注入したキーを控え、衝突の報告（ownKeyShadow）から外す（`getInjectedKeys`）。
+ *    私有判定そのものは innerState が「部分規則が覆うキー」を静的に除くので、ここには依らない。
+ *
+ * どちらもカスタム要素・オブジェクト値のときだけ記録するので、通常のプロパティ書き込み
+ * （textContent / value / checked …）のホットパスには typeof 判定 1 つしか載らない。
+ */
+const overwrittenObjectByElement = new WeakMap();
+const injectedKeysByElement = new WeakMap();
+/** 1 セグメント書き込みで置き換えられる直前のオブジェクトを控える。最初の 1 回だけ（作者のもの）。 */
+function rememberOverwrittenObject(element, prop, previous) {
+    let byProp = overwrittenObjectByElement.get(element);
+    if (!byProp) {
+        byProp = new Map();
+        overwrittenObjectByElement.set(element, byProp);
+    }
+    if (!byProp.has(prop)) {
+        byProp.set(prop, previous);
+    }
+}
+/** 控えを取り出して消す。無ければ undefined。 */
+function takeOverwrittenObject(element, prop) {
+    const byProp = overwrittenObjectByElement.get(element);
+    if (!byProp) {
+        return undefined;
+    }
+    const previous = byProp.get(prop);
+    byProp.delete(prop);
+    return previous;
+}
+/** 2 セグメント書き込み（`state.theme`）が作者のオブジェクトに無かったキーを作ったことを控える。 */
+function recordInjectedKey(element, prop, key) {
+    let byProp = injectedKeysByElement.get(element);
+    if (!byProp) {
+        byProp = new Map();
+        injectedKeysByElement.set(element, byProp);
+    }
+    let keys = byProp.get(prop);
+    if (!keys) {
+        keys = new Set();
+        byProp.set(prop, keys);
+    }
+    keys.add(key);
+}
+function getInjectedKeys(element, prop) {
+    return injectedKeysByElement.get(element)?.get(prop);
+}
+
 /**
  * SSR 時に HTML 属性で表現できないプロパティバインディングを蓄積するストア。
  * ハイドレーション時にクライアント側で復元する。
@@ -7123,7 +7555,17 @@ function applyChangeToProperty(binding, _context, newValue) {
     const propSegments = binding.propSegments;
     if (propSegments.length === 1) {
         const firstSegment = propSegments[0];
-        if (element[firstSegment] !== newValue) {
+        const current = element[firstSegment];
+        if (current !== newValue) {
+            // 完了前の丸ごとマウント（`state: user`）は、作者の state オブジェクトを親の
+            // オブジェクトで置き換えてしまう。あとで戻せるように置き換え前を控える
+            // （webComponent/preCompletionWrites.ts）。オブジェクト → オブジェクトの書き込みで
+            // 相手がカスタム要素のときだけ台帳に触る（通常の書き込みは typeof 判定で抜ける）。
+            if (current !== null && typeof current === 'object'
+                && newValue !== null && typeof newValue === 'object'
+                && getCustomElement(element) !== null) {
+                rememberOverwrittenObject(element, firstSegment, current);
+            }
             const performWrite = () => {
                 let propertyWriteSucceeded = false;
                 try {
@@ -7225,7 +7667,8 @@ function applyChangeToProperty(binding, _context, newValue) {
         }
         subObject = subObject[segment];
     }
-    const oldValue = subObject[propSegments[propSegments.length - 1]];
+    const lastSegment = propSegments[propSegments.length - 1];
+    const oldValue = subObject[lastSegment];
     if (oldValue !== newValue) {
         if (Object.isFrozen(subObject)) {
             if (config.debug) {
@@ -7238,8 +7681,15 @@ function applyChangeToProperty(binding, _context, newValue) {
             }
             return;
         }
+        // 完了前の部分マウント（`state.theme: theme`）が、作者の state オブジェクトに無かった
+        // キーを作る（積み）ことを控える。R1 の衝突報告はこのキーを作者のものとして扱わない
+        // （webComponent/preCompletionWrites.ts）
+        if (propSegments.length === 2 && typeof subObject === 'object' && subObject !== null
+            && !(lastSegment in subObject) && getCustomElement(element) !== null) {
+            recordInjectedKey(element, firstSegment, lastSegment);
+        }
         try {
-            subObject[propSegments[propSegments.length - 1]] = newValue;
+            subObject[lastSegment] = newValue;
         }
         catch (error) {
             if (config.debug) {
@@ -7297,6 +7747,34 @@ function applyChangeToText(binding, _context, newValue) {
     }
 }
 
+/**
+ * ルート規則（`data-wcs="state: path"` の丸ごとマウント）で、親がマウント先を
+ * 丸ごと差し替えた／子が切断 → 再接続した、というときに子へ「読み直せ」と撃つパスの集合。
+ *
+ * 部分規則ならプライマリの内側パス（`state.items: rows` なら `items`）を撃てば依存 walk が
+ * 配下へ展開するが、ルート規則は内側パスが空で `$postUpdate("")` に意味が無い。
+ * 代わりに子の登録済みパス（`boundPaths`）の**先頭セグメント**を撃つ — `tags.*.name` は
+ * `tags` から静的依存で展開されるので、先頭だけで配下を覆える。
+ *
+ * `$` 名前空間（`$1` など）は state に実体を持たないので除く。私有キー（R1）への通知は
+ * 値が変わっていないので再描画が同値で終わるだけ（無害）。
+ */
+function getRootReloadPaths(innerStateElement) {
+    const boundPaths = innerStateElement.boundPaths;
+    if (typeof boundPaths === 'undefined') {
+        return [];
+    }
+    const roots = new Set();
+    for (const path of boundPaths) {
+        if (path[0] === '$') {
+            continue;
+        }
+        const dot = path.indexOf(DELIMITER);
+        roots.add(dot === -1 ? path : path.slice(0, dot));
+    }
+    return [...roots];
+}
+
 /**
  * 親 state → `bind-component` 済みコンポーネントの再読込通知（内部チャネル）。
  *
@@ -7315,13 +7793,14 @@ function applyChangeToText(binding, _context, newValue) {
  * （apply/applyChange.ts）、`bindWebComponent` は完了済み ＝ state element は登録済み。
  * ただし**登録済みと使用可能は別**で、切断済みの state element が台帳に残っている
  * 窓がある（§1.9）。下の使用可能判定を参照。
+ *
+ * 残余パスが空（`data-wcs="state: user"` — ルート規則の丸ごとマウント）は、親が
+ * マウント先を丸ごと差し替えたという通知。何が変わったかは分からないので、子の
+ * 登録済みパス全部を読み直す（docs/state-mount-design.md §3-2 / impl-plan P1-2）。
  */
 function applyChangeToWebComponent(binding, _context, _newValue) {
     const element = binding.node;
     const propSegments = binding.propSegments;
-    if (propSegments.length <= 1) {
-        raiseError(`Invalid propSegments for web component binding: ${propSegments.join(DELIMITER)}`);
-    }
     const [firstSegment, ...restSegments] = propSegments;
     const innerStateElement = getStateElementByWebComponent(element, firstSegment);
     if (innerStateElement === null) {
@@ -7346,6 +7825,18 @@ function applyChangeToWebComponent(binding, _context, _newValue) {
         }
         return;
     }
+    if (restSegments.length === 0) {
+        const paths = getRootReloadPaths(innerStateElement);
+        if (paths.length === 0) {
+            return;
+        }
+        innerStateElement.createState("readonly", (state) => {
+            for (const path of paths) {
+                state.$postUpdate(path);
+            }
+        });
+        return;
+    }
     innerStateElement.createState("readonly", (state) => {
         state.$postUpdate(restSegments.join(DELIMITER));
     });
@@ -7509,12 +8000,47 @@ function missingRootPathMessage(stateName, path, target, declaredPaths) {
  * 決まるので、噛み合わないことは常にプログラマのミス。
  */
 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}`;
+}
 /**
  * ワイルドカードを解決するループ文脈が足りない（＝パスの階数 > スコープの階数）。
  *
@@ -7697,21 +8223,36 @@ const deferredSelectBindingByBinding = new WeakMap();
 // registry 照会を省略できる。scoped registry を導入する場合はこの不可逆前提を再検討。
 const definedApplyVerifiedByBinding = new WeakMap();
 /**
- * このバインディングを「値を運ばない親→子の再読込通知」（applyChangeToWebComponent）へ
- * 回してよいか。
- *
- * 長さ 1 の propSegments を除くのが要点。`data-wcs="state: user"` のように
- * bind-component の stateProp をそのままプロパティ名に書いた形は、完了台帳のキーが
- * stateProp 名になった以上ゲートを通ってしまうが、applyChangeToWebComponent は
- * 「先頭セグメント＝束ね先の state 要素、残り＝子側のパス」を前提にしており
- * 残余が空だと raiseError する。updater の drain は例外を捕まえないので、
- * 誤設定タグ 1 つが同じバッチの無関係な更新まで巻き添えにしてしまう。
- * ここで弾いておけば従来どおり applyChangeToProperty に落ち、挙動は変わらない
- * （getter だけの公開プロパティへの代入が握り潰される ＝ 無言の no-op）。
+ * 丸ごとマウント（`state: user`）の完了前の初期適用は書かない。子が完了すれば
+ * innerState 経由でライブに読むので、ここで親のオブジェクトを書く意味は無い
+ * （書くと害がある — webComponent/completeWebComponent.ts の宣言台帳を参照）。
+ */
+function skipPendingRootMount() { }
+/**
+ * カスタム要素へのプロパティバインディングの適用関数を決める。
+ *
+ * - 完了済み（bindWebComponent が公開プロパティを差し替え終えた）→ 値を運ばない
+ *   再読込通知（applyChangeToWebComponent）。1 セグメント（`state: user`）も含む —
+ *   残余が空なら「子の登録済みパス全部を読み直せ」の意味（ルート規則。
+ *   docs/state-mount-design.md §3-2 / impl-plan P1-2）
+ * - 未完了だが `<wcs-state bind-component>` が宣言済みで、かつ 1 セグメント → 今回は
+ *   書かない（skipPendingRootMount）
+ * - それ以外 → 素のプロパティ書き込み（`state.name: x` の完了前の積みも含む）
+ *
+ * 以前は 1 セグメントを通知チャネルから除いていた（残余が空だと applyChangeToWebComponent
+ * が raiseError し、updater の drain が捕まえないので同じバッチの無関係な更新まで
+ * 巻き添えにした）。残余空がルート規則の意味を持った今、その除外は要らない。
  */
-function isWebComponentCompleteForBinding(binding) {
-    return binding.propSegments.length > 1
-        && isWebComponentComplete(binding.replaceNode, binding.propSegments[0]);
+function resolveCustomElementApply(binding) {
+    const element = binding.replaceNode;
+    const stateProp = binding.propSegments[0];
+    if (isWebComponentComplete(element, stateProp)) {
+        return applyChangeToWebComponent;
+    }
+    if (binding.propSegments.length === 1 && isWebComponentStatePropDeclared(element, stateProp)) {
+        return skipPendingRootMount;
+    }
+    return applyChangeToProperty;
 }
 function _applyChange(binding, context) {
     const value = getValue(context.state, binding);
@@ -7726,13 +8267,10 @@ function _applyChange(binding, context) {
         return;
     }
     if (fnByBinding.has(binding)) {
-        if (isWebComponentCompleteForBinding(binding)) {
-            fn = applyChangeToWebComponent;
+        fn = resolveCustomElementApply(binding);
+        if (fn === applyChangeToWebComponent) {
             fnByBinding.set(binding, fn); // 確定したのでキャッシュ
         }
-        else {
-            fn = applyChangeToProperty;
-        }
         fn(binding, context, filteredValue);
         return;
     }
@@ -7744,13 +8282,10 @@ function _applyChange(binding, context) {
         if (typeof fn === 'undefined') {
             const customTag = getCustomElement(binding.replaceNode);
             if (customTag) {
-                if (isWebComponentCompleteForBinding(binding)) {
-                    fn = applyChangeToWebComponent;
+                fn = resolveCustomElementApply(binding);
+                if (fn === applyChangeToWebComponent) {
                     fnByBinding.set(binding, fn); // 確定したのでキャッシュ
                 }
-                else {
-                    fn = applyChangeToProperty;
-                }
             }
             else {
                 fn = applyChangeToProperty;
@@ -8453,7 +8988,7 @@ async function buildBindings(root) {
     }
 }
 
-var version = "1.31.0";
+var version = "1.33.0";
 var pkg = {
 	version: version};
 
@@ -9176,6 +9711,221 @@ async function hydrateBindings(root) {
     return true;
 }
 
+// ===========================================================================
+// 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 台帳）。
@@ -9198,6 +9948,25 @@ function getStateElementByName(rootNode, name) {
 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) {
@@ -9250,6 +10019,11 @@ function setStateElementByName(rootNode, name, element) {
                             else {
                                 await buildBindings(rootNode);
                             }
+                            markBindingsBuilt(rootNode);
+                            // binder が居ない時点で差し出されたサブツリーを引き取る。ここが
+                            // 「state が確実に居る」最初の瞬間で、router の auto バンドルが
+                            // state のそれより先に走る順序を吸収できる唯一の場所である。
+                            drainPendingBinds();
                             resolve();
                         }
                         catch (error) {
@@ -9264,6 +10038,11 @@ function setStateElementByName(rootNode, name, element) {
                     queueMicrotask(async () => {
                         try {
                             await buildBindings(rootNode);
+                            markBindingsBuilt(rootNode);
+                            // binder が居ない時点で差し出されたサブツリーを引き取る。ここが
+                            // 「state が確実に居る」最初の瞬間で、router の auto バンドルが
+                            // state のそれより先に走る順序を吸収できる唯一の場所である。
+                            drainPendingBinds();
                             resolve();
                         }
                         catch (error) {
@@ -9373,6 +10152,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() {
@@ -9481,12 +10271,34 @@ class Updater {
         // 限られるが、そのとき drain フックまで道連れにすると「機構間の順序は固定」
         // （README の 3 層表）が黙って破れる。例外は握らない ＝ 伝播は維持する。
         try {
-            // context が無い場合は従来どおり 1 引数で呼ぶ（呼び出し契約の互換維持）
-            if (propagationContextByBinding.size > 0) {
-                applyChangeFromBindings(processBindings, propagationContextByBinding);
-            }
+            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 {
-                applyChangeFromBindings(processBindings);
+                const pending = runTransition("state", applyBindings);
+                if (pending !== undefined) {
+                    pending.catch(reportDeferredApplyFailure);
+                }
             }
         }
         finally {
@@ -9881,6 +10693,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>` の評価失敗を、原因の分かるメッセージに変換する。
@@ -9904,9 +10768,19 @@ function describeImportFailure(name, error, cspBlocked) {
     return `Failed to evaluate the inline <script> of state "${name}": ${detail}. ` +
         `If this page sets a Content-Security-Policy, see ${CSP_GUIDE}`;
 }
+/**
+ * ロードごとに増える通し番号。`data:` URL フォールバック（createObjectURL の無い
+ * テスト / SSR 環境）では URL がスクリプト本文そのものなので、同じ本文を 2 度
+ * 読み込むと ESM ローダーのキャッシュに当たり **同じモジュール = 同じ default export
+ * オブジェクト** が返る — 2 つ目の `<wcs-state>` が 1 つ目の state を共有してしまう
+ * （テストでは前のテストの書き込みが次のテストに漏れ、SSR では同一テンプレートの
+ * 再描画で state が共有される）。blob: URL は生成のたびに一意なのでブラウザでは
+ * 起きない。sourceURL コメントに番号を混ぜて本文を毎回変え、両経路を揃える。
+ */
+let loadSequence = 0;
 async function loadFromInnerScript(script, name) {
     let scriptModule = null;
-    const uniq_comment = `\n//# sourceURL=${name}\n`;
+    const uniq_comment = `\n//# sourceURL=${name}#${++loadSequence}\n`;
     // import() が失敗した理由が CSP かどうかを判別するために、評価の間だけ違反を購読する。
     let cspBlocked = false;
     const onViolation = (event) => {
@@ -9961,9 +10835,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) {
@@ -12176,6 +13067,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;
@@ -12463,38 +13389,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;
 }
 
 /**
@@ -13500,22 +14500,8 @@ function resolve(target, _prop, receiver, handler) {
         if (indexes.length !== pathInfo.wildcardParentPathInfos.length) {
             raiseError(indexArityMessage("$resolve", path, pathInfo.wildcardParentPathInfos.length, indexes.length));
         }
-        // ワイルドカード階層ごとに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}`);
-        }
+        // ワイルドカード階層ごとにListIndexを解決していく（`$setAll` と共有）
+        const listIndex = getListIndexByIndexes(target, receiver, handler, pathInfo, indexes);
         // ToDo:WritableかReadonlyかを判定して適切なメソッドを呼び出す
         const address = createStateAddress(pathInfo, listIndex);
         const hasSetValue = typeof value !== "undefined";
@@ -13532,14 +14518,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;
@@ -13560,60 +14550,39 @@ function getAll(target, prop, receiver, handler) {
             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;
     };
 }
@@ -13697,6 +14666,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
  *
@@ -13871,7 +14917,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で構造化パス・リストインデックスに対応した値を取得
@@ -13934,6 +14980,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);
@@ -14204,9 +15255,58 @@ function meltFrozenObject(frozenObj) {
 class InnerStateProxyHandler {
     _webComponent;
     _innerStateElement;
+    /**
+     * ルート規則（`state: path` の丸ごとマウント）の下にいるか。プライマリ規則は
+     * bindWebComponent が createInnerState より先に組むので、構築時に確定する。
+     */
+    _rootMounted;
+    /**
+     * 部分規則（`state.theme: theme`）が覆う内側の先頭セグメント。ルート規則と併用された
+     * とき、これらのキーは own data key があってもマッピング（1.x の既存挙動）に落とす。
+     * 完了前の親の初期適用が `element.state.theme = obj` とキーを注入する（積み）ので、
+     * own key の有無では作者の意図を判定できない（webComponent/preCompletionWrites.ts）。
+     */
+    _partialFirstSegments;
     constructor(webComponent, stateName) {
         this._webComponent = webComponent;
         this._innerStateElement = getStateElementByWebComponent(webComponent, stateName) ?? raiseError('State element not found for web component.');
+        this._rootMounted = hasRootMappingRule(webComponent);
+        this._partialFirstSegments = null;
+        if (this._rootMounted) {
+            const rules = getPrimaryMappingRules(webComponent);
+            for (const rule of rules ?? []) {
+                if (!rule.isRoot) {
+                    (this._partialFirstSegments ??= new Set()).add(rule.innerAbsPathInfo.pathInfo.segments[0]);
+                }
+            }
+        }
+    }
+    /**
+     * R1（docs/state-mount-design.md D4 / D19）: ルートマウント下では、コンポーネントが
+     * 自分で書いた data key は**私有**で、マウント先のツリーを隠す。v1 の解決順
+     * （getter → マッピング → ローカル）のままルート規則を載せると、ルート規則は全キーに
+     * 一致するので own key が全部ツリーに隠され、2.0 と逆の意味論で出荷することになる。
+     *
+     * 判定は**先頭セグメント**で行う。getByAddress は `"draft.title" in target` → 偽 →
+     * 親アドレス `draft` の読み、と降りてくるので、先頭が私有ならその下は素のオブジェクト
+     * 走査になる（plain な state と同じ）。getter / setter は規則 1（chroot 評価）なので除く。
+     *
+     * 部分マウントだけのコンポーネントには適用しない（1.x の既存挙動＝マッピングが勝つ、を
+     * 維持する。2.0 での反転は bindWebComponent が warn で予告する — D19）。
+     */
+    _isPrivateKey(target, prop) {
+        if (!this._rootMounted) {
+            return false;
+        }
+        const dot = prop.indexOf(DELIMITER);
+        const first = dot === -1 ? prop : prop.slice(0, dot);
+        if (!Object.prototype.hasOwnProperty.call(target, first)) {
+            return false;
+        }
+        if (this._partialFirstSegments !== null && this._partialFirstSegments.has(first)) {
+            return false;
+        }
+        return !this._innerStateElement.getterPaths.has(first) && !this._innerStateElement.setterPaths.has(first);
     }
     /**
      * 親スコープで読み書きするときのループ文脈を決める。候補は 2 つある。
@@ -14259,6 +15359,10 @@ class InnerStateProxyHandler {
             if (this._innerStateElement.getterPaths.has(prop) && prop in target) {
                 return Reflect.get(target, prop, receiver);
             }
+            // 1'. R1: ルートマウント下の own data key → 私有（マッピングより先）
+            if (this._isPrivateKey(target, prop)) {
+                return Reflect.get(target, prop, receiver);
+            }
             // 2 & 3. マッピング完全一致 / サブパス → 親の状態
             const innerPathInfo = getPathInfo(prop);
             const innerAbsPathInfo = getAbsolutePathInfo(this._innerStateElement, innerPathInfo);
@@ -14290,6 +15394,10 @@ class InnerStateProxyHandler {
             if (this._innerStateElement.setterPaths.has(prop) && prop in target) {
                 return Reflect.set(target, prop, value, receiver);
             }
+            // 1'. R1: ルートマウント下の own data key → 私有に書く
+            if (this._isPrivateKey(target, prop)) {
+                return Reflect.set(target, prop, value, receiver);
+            }
             // 2 & 3. マッピング完全一致 / サブパス → 親に書く
             const innerPathInfo = getPathInfo(prop);
             const innerAbsPathInfo = getAbsolutePathInfo(this._innerStateElement, innerPathInfo);
@@ -14323,6 +15431,11 @@ class InnerStateProxyHandler {
             if ((this._innerStateElement.getterPaths.has(prop) || this._innerStateElement.setterPaths.has(prop)) && prop in target) {
                 return true;
             }
+            // 1'. R1: 先頭が私有キーなら素のオブジェクトの答え（完全一致だけ真。`draft.title` は
+            // 偽を返して getByAddress に親アドレスから降りてもらう）
+            if (this._isPrivateKey(target, prop)) {
+                return prop in target;
+            }
             // 2 & 3. マッピング
             const innerPathInfo = getPathInfo(prop);
             const innerAbsPathInfo = getAbsolutePathInfo(this._innerStateElement, innerPathInfo);
@@ -14414,6 +15527,116 @@ function createOuterState(webComponent, stateName) {
     return new Proxy({}, handler);
 }
 
+/**
+ * コンポーネントの own data key とマウントの衝突を、バインド確立時に 1 回だけ報告する
+ * （docs/state-mount-design.md D4 / D19、impl-plan P1-10 / P1-11）。
+ *
+ * 2 つの形がある。
+ *
+ * - **ルートマウント**（`state: user`）: R1 では own data key は私有で、マウント先の
+ *   同名キー（`user.name`）を**隠す**。書き手が「既定値」のつもりで置いたキーがツリーを
+ *   読まなくなるので、マウント先の値がオブジェクトで同名キーを持つときに報告する。
+ * - **部分マウント**（`state.message: x` ＋ `state = { message: "" }`）: 1.x では
+ *   マッピングが勝つ（既存挙動・不変）が、v2 では R1 で own key が私有になり逆転する。
+ *   反転を 1.x の時点で予告する。
+ *
+ * どちらも「既定値を消す（ツリーを読む）か、名前を変える（私有のまま）」で直る。
+ * 報告はタグ名 × プロパティ × キーで 1 回（リストの行ごとに並ばないように）。
+ * ホットパス外（bindWebComponent の中・要素につき 1 回）。
+ */
+const reported = new Set();
+function ownDataKeys(state, injected) {
+    const keys = [];
+    for (const key of Object.keys(state)) {
+        if (key.startsWith('$')) {
+            continue;
+        }
+        // 完了前の親の初期適用（`state.theme: theme` の積み）が作ったキーは作者のものではない
+        if (typeof injected !== 'undefined' && injected.has(key)) {
+            continue;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(state, key);
+        if (typeof descriptor.get === 'function' || typeof descriptor.set === 'function') {
+            continue;
+        }
+        if (typeof descriptor.value === 'function') {
+            continue;
+        }
+        keys.push(key);
+    }
+    return keys;
+}
+/**
+ * ルート規則のマウント先の現在値を読む。ワイルドカードを含むマウント先（`users.*`）は
+ * ホスト要素のループ文脈で解決する。文脈が無ければ判定できないので undefined。
+ */
+function readMountTarget(component, rule) {
+    const outer = rule.outerAbsPathInfo;
+    const loopContext = getLoopContextByNode(component);
+    if (outer.pathInfo.wildcardCount > 0 && loopContext === null) {
+        return undefined;
+    }
+    let value = undefined;
+    outer.stateElement.createState("readonly", (state) => {
+        state[setLoopContextSymbol](loopContext, () => {
+            value = state[outer.pathInfo.path];
+        });
+    });
+    return value;
+}
+function report(key, message) {
+    if (reported.has(key)) {
+        return;
+    }
+    reported.add(key);
+    console.warn(`[@wcstack/state] [wcs/mount-own-key-shadow] ${message} See docs/state-mount-design.md §4-3.`);
+}
+function warnOwnKeyShadows(component, stateProp, state) {
+    const rules = getPrimaryMappingRules(component);
+    if (rules === null) {
+        return;
+    }
+    const keys = ownDataKeys(state, getInjectedKeys(component, stateProp));
+    if (keys.length === 0) {
+        return;
+    }
+    const tag = component.tagName.toLowerCase();
+    let rootRule = null;
+    const partialRuleByKey = new Map();
+    for (const rule of rules) {
+        if (rule.isRoot) {
+            rootRule = rule;
+        }
+        else if (rule.innerAbsPathInfo.pathInfo.segments.length === 1) {
+            partialRuleByKey.set(rule.innerAbsPathInfo.pathInfo.path, rule);
+        }
+    }
+    let mountTarget = undefined;
+    let mountTargetRead = false;
+    for (const key of keys) {
+        const partial = partialRuleByKey.get(key);
+        if (typeof partial !== 'undefined') {
+            const outerPath = partial.outerAbsPathInfo.pathInfo.path;
+            report(`${tag}|${stateProp}|${key}|partial`, `<${tag}>.${stateProp}.${key} is an own key of the component and is also mapped from the host ("${stateProp}.${key}: ${outerPath}"). ` +
+                `Today the host value wins; in v2 the own key becomes private and hides the host value. Remove the default, or drop the mapping.`);
+            continue;
+        }
+        if (rootRule === null) {
+            continue;
+        }
+        if (!mountTargetRead) {
+            mountTarget = readMountTarget(component, rootRule);
+            mountTargetRead = true;
+        }
+        if (typeof mountTarget !== 'object' || mountTarget === null || !(key in mountTarget)) {
+            continue;
+        }
+        const outerPath = rootRule.outerAbsPathInfo.pathInfo.path;
+        report(`${tag}|${stateProp}|${key}|root`, `<${tag}>.${stateProp}.${key} is private and hides the mounted tree key "${outerPath}.${key}" (${stateProp}: ${outerPath}). ` +
+            `Remove the default to read the tree, or rename it to keep it private.`);
+    }
+}
+
 const getOuter = (outerState) => () => outerState;
 function bindWebComponent(innerStateElement, component, stateProp, state) {
     setStateElementByWebComponent(component, stateProp, innerStateElement);
@@ -14430,6 +15653,9 @@ function bindWebComponent(innerStateElement, component, stateProp, state) {
     // innerState proxy、plain なら melt 済みのローカル state。
     if (bindings.length > 0) {
         buildPrimaryMappingRule(component, stateProp, bindings);
+        // own data key とマウントの衝突を 1 回だけ報告する（R1 の私有キーがツリーを隠す形と、
+        // 部分マウントで v2 に反転する形 — docs/state-mount-design.md D19）。
+        warnOwnKeyShadows(component, stateProp, state);
         // 値の正本が親スコープにあることを state 要素に記録する。越境アドレスの受け渡しと
         // リストパスの外向き伝播はこのフラグでのみ有効になる（§1.8）。
         innerStateElement.markComponentStateMapped?.();
@@ -14460,6 +15686,27 @@ function bindWebComponent(innerStateElement, component, stateProp, state) {
     }
 }
 
+/**
+ * ホストが `<stateProp>: path`（1 セグメント ＝ 丸ごとマウント・ルート規則）を
+ * このコンポーネントに書いているか。バインディング初期化が済んだ後に呼ぶこと
+ * （`State._initializeBindWebComponent` は `waitInitializeBinding` の後で呼ぶ）。
+ */
+function hasRootMountBinding(component, stateProp) {
+    if (!component.hasAttribute(config.bindAttributeName)) {
+        return false;
+    }
+    const bindings = getBindingsByNode(component);
+    if (bindings === null) {
+        return false;
+    }
+    for (const binding of bindings) {
+        if (binding.propSegments.length === 1 && binding.propSegments[0] === stateProp) {
+            return true;
+        }
+    }
+    return false;
+}
+
 function getStateInfo(state) {
     const getterPaths = new Set();
     const setterPaths = new Set();
@@ -14690,6 +15937,11 @@ class State extends HTMLElementBase {
         }
         await this._loadingPromise;
         this._name = this.getAttribute('name') || 'default';
+        if (this.hasAttribute('name') && !this.hasAttribute('bind-component')) {
+            // 名前付き State は v2 でマウント（`mount=`）に置き換わる（docs/state-mount-design.md D16）。
+            // Light DOM の bind-component は今日 name が必須なので、そちらには言わない。
+            warnNamedStateDeprecated('attribute', this._name);
+        }
         setStateElementByName(this.rootNode, this._name, this);
     }
     async _initializeBindWebComponent() {
@@ -14725,6 +15977,11 @@ 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");
+            // 束ねる意思をここで宣言する（完了はずっと後）。丸ごとマウント `state: user` の
+            // 完了前の初期適用は、この宣言を見て書き込みを抑止する
+            // （webComponent/completeWebComponent.ts）。下の await より前でなければ、
+            // 親の初期適用が先に走って親のオブジェクトを state プロパティに書いてしまう。
+            markWebComponentStatePropDeclared(boundComponent, boundComponentStateProp);
             const componentRegistry = getCustomElementRegistry(boundComponent);
             if (componentRegistry === null) {
                 // null レジストリのサブツリーではホストは永久に upgrade されない。
@@ -14739,10 +15996,19 @@ class State extends HTMLElementBase {
             if (!(boundComponentStateProp in boundComponent)) {
                 raiseError(`Component does not have property "${boundComponentStateProp}" for state binding.`);
             }
-            const state = boundComponent[boundComponentStateProp];
+            let state = boundComponent[boundComponentStateProp];
             if (typeof state !== 'object' || state === null) {
                 raiseError(`Component property "${boundComponentStateProp}" is not an object for state binding.`);
             }
+            // 丸ごとマウント（`state: user`）の完了前の初期適用が、宣言より先に走って state
+            // プロパティを親のオブジェクトごと置き換えていたら、作者のオブジェクトに戻す
+            // （webComponent/preCompletionWrites.ts）。戻さないと親のキー全部が own data key に
+            // なり、R1 で全部が私有に化ける。
+            const authored = takeOverwrittenObject(boundComponent, boundComponentStateProp);
+            if (typeof authored !== 'undefined' && hasRootMountBinding(boundComponent, boundComponentStateProp)) {
+                boundComponent[boundComponentStateProp] = authored;
+                state = authored;
+            }
             this._boundComponent = boundComponent;
             this._boundComponentStateProp = boundComponentStateProp;
             bindWebComponent(this, this._boundComponent, this._boundComponentStateProp, state);
@@ -14799,11 +16065,17 @@ class State extends HTMLElementBase {
         }
         // mapped ＝ プライマリ規則が 1 件以上あることと同義（bindWebComponent の分岐）
         const innerPaths = getPrimaryInnerPaths(this._boundComponent);
+        // ルート規則（丸ごとマウント）は内側パスが空なので、子の登録済みパス全部を読み直す
+        // （webComponent/rootReloadPaths.ts）
+        const rootPaths = hasRootMappingRule(this._boundComponent) ? getRootReloadPaths(this) : [];
         resetDerivedMappingRules(this._boundComponent);
         this.createState("readonly", (state) => {
             for (const path of innerPaths) {
                 state.$postUpdate(path);
             }
+            for (const path of rootPaths) {
+                state.$postUpdate(path);
+            }
         });
     }
     async _callStateConnectedCallback() {
@@ -14896,8 +16168,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';
@@ -15044,6 +16320,9 @@ class State extends HTMLElementBase {
     get hasMappedComponentState() {
         return this._hasMappedComponentState;
     }
+    get boundPaths() {
+        return this._pathSet;
+    }
     /**
      * この state の実体が innerState proxy であることを記録する。唯一の呼び手は
      * `bindWebComponent` の mapped 分岐（§1.8）。
@@ -15199,11 +16478,63 @@ function registerComponents(registry = customElements) {
     }
 }
 
+/**
+ * `<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) {
-    if (config) {
-        setConfig(config);
+    const resolved = resolveConfig(config);
+    if (resolved) {
+        setConfig(resolved);
     }
     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();
 }