@wcstack/state 1.17.0 → 1.19.0

package/dist/index.esm.js

@@ -63,7 +63,7 @@ function setConfig(partialConfig) {
     }
 }
 
-var version$1 = "1.17.0";
+var version$1 = "1.19.0";
 var pkg = {
 	version: version$1};
 
@@ -150,6 +150,9 @@ const STATE_COMMAND_TOKENS_NAME = "$commandTokens";
 const STATE_COMMAND_NAMESPACE_NAME = "$command";
 const STATE_EVENT_TOKENS_NAME = "$eventTokens";
 const STATE_ON_NAME = "$on";
+const STATE_STREAMS_NAME = "$streams";
+const STATE_STREAM_STATUS_NAMESPACE_NAME = "$streamStatus";
+const STATE_STREAM_ERROR_NAMESPACE_NAME = "$streamError";
 const DCC_DEFINITION_ATTRIBUTE = "data-wc-definition";
 
 const _cache$4 = new Map();
@@ -1843,13 +1846,62 @@ const connectedCallbackSymbol = Symbol("$$connectedCallback");
 const disconnectedCallbackSymbol = Symbol("$$disconnectedCallback");
 const updatedCallbackSymbol = Symbol("$$updatedCallback");
 
+function createHandlerBindingRegistry() {
+    const attachedByKey = new Map();
+    const countByKey = new Map();
+    return {
+        add(key, binding) {
+            let attached = attachedByKey.get(key);
+            if (typeof attached === "undefined") {
+                attached = new WeakSet();
+                attachedByKey.set(key, attached);
+            }
+            if (attached.has(binding)) {
+                return false;
+            }
+            attached.add(binding);
+            countByKey.set(key, (countByKey.get(key) ?? 0) + 1);
+            return true;
+        },
+        remove(key, binding) {
+            const attached = attachedByKey.get(key);
+            if (typeof attached === "undefined" || !attached.has(binding)) {
+                return false;
+            }
+            attached.delete(binding);
+            const next = (countByKey.get(key) ?? 1) - 1;
+            if (next <= 0) {
+                attachedByKey.delete(key);
+                countByKey.delete(key);
+                return true;
+            }
+            countByKey.set(key, next);
+            return false;
+        },
+        has(key, binding) {
+            return attachedByKey.get(key)?.has(binding) ?? false;
+        },
+        countOf(key) {
+            return countByKey.get(key) ?? 0;
+        },
+        get keyCount() {
+            return countByKey.size;
+        },
+        clear() {
+            attachedByKey.clear();
+            countByKey.clear();
+        },
+    };
+}
+
 // onclick: $command.<name> のように、DOM イベントから command token を直接 emit する形式かを判定する。
 // 右辺が $command 名前空間配下のパス（$command.<token>）のときに true。
 function isCommandTokenPath(statePathName) {
     return statePathName.startsWith(STATE_COMMAND_NAMESPACE_NAME + ".");
 }
 const handlerByHandlerKey$3 = new Map();
-const bindingSetByHandlerKey$3 = new Map();
+// binding を強参照しない台帳（handlerBindingRegistry.ts のリーク解説を参照）
+const bindingRegistry$3 = createHandlerBindingRegistry();
 function getHandlerKey$3(binding) {
     const modifierKey = binding.propModifiers.filter(m => m === 'prevent' || m === 'stop').sort().join(',');
     return `${binding.stateName}::${binding.statePathName}::${modifierKey}`;
@@ -1898,14 +1950,7 @@ function attachEventHandler(binding) {
     }
     const eventName = binding.propName.slice(2);
     binding.node.addEventListener(eventName, stateEventHandler);
-    let bindingSet = bindingSetByHandlerKey$3.get(key);
-    if (typeof bindingSet === "undefined") {
-        bindingSet = new Set([binding]);
-        bindingSetByHandlerKey$3.set(key, bindingSet);
-    }
-    else {
-        bindingSet.add(binding);
-    }
+    bindingRegistry$3.add(key, binding);
     return true;
 }
 
@@ -1914,12 +1959,12 @@ function attachEventHandler(binding) {
 class EventToken extends Token {
 }
 
-const registryByStateElement$1 = new WeakMap();
+const registryByStateElement$2 = new WeakMap();
 function getOrCreateEventToken(stateElement, name) {
-    let registry = registryByStateElement$1.get(stateElement);
+    let registry = registryByStateElement$2.get(stateElement);
     if (typeof registry === "undefined") {
         registry = new Map();
-        registryByStateElement$1.set(stateElement, registry);
+        registryByStateElement$2.set(stateElement, registry);
     }
     let token = registry.get(name);
     if (typeof token === "undefined") {
@@ -1929,7 +1974,7 @@ function getOrCreateEventToken(stateElement, name) {
     return token;
 }
 function clearEventTokenRegistry(stateElement) {
-    registryByStateElement$1.delete(stateElement);
+    registryByStateElement$2.delete(stateElement);
 }
 
 /**
@@ -2075,7 +2120,8 @@ function isPossibleTwoWay(node, propName) {
 }
 
 const handlerByHandlerKey$2 = new Map();
-const bindingSetByHandlerKey$2 = new Map();
+// binding を強参照しない台帳（handlerBindingRegistry.ts のリーク解説を参照）
+const bindingRegistry$2 = createHandlerBindingRegistry();
 const DEFAULT_GETTER = (e) => e.detail;
 function getHandlerKey$2(binding, eventName, hasGetter) {
     const filterKey = binding.inFilters.map(f => f.filterName + '(' + f.args.join(',') + ')').join('|');
@@ -2178,14 +2224,7 @@ function attachTwowayEventHandler(binding) {
             handlerByHandlerKey$2.set(key, twowayEventHandler);
         }
         binding.node.addEventListener(eventName, twowayEventHandler);
-        let bindingSet = bindingSetByHandlerKey$2.get(key);
-        if (typeof bindingSet === "undefined") {
-            bindingSet = new Set([binding]);
-            bindingSetByHandlerKey$2.set(key, bindingSet);
-        }
-        else {
-            bindingSet.add(binding);
-        }
+        bindingRegistry$2.add(key, binding);
     }
 }
 
@@ -2890,6 +2929,103 @@ function calcDiffIndexes(oldList, newList, oldIndexes, newIndexes, indexByValue)
     };
 }
 
+/**
+ * Indices into `seq` whose values form a longest strictly-increasing
+ * subsequence, returned in ascending order. Classic patience-sorting
+ * LIS in O(n log n). `seq` values are assumed distinct (old list
+ * positions are unique).
+ */
+function longestIncreasingSubsequence(seq) {
+    const n = seq.length;
+    // tails[k] = index into seq of the smallest tail of an increasing
+    // subsequence of length k+1; prev[i] = predecessor index to rebuild the chain.
+    const tails = [];
+    const prev = new Array(n).fill(-1);
+    for (let i = 0; i < n; i++) {
+        const value = seq[i];
+        let lo = 0;
+        let hi = tails.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (seq[tails[mid]] < value) {
+                lo = mid + 1;
+            }
+            else {
+                hi = mid;
+            }
+        }
+        if (lo > 0) {
+            prev[i] = tails[lo - 1];
+        }
+        tails[lo] = i;
+    }
+    const result = [];
+    let k = tails.length > 0 ? tails[tails.length - 1] : -1;
+    while (k >= 0) {
+        result.push(k);
+        k = prev[k];
+    }
+    result.reverse();
+    return result;
+}
+/**
+ * Determines which reused list indexes can stay where they are when the DOM
+ * is brought into the new list order.
+ *
+ * Returns null when the reused indexes already appear in their old relative
+ * order (no inversions) — the caller's existing position guard then performs
+ * no moves, so nothing extra is needed. When inversions exist, returns the
+ * set of indexes forming a longest increasing subsequence of old positions:
+ * leaving exactly those in place and moving every other content yields the
+ * correct final order with the fewest content moves (the naive forward walk
+ * otherwise cascades: a single swap of rows 2/999 in 1000 rows moves ~997
+ * contents instead of 2).
+ *
+ * Note: IListIndex.index is already mutated to the NEW position by
+ * createListDiff, so old positions must come from the oldIndexes array order.
+ */
+function computeStableIndexSet(diff) {
+    // No reused index changed position, or nothing was reused: relative order
+    // is already correct and the walk performs no moves.
+    if (diff.changeIndexSet.size === 0 || diff.addIndexSet.size === diff.newIndexes.length) {
+        return null;
+    }
+    const oldPosByIndex = new Map();
+    for (let i = 0; i < diff.oldIndexes.length; i++) {
+        oldPosByIndex.set(diff.oldIndexes[i], i);
+    }
+    const reused = [];
+    const seq = [];
+    let prevPos = -1;
+    let sorted = true;
+    for (const index of diff.newIndexes) {
+        if (diff.addIndexSet.has(index)) {
+            continue;
+        }
+        const pos = oldPosByIndex.get(index);
+        if (pos === undefined) {
+            // Invariant break (a reused index missing from oldIndexes): fall back
+            // to the settle walk rather than compute a stable set from bad data.
+            return null;
+        }
+        if (pos < prevPos) {
+            sorted = false;
+        }
+        prevPos = pos;
+        reused.push(index);
+        seq.push(pos);
+    }
+    if (sorted) {
+        return null;
+    }
+    const lis = longestIncreasingSubsequence(seq);
+    const stable = new Set();
+    for (const seqIndex of lis) {
+        stable.add(reused[seqIndex]);
+    }
+    return stable;
+}
+
 const bindingSetByAbsoluteStateAddress = new WeakMap();
 function getBindingSetByAbsoluteStateAddress(absoluteStateAddress) {
     let bindingSet = null;
@@ -2900,38 +3036,24 @@ function getBindingSetByAbsoluteStateAddress(absoluteStateAddress) {
     }
     return bindingSet;
 }
+/**
+ * 参照専用の取得。get-or-create と違い、未登録アドレスに空 Set を
+ * 生成・キャッシュしない（リスト置換の drain は大量のバインディング無し
+ * アドレスを照会するため、生成すると空 Set が溜まり続ける）。
+ */
+function peekBindingSetByAbsoluteStateAddress(absoluteStateAddress) {
+    return bindingSetByAbsoluteStateAddress.get(absoluteStateAddress);
+}
 function addBindingByAbsoluteStateAddress(absoluteStateAddress, binding) {
     const bindingSet = getBindingSetByAbsoluteStateAddress(absoluteStateAddress);
     bindingSet.add(binding);
 }
 function removeBindingByAbsoluteStateAddress(absoluteStateAddress, binding) {
-    const bindingSet = getBindingSetByAbsoluteStateAddress(absoluteStateAddress);
-    bindingSet.delete(binding);
-}
-
-const stateAddressByBindingInfo = new WeakMap();
-function getStateAddressByBindingInfo(bindingInfo) {
-    let stateAddress = null;
-    stateAddress = stateAddressByBindingInfo.get(bindingInfo) || null;
-    if (stateAddress !== null) {
-        return stateAddress;
-    }
-    if (bindingInfo.statePathInfo.wildcardCount > 0) {
-        const listIndex = getListIndexByBindingInfo(bindingInfo);
-        if (listIndex === null) {
-            raiseError(`Cannot resolve state address for binding with wildcard statePathName "${bindingInfo.statePathName}" because list index is null.`);
-        }
-        stateAddress = createStateAddress(bindingInfo.statePathInfo, listIndex);
-    }
-    else {
-        stateAddress = createStateAddress(bindingInfo.statePathInfo, null);
+    // get-or-create を通すと未登録アドレスに空 Set を生成してしまうため素の get で参照する
+    const bindingSet = bindingSetByAbsoluteStateAddress.get(absoluteStateAddress);
+    if (bindingSet !== undefined) {
+        bindingSet.delete(binding);
     }
-    stateAddressByBindingInfo.set(bindingInfo, stateAddress);
-    return stateAddress;
-}
-// call for change loopContext
-function clearStateAddressByBindingInfo(bindingInfo) {
-    stateAddressByBindingInfo.delete(bindingInfo);
 }
 
 const bindingsByContent = new WeakMap();
@@ -2980,8 +3102,10 @@ function deactivateContent(content) {
     for (const binding of bindings) {
         const absoluteStateAddress = getAbsoluteStateAddressByBinding(binding);
         removeBindingByAbsoluteStateAddress(absoluteStateAddress, binding);
-        clearAbsoluteStateAddressByBinding(binding);
-        clearStateAddressByBindingInfo(binding);
+        // アドレスキャッシュ（absoluteStateAddressByBinding / stateAddressByBindingInfo）
+        // のクリアはここでは行わない。deactivateContent の呼び出し元（for/if）は必ず
+        // 直後に content.unmount() を呼び、unmount が同じ2台帳をネスト content も含めて
+        // クリアする（createContent.ts）。ここで消すと全 binding で二重 delete になる。
     }
     unbindLoopContextToContent(content);
 }
@@ -3008,6 +3132,40 @@ function getContentSetByNode(node) {
     }
     return EMPTY_SET;
 }
+function deleteContentByNode(node, content) {
+    const contents = contentSetByNode.get(node);
+    if (contents) {
+        contents.delete(content);
+        if (contents.size === 0) {
+            contentSetByNode.delete(node);
+        }
+    }
+}
+
+const stateAddressByBindingInfo = new WeakMap();
+function getStateAddressByBindingInfo(bindingInfo) {
+    let stateAddress = null;
+    stateAddress = stateAddressByBindingInfo.get(bindingInfo) || null;
+    if (stateAddress !== null) {
+        return stateAddress;
+    }
+    if (bindingInfo.statePathInfo.wildcardCount > 0) {
+        const listIndex = getListIndexByBindingInfo(bindingInfo);
+        if (listIndex === null) {
+            raiseError(`Cannot resolve state address for binding with wildcard statePathName "${bindingInfo.statePathName}" because list index is null.`);
+        }
+        stateAddress = createStateAddress(bindingInfo.statePathInfo, listIndex);
+    }
+    else {
+        stateAddress = createStateAddress(bindingInfo.statePathInfo, null);
+    }
+    stateAddressByBindingInfo.set(bindingInfo, stateAddress);
+    return stateAddress;
+}
+// call for change loopContext
+function clearStateAddressByBindingInfo(bindingInfo) {
+    stateAddressByBindingInfo.delete(bindingInfo);
+}
 
 const recursiveBindingTypes = new Set(['if', 'elseif', 'else', 'for']);
 class Content {
@@ -3120,14 +3278,27 @@ function hydrateSetLastNode(node, lastNode) {
 function getPooledContents(bindingInfo) {
     return pooledContentsByNode.get(bindingInfo.node) || [];
 }
+// プールの上限（アンカーごと）。プールはアンカー（文書に永続するコメントノード）
+// から content とその DOM サブツリー・バインディング群を強参照するため、無制限だと
+// 大きなリストのクリア後もメモリが解放されない（10k 行で 10MB 級）。上限超過分は
+// contentSetByNode の台帳からも外して GC 可能にする。再追加時は createContent で
+// 作り直すコストと引き換えになる。
+const MAX_POOLED_CONTENTS = 1000;
+let maxPooledContents = MAX_POOLED_CONTENTS;
 function setPooledContent(bindingInfo, content) {
-    const contents = pooledContentsByNode.get(bindingInfo.node);
+    let contents = pooledContentsByNode.get(bindingInfo.node);
     if (typeof contents === 'undefined') {
-        pooledContentsByNode.set(bindingInfo.node, [content]);
+        contents = [];
+        pooledContentsByNode.set(bindingInfo.node, contents);
     }
-    else {
+    if (contents.length < maxPooledContents) {
         contents.push(content);
     }
+    else {
+        // 上限超過: content を完全に手放す。contentSetByNode は createContent 時に
+        // 追加されたきり解放経路が無いため、ここで外さないと GC できない。
+        deleteContentByNode(bindingInfo.node, content);
+    }
 }
 function isOnlyNodeInParentContent(firstNode, lastNode) {
     let prevCheckNode = firstNode.previousSibling;
@@ -3151,6 +3322,23 @@ function isOnlyNodeInParentContent(firstNode, lastNode) {
     }
     return onlyNode;
 }
+// A stable content may be left in place only when its first node verifiably
+// follows the settled walk position in the same tree: the listIndexes ledger
+// can lag the physical DOM (element-write swaps reorder listIndexes without
+// moving nodes; hidden regions unmount contents that stay registered). Empty
+// contents (null firstNode) always take the settle walk so their mount
+// bookkeeping matches the pre-LIS behavior.
+function isPhysicallyAfter(lastNode, firstNode) {
+    if (firstNode === null) {
+        return false;
+    }
+    if (lastNode.nextSibling === firstNode) {
+        return true;
+    }
+    const position = lastNode.compareDocumentPosition(firstNode);
+    return (position & Node.DOCUMENT_POSITION_FOLLOWING) !== 0
+        && (position & Node.DOCUMENT_POSITION_DISCONNECTED) === 0;
+}
 function getContent(node, listIndex) {
     let contentByListIndex = contentByListIndexByNode.get(node);
     if (typeof contentByListIndex === 'undefined') {
@@ -3210,6 +3398,11 @@ function applyChangeToFor(bindingInfo, context, newValue) {
     let lastNode = bindingInfo.node;
     const elementPathInfo = getPathInfo(listPathInfo.path + '.' + WILDCARD);
     const loopContextStack = context.stateElement.loopContextStack;
+    // When the new order contains inversions, contents in the stable set (an LIS
+    // of old positions) keep their relative order and must not be moved; moving
+    // only the rest avoids the cascade where one swap relocates every row in
+    // between. null = no inversions; the position guard below then does no moves.
+    const stableIndexSet = computeStableIndexSet(diff);
     let fragment = null;
     if (diff.newIndexes.length == diff.addIndexSet.size
         && diff.newIndexes.length > 0
@@ -3279,7 +3472,13 @@ function applyChangeToFor(bindingInfo, context, newValue) {
             if (content === null) {
                 raiseError(`Content not found for ListIndex: ${index.index} at path "${listPathInfo.path}"`);
             }
-            if (lastNode.nextSibling !== content.firstNode) {
+            // Stable contents are already in correct relative order — but only
+            // trust that after physical verification (see isPhysicallyAfter).
+            // Contents out of order (and everything unverifiable) settle via the
+            // self-healing mountAfter walk below.
+            const stable = stableIndexSet !== null && stableIndexSet.has(index)
+                && isPhysicallyAfter(lastNode, content.firstNode);
+            if (!stable && lastNode.nextSibling !== content.firstNode) {
                 content.mountAfter(lastNode);
             }
         }
@@ -3608,8 +3807,14 @@ function applyChangeToStyle(binding, _context, newValue) {
 
 const ssrWrappedNodes = new WeakSet();
 function applyChangeToText(binding, _context, newValue) {
-    if (binding.replaceNode.nodeValue !== newValue) {
-        binding.replaceNode.nodeValue = newValue;
+    // nodeValue は nullable DOMString（実ブラウザでは null / undefined とも空文字に
+    // 正規化される）ため、比較前に同じ規則で文字列化する。生値のまま比較すると
+    // 数値など非文字列値は常に不一致になり、同値でも毎回 DOM 書き込みが走る。
+    // 注: happy-dom は undefined を "undefined" にする非準拠実装なので String() に
+    // 頼らず明示的に "" へ正規化する。
+    const text = newValue === null || newValue === undefined ? "" : String(newValue);
+    if (binding.replaceNode.nodeValue !== text) {
+        binding.replaceNode.nodeValue = text;
     }
     // SSR モード時: テキストノードの前後にコメントを挿入して境界を明示
     if (inSsr() && !ssrWrappedNodes.has(binding.replaceNode)) {
@@ -3669,6 +3874,37 @@ function getValue(state, binding) {
     }
 }
 
+// applyChange が「未 define のカスタム要素」への適用を見送った binding の台帳。
+// define されるまでの間、同じ binding に対して applyChange は（state 更新の
+// たびに）何度も呼ばれうるため、whenDefined の多重登録をここで抑止する。
+// WeakSet なので binding の寿命に追従し、恒久 define されないタグでもリークしない。
+const scheduledBindings = new WeakSet();
+/**
+ * 未 define のカスタム要素に対する適用を customElements.whenDefined 後に再実行
+ * する。two-way / event-token の attach、spread の deferred 展開はいずれも
+ * whenDefined で再試行するのに対し、値の適用だけが片道 skip だった非対称の解消
+ * （docs/state-binding-init-races.md §2）。
+ *
+ * 再適用は applyChangeFromBindings を通すため、define 時点の最新 state 値で
+ * 適用される（skip 時点の値を保持しない）。define を待つ間に DOM から外れた
+ * binding には適用しない（deferred spread と同じ規約）。
+ */
+function scheduleDeferredApply(binding, tagName) {
+    if (scheduledBindings.has(binding)) {
+        return;
+    }
+    scheduledBindings.add(binding);
+    customElements.whenDefined(tagName).then(() => {
+        scheduledBindings.delete(binding);
+        if (!binding.replaceNode.isConnected) {
+            return; // define を待つ間にノードが削除された
+        }
+        applyChangeFromBindings([binding]);
+    }).catch((error) => {
+        console.error(`[@wcstack/state] deferred apply failed for <${tagName}>.`, error);
+    });
+}
+
 const applyChangeByFirstSegment = {
     "class": applyChangeToClass,
     "attr": applyChangeToAttribute,
@@ -3749,15 +3985,20 @@ function applyChange(binding, context) {
         return;
     }
     context.appliedBindingSet.add(binding);
-    const absAddress = getAbsoluteStateAddressByBinding(binding);
-    if (context.updatedAbsAddressSetByStateElement.has(context.stateElement)) {
-        const addressSet = context.updatedAbsAddressSetByStateElement.get(context.stateElement);
-        addressSet.add(absAddress);
-    }
-    else {
-        context.updatedAbsAddressSetByStateElement.set(context.stateElement, new Set([
-            absAddress
-        ]));
+    // $updatedCallback が定義されていない state では、更新アドレスの集計自体が
+    // 不要（drain 終端の呼び出しごと省略される）。大量バインディング適用時の
+    // Set 蓄積を避ける。undefined（テスト用モック等）は従来通り集計する。
+    if (context.stateElement.hasUpdatedCallback !== false) {
+        const absAddress = getAbsoluteStateAddressByBinding(binding);
+        if (context.updatedAbsAddressSetByStateElement.has(context.stateElement)) {
+            const addressSet = context.updatedAbsAddressSetByStateElement.get(context.stateElement);
+            addressSet.add(absAddress);
+        }
+        else {
+            context.updatedAbsAddressSetByStateElement.set(context.stateElement, new Set([
+                absAddress
+            ]));
+        }
     }
     if (binding.bindingType === "event") {
         return;
@@ -3765,10 +4006,22 @@ function applyChange(binding, context) {
     const customTag = getCustomElement(binding.replaceNode);
     if (customTag) {
         if (customElements.get(customTag) === undefined) {
-            // cutomElement側の初期化を期待
+            // 未 define のカスタム要素へは今は適用できない（accessor 未確立の要素に
+            // 素の own property を書くと upgrade 後に class accessor を隠してしまう）。
+            // whenDefined 後に最新 state 値で再適用する（two-way attach / deferred
+            // spread と対称。docs/state-binding-init-races.md §2）。
+            scheduleDeferredApply(binding, customTag);
             return;
         }
     }
+    // applyChangeFromBindings のグループ化ループが解決済みルートの一致を検証済みの
+    // 場合、stateName さえ一致すれば getRootNode の再解決（native 呼び出し）を省略
+    // できる。activateContent 経由（フラグメント内の新規 content）も、フラグメントは
+    // setRootNodeByFragment で context.rootNode に解決されるため同じ不変条件が成り立つ。
+    if (context.sameRootVerified === true && binding.stateName === context.stateName) {
+        _applyChange(binding, context);
+        return;
+    }
     let rootNode = binding.replaceNode.getRootNode();
     if (rootNode instanceof DocumentFragment && !(rootNode instanceof ShadowRoot)) {
         rootNode = getRootNodeByFragment(rootNode);
@@ -3849,6 +4102,9 @@ function applyChangeFromBindings(bindings) {
                 newListValueByAbsAddress: newListValueByAbsAddress,
                 updatedAbsAddressSetByStateElement: updatedAbsAddressSetByStateElement,
                 deferredSelectBindings: deferredSelectBindings,
+                // グループ内の binding は下の do/while が「解決済みルート === rootNode」を
+                // 検証してから applyChange に渡す（applyChange 側の getRootNode 省略の根拠）
+                sameRootVerified: true,
             };
             do {
                 applyChange(binding, context);
@@ -3879,7 +4135,8 @@ function applyChangeFromBindings(bindings) {
 }
 
 const handlerByHandlerKey$1 = new Map();
-const bindingSetByHandlerKey$1 = new Map();
+// binding を強参照しない台帳（handlerBindingRegistry.ts のリーク解説を参照）
+const bindingRegistry$1 = createHandlerBindingRegistry();
 function getHandlerKey$1(binding, eventName) {
     const filterKey = binding.inFilters.map(f => f.filterName + '(' + f.args.join(',') + ')').join('|');
     return `${binding.stateName}::${binding.statePathName}::${eventName}::${filterKey}`;
@@ -3933,21 +4190,15 @@ function attachRadioEventHandler(binding) {
             handlerByHandlerKey$1.set(key, radioEventHandler);
         }
         binding.node.addEventListener(eventName, radioEventHandler);
-        let bindingSet = bindingSetByHandlerKey$1.get(key);
-        if (typeof bindingSet === "undefined") {
-            bindingSet = new Set([binding]);
-            bindingSetByHandlerKey$1.set(key, bindingSet);
-        }
-        else {
-            bindingSet.add(binding);
-        }
+        bindingRegistry$1.add(key, binding);
         return true;
     }
     return false;
 }
 
 const handlerByHandlerKey = new Map();
-const bindingSetByHandlerKey = new Map();
+// binding を強参照しない台帳（handlerBindingRegistry.ts のリーク解説を参照）
+const bindingRegistry = createHandlerBindingRegistry();
 function getHandlerKey(binding, eventName) {
     const filterKey = binding.inFilters.map(f => f.filterName + '(' + f.args.join(',') + ')').join('|');
     return `${binding.stateName}::${binding.statePathName}::${eventName}::${filterKey}`;
@@ -4020,14 +4271,7 @@ function attachCheckboxEventHandler(binding) {
             handlerByHandlerKey.set(key, checkboxEventHandler);
         }
         binding.node.addEventListener(eventName, checkboxEventHandler);
-        let bindingSet = bindingSetByHandlerKey.get(key);
-        if (typeof bindingSet === "undefined") {
-            bindingSet = new Set([binding]);
-            bindingSetByHandlerKey.set(key, bindingSet);
-        }
-        else {
-            bindingSet.add(binding);
-        }
+        bindingRegistry.add(key, binding);
         return true;
     }
     return false;
@@ -5486,12 +5730,12 @@ function processCommandTokensDeclaration(state) {
     return names;
 }
 
-const registryByStateElement = new WeakMap();
+const registryByStateElement$1 = new WeakMap();
 function getOrCreateCommandToken(stateElement, name) {
-    let registry = registryByStateElement.get(stateElement);
+    let registry = registryByStateElement$1.get(stateElement);
     if (typeof registry === "undefined") {
         registry = new Map();
-        registryByStateElement.set(stateElement, registry);
+        registryByStateElement$1.set(stateElement, registry);
     }
     let token = registry.get(name);
     if (typeof token === "undefined") {
@@ -5501,7 +5745,7 @@ function getOrCreateCommandToken(stateElement, name) {
     return token;
 }
 function clearCommandTokenRegistry(stateElement) {
-    registryByStateElement.delete(stateElement);
+    registryByStateElement$1.delete(stateElement);
 }
 
 /**
@@ -5623,95 +5867,1005 @@ function processOnDeclaration(stateElement, state, eventTokenNames) {
     }
 }
 
-function getterFn(name) {
-    return function () {
-        const stateEl = this.stateElement;
-        if (!stateEl)
-            return undefined;
-        let value;
-        try {
-            stateEl.createState("readonly", (state) => {
-                value = state[name];
-            });
-        }
-        catch (e) {
-            console.warn(`[@wcstack/state] DCC getter "${name}" failed:`, e);
-            return undefined;
-        }
-        return value;
-    };
-}
-function setterFn(name) {
-    return function (value) {
-        const stateEl = this.stateElement;
-        if (!stateEl)
-            return;
-        stateEl.initializePromise.then(() => {
-            stateEl.createState("writable", (state) => {
-                state[name] = value;
-            });
-        });
-    };
+/**
+ * stream/lastNotified.ts
+ *
+ * 「最後に通知した観測値」台帳 — DOM binding / $updatedCallback（観測層）が
+ * 最後に見た status・error（docs/state-streams-design.md §4-3）。
+ *
+ * 通知の same-value 判定を entry フィールドとの比較で行うと、再 set
+ * （clearStreamRegistry → 新 entry 生成）を跨いだ陳腐化を検出できない
+ * （error 表示中に再 set すると新 entry は error=null で生まれるため
+ * null → null と誤判定して $postUpdate が落ち、DOM に旧 error が残る）。
+ * そのため通知 dedup は entry の寿命ではなく stateElement の寿命で持つ
+ * （ただし再 set で新宣言から消えた名前のエントリは pruneLastNotified で削除する —
+ *  同名にしか dedup は要らず、放置すると台帳が単調増加するため）。
+ * 未通知（初回）の基準値は宣言直後の観測初期値と同じ { idle, null }。
+ *
+ * さらに abortAllStreams（§5-1）は registry entry を通知なしで idle / null に
+ * 直接ミューテーションするため、観測層が「台帳の値」と「idle / null」の
+ * どちらを見たか確定できなくなる（binding / computed の fresh 読みは通知が
+ * なくても他パスの drain で走る）。その乖離フィールドは invalidateLastNotified
+ * で UNCERTAIN に無効化し、次回 updateStreamStatus の同値判定が必ず
+ * 「変化あり」になるようにする（再接続ウィンドウ内の idle 描画が恒久陳腐化
+ * しないための不変条件、§4-3）。
+ */
+/**
+ * 無通知ミューテーション後の「観測値が確定できない」印。
+ * どの実値とも一致しないため、次回の通知 dedup（`!==` / `Object.is`）を強制的に解除する。
+ */
+const UNCERTAIN = Symbol("wcs-stream-last-notified-uncertain");
+const lastNotifiedByStateElement = new WeakMap();
+/**
+ * 最後に通知した観測値を返す。未通知なら基準値 { idle, null }。
+ */
+function getLastNotified(stateElement, name) {
+    return (lastNotifiedByStateElement.get(stateElement)?.get(name) ?? { status: "idle", error: null });
 }
-function callFn(name, isAsync) {
-    if (isAsync) {
-        return function (...args) {
-            const stateEl = this.stateElement;
-            if (!stateEl)
-                return undefined;
-            return stateEl.initializePromise.then(() => {
-                let result;
-                return stateEl.createStateAsync("writable", async (state) => {
-                    result = await state[name](...args);
-                }).then(() => result);
-            });
-        };
+/**
+ * 通知した観測値を記録する（updateStreamStatus が $postUpdate 発行と同時に呼ぶ）。
+ */
+function setLastNotified(stateElement, name, status, error) {
+    let lastMap = lastNotifiedByStateElement.get(stateElement);
+    if (typeof lastMap === "undefined") {
+        lastMap = new Map();
+        lastNotifiedByStateElement.set(stateElement, lastMap);
     }
-    return function (...args) {
-        const stateEl = this.stateElement;
-        if (!stateEl)
-            return undefined;
-        return stateEl.initializePromise.then(() => {
-            let result;
-            stateEl.createState("writable", (state) => {
-                result = state[name](...args);
-            });
-            return result;
-        });
-    };
-}
-function isInternalProperty(name) {
-    return name.startsWith("$");
-}
-
-function createWcBindable(tagName, bindables) {
-    const properties = bindables.map((propName) => ({
-        name: propName,
-        event: `${tagName}:${propName}-changed`,
-    }));
-    return {
-        protocol: "wc-bindable",
-        version: 1,
-        properties,
-    };
+    lastMap.set(name, { status, error });
 }
-function createBindableEventMap(tagName, bindables) {
-    const map = {};
-    for (const propName of bindables) {
-        map[propName] = `${tagName}:${propName}-changed`;
+/**
+ * 再 set（clearStreamRegistry → processStreamsDeclaration）後に呼び、新宣言に
+ * 存在しない名前の台帳エントリを削除する。台帳は stateElement の寿命で生存するが
+ * （§4-3 の再 set・再接続跨ぎ dedup）、それが必要なのは同名エントリのみで、
+ * 旧宣言にしか無い名前は以後どの通知経路（updateStreamStatus）からも参照されない。
+ * prune しないと、再 set のたびに異なる stream 名を使うステートで台帳が
+ * stateElement の寿命の間単調増加する。
+ * 既知の許容: prune 後に同名を再宣言した場合、dedup は基準値 { idle, null } から
+ * やり直しになる（宣言削除時の binding 陳腐化が §4-4 の既知エッジである以上、
+ * 再宣言は新規宣言と同じ扱いでよい）。
+ */
+function pruneLastNotified(stateElement, liveNames) {
+    const lastMap = lastNotifiedByStateElement.get(stateElement);
+    if (typeof lastMap === "undefined") {
+        return;
+    }
+    for (const name of lastMap.keys()) {
+        if (!liveNames.has(name)) {
+            lastMap.delete(name);
+        }
     }
-    return map;
 }
-
-function defineDCC(hostElement, shadowRoot, state) {
-    const tagName = hostElement.tagName.toLowerCase();
-    // バリデーション
-    if (!tagName.includes("-")) {
-        raiseError(`DCC: "${tagName}" is not a valid custom element name (must contain a hyphen).`);
+/**
+ * 無通知ミューテーション（abortAllStreams の idle / null 直接書き換え）の直後に呼び、
+ * 台帳のうちミューテーション後の値と一致しないフィールドを UNCERTAIN に無効化する。
+ * 一致しているフィールド（観測層がどちらを見ても同じ値）は dedup を維持する
+ * （例: error が null のままなら再接続時に $streamError.<name> の余計な通知は出ない）。
+ */
+function invalidateLastNotified(stateElement, name) {
+    const lastMap = lastNotifiedByStateElement.get(stateElement);
+    if (typeof lastMap === "undefined") {
+        return;
     }
-    if (customElements.get(tagName)) {
-        // 既に登録済みならスキップ（重複定義の検知のため警告は出す）
-        console.warn(`[@wcstack/state] DCC: "${tagName}" is already registered. Skipping redefinition.`);
+    const last = lastMap.get(name);
+    if (typeof last === "undefined") {
+        // 未通知: 基準値 { idle, null } はミューテーション後の値と一致するため乖離しない
+        return;
+    }
+    lastMap.set(name, {
+        status: last.status === "idle" ? last.status : UNCERTAIN,
+        error: Object.is(last.error, null) ? null : UNCERTAIN,
+    });
+}
+
+/**
+ * stream/activeStateElements.ts
+ *
+ * 起動中（startStreams 済み・未切断）の stateElement の列挙用 Set
+ * （docs/state-streams-design.md §3-2）。
+ *
+ * streamRegistry の WeakMap は列挙不能のため、updater の drain リスナーが
+ * 「どの stateElement の entry と batch を交差させるか」を知るには
+ * 列挙可能な strong Set が別途必要になる。lastNotified.ts と同じ
+ * 「import 循環回避の小モジュール」パターン
+ * （streamRegistry → activeStateElements ← streamRuntime の一方向依存に保つ）。
+ *
+ * リーク防止の不変条件（strong Set が切断済み要素の GC を妨げないための連動）:
+ * - add は startStreams（streamRuntime.ts）だけが行う
+ *   （eager 起動＝connect 時、および接続中の `_state` 再 set 時の再起動）。
+ * - delete は abortAllStreams / clearStreamRegistry（streamRegistry.ts）が行う。
+ *   disconnect（disconnectedCallback → abortAllStreams）と `_state` 再 set
+ *   （clearStreamRegistry → processStreamsDeclaration → 接続中なら startStreams で
+ *   再 add）の両経路が必ずここを通るため、「Set に居る = 接続中かつ起動済み」が
+ *   常に保たれ、切断済み stateElement への強参照は残らない。
+ *   設計書 §3-2 の「未接続（disconnect 済み）の stateElement の entry は restart
+ *   しない」はこの不変条件で担保される。
+ */
+const activeStateElements = new Set();
+/**
+ * 起動中 stateElement として登録する（startStreams 専用。不変条件はモジュールヘッダ参照）。
+ */
+function addActiveStateElement(stateElement) {
+    activeStateElements.add(stateElement);
+}
+/**
+ * 起動中 stateElement から外す（abortAllStreams / clearStreamRegistry 専用）。
+ */
+function deleteActiveStateElement(stateElement) {
+    activeStateElements.delete(stateElement);
+}
+/**
+ * 起動中 stateElement を列挙する（drain リスナーの交差判定用）。
+ */
+function getActiveStateElements() {
+    return activeStateElements;
+}
+
+/**
+ * stream/streamRegistry.ts
+ *
+ * `$streams` の registry（docs/state-streams-design.md §2-1 / §5）。
+ * eventTokenRegistry と対称の WeakMap registry。
+ *
+ * - status / error の正本は registry entry（state オブジェクト上に実プロパティは持たない）。
+ * - disconnect 時は abortAllStreams（abort のみ・registry 保持）、
+ *   `_state` 再 set 時のみ clearStreamRegistry（abort ＋ 全削除）。
+ */
+const registryByStateElement = new WeakMap();
+/**
+ * stream entry 群を置換登録する（`_state` セッターからの再構築で丸ごと差し替える）。
+ */
+function setStreamEntries(stateElement, entries) {
+    registryByStateElement.set(stateElement, entries);
+}
+/**
+ * 登録済みの stream entry 群を返す。未登録なら空 Map を返す（registry への登録はしない）。
+ */
+function getStreamEntries(stateElement) {
+    return registryByStateElement.get(stateElement) ?? new Map();
+}
+/**
+ * 全 stream を abort して idle に戻す（設計書 §5-1）。registry は保持する。
+ *
+ * disconnectedCallback（切断時）に呼ばれるため、status / error の反映は
+ * proxy / $postUpdate を使わず entry への直接ミューテーションで行う
+ * （切断済みで binding 更新は不要かつ rootNode が無い）。
+ *
+ * 無通知ミューテーションは「最後に通知した観測値」台帳（stream/lastNotified.ts）
+ * と registry を乖離させるため、同時に台帳側を invalidate する。これを怠ると
+ * 再接続ウィンドウ内の fresh 読み（他パスの drain での getter 再計算など）が
+ * 描画した idle に対し、restart の updateStreamStatus("active") が切断前の
+ * 通知値と同値判定されて skip され、DOM が恒久的に陳腐化する（設計書 §4-3）。
+ */
+function abortAllStreams(stateElement) {
+    // 依存駆動 restart の対象から外す（切断済み stateElement は restart しない、
+    // 設計書 §3-2。add 側は startStreams — stream/activeStateElements.ts の
+    // リーク防止不変条件を参照）。registry の有無に関わらず必ず外す。
+    deleteActiveStateElement(stateElement);
+    const entries = registryByStateElement.get(stateElement);
+    if (typeof entries === "undefined") {
+        return;
+    }
+    for (const entry of entries.values()) {
+        entry.controller?.abort();
+        entry.controller = null;
+        entry.status = "idle";
+        entry.error = null;
+        invalidateLastNotified(stateElement, entry.name);
+    }
+}
+/**
+ * 全 stream を abort したうえで registry から削除する（`_state` 再 set 時の再配線用、設計書 §5-2）。
+ */
+function clearStreamRegistry(stateElement) {
+    abortAllStreams(stateElement);
+    // abortAllStreams が既に delete 済みだが、「clear = 全削除でも必ず restart 対象から
+    // 外れる」不変条件を将来の abortAllStreams の変更から独立に保証するため明示的に呼ぶ。
+    deleteActiveStateElement(stateElement);
+    registryByStateElement.delete(stateElement);
+}
+
+/**
+ * stream/processStreamsDeclaration.ts
+ *
+ * `$streams: { <name>: { args?, source, fold?, initial? } }` 宣言マップを解析し、
+ * IStreamEntry を構築して streamRegistry に一括登録する
+ * （docs/state-streams-design.md §1-1 / §1-2 / §1-3）。
+ *
+ * - バリデーション（§1-2）: 違反は raiseError。
+ *   - 名前はフラットなプロパティ名のみ（空文字 / `.`（DELIMITER）/ `*`（WILDCARD）/ 先頭 `$` を禁止）。
+ *   - Object.prototype の継承名（`__proto__` / `constructor` / `toString` 等）を禁止
+ *     （own key でなくても `in` 判定が真になり、実体化 skip ＋ 起動時 Reflect.set の
+ *      継承 setter 化 — `__proto__` は prototype 差し替え — を引き起こすため）。
+ *   - getter / setter として宣言済みのパスとの衝突を禁止（getterPaths / setterPaths を検査）。
+ *   - `source` は関数必須。`fold` は（あれば）関数。`fold` があるのに `initial` が無ければエラー
+ *     （reduce は initial 必須。`initial` の有無は in 演算子で判定）。`args` は（あれば）関数。
+ * - fold 省略時は latest（`(_acc, chunk) => chunk`）を注入する（§0 決定レコード）。
+ * - 値プロパティ実体化（§1-3）: `state[name]` が未定義なら `initial`
+ *   （fold 無しなら undefined）でデータプロパティとして初期化する。
+ *   ユーザーが同名プロパティを先に宣言していた場合は上書きしない
+ *   （起動時の initial リセットは streamRuntime 側の責務）。
+ * - 通知 dedup 台帳の prune（§4-3）: 新宣言に存在しない名前の lastNotified エントリを
+ *   削除する（台帳は stateElement 寿命 — 再 set 跨ぎ dedup が必要なのは同名のみ）。
+ *
+ * 呼び出しは stateElement.getterPaths / setterPaths の確定後であること
+ * （State の `_state` セッターが getStateInfo の反映より後に呼ぶことで保証する）。
+ */
+/** fold 省略時に注入される既定 fold（latest = 最新チャンクで置換） */
+const latestFold = (_acc, chunk) => chunk;
+/** `$streams` 無し宣言の prune 用（旧宣言の全名前が残骸になる） */
+const NO_STREAM_NAMES = new Set();
+function processStreamsDeclaration(stateElement, state) {
+    const declared = state[STATE_STREAMS_NAME];
+    if (typeof declared === "undefined") {
+        // $streams 無しの再 set でも旧宣言の名前は通知 dedup 台帳の残骸になるため prune する
+        pruneLastNotified(stateElement, NO_STREAM_NAMES);
+        return;
+    }
+    if (typeof declared !== "object" || declared === null) {
+        raiseError(`${STATE_STREAMS_NAME} must be an object mapping stream names to stream definitions.`);
+    }
+    const entries = new Map();
+    for (const [name, def] of Object.entries(declared)) {
+        if (name.length === 0) {
+            raiseError(`${STATE_STREAMS_NAME} entry name must be a non-empty string.`);
+        }
+        if (name.includes(DELIMITER)) {
+            raiseError(`${STATE_STREAMS_NAME} entry "${name}" must be a flat property name ("${DELIMITER}" is not allowed).`);
+        }
+        if (name.includes(WILDCARD)) {
+            raiseError(`${STATE_STREAMS_NAME} entry "${name}" must be a flat property name ("${WILDCARD}" is not allowed).`);
+        }
+        if (name.startsWith("$")) {
+            raiseError(`${STATE_STREAMS_NAME} entry "${name}" must not start with "$" (reserved namespace).`);
+        }
+        // Object.prototype の継承名（__proto__ / constructor / toString 等）は一律拒否する。
+        // own key でないのに `name in state` が真になるため実体化（§1-3）が skip され、
+        // 起動時の initial リセット（Reflect.set）が継承 setter に化ける
+        // （特に __proto__ は state の prototype を差し替える）ため、名前検査の防衛線で落とす（§1-2）。
+        if (name in Object.prototype) {
+            raiseError(`${STATE_STREAMS_NAME} entry "${name}" must not be a property name inherited from Object.prototype (e.g. "__proto__", "constructor").`);
+        }
+        if (stateElement.getterPaths.has(name)) {
+            raiseError(`${STATE_STREAMS_NAME} entry "${name}" conflicts with a getter declared on the state.`);
+        }
+        if (stateElement.setterPaths.has(name)) {
+            raiseError(`${STATE_STREAMS_NAME} entry "${name}" conflicts with a setter declared on the state.`);
+        }
+        if (typeof def !== "object" || def === null) {
+            raiseError(`${STATE_STREAMS_NAME} entry "${name}" must be an object ({ args?, source, fold?, initial? }).`);
+        }
+        const definition = def;
+        if (typeof definition.source !== "function") {
+            raiseError(`${STATE_STREAMS_NAME} entry "${name}" source must be a function.`);
+        }
+        const hasFold = typeof definition.fold !== "undefined";
+        if (hasFold && typeof definition.fold !== "function") {
+            raiseError(`${STATE_STREAMS_NAME} entry "${name}" fold must be a function.`);
+        }
+        if (hasFold && !("initial" in definition)) {
+            raiseError(`${STATE_STREAMS_NAME} entry "${name}" requires "initial" when fold is specified (reduce needs a seed value).`);
+        }
+        const hasArgs = typeof definition.args !== "undefined";
+        if (hasArgs && typeof definition.args !== "function") {
+            raiseError(`${STATE_STREAMS_NAME} entry "${name}" args must be a function.`);
+        }
+        const entry = {
+            name,
+            definition: {
+                args: definition.args ?? null,
+                source: definition.source,
+                fold: definition.fold ?? latestFold,
+                initial: definition.initial,
+            },
+            status: "idle",
+            error: null,
+            controller: null,
+            depAddresses: new Set(),
+        };
+        // 値プロパティ実体化（§1-3）: ユーザーが同名プロパティを先に宣言していたら上書きしない
+        if (!(name in state)) {
+            state[name] = entry.definition.initial;
+        }
+        entries.set(name, entry);
+    }
+    setStreamEntries(stateElement, entries);
+    // 新宣言に存在しない名前の通知 dedup 台帳エントリを prune する
+    // （同名は保持 = §4-3 の再 set 跨ぎ dedup 契約を維持。stream/lastNotified.ts 参照）
+    pruneLastNotified(stateElement, new Set(entries.keys()));
+}
+
+/**
+ * stream/streamNamespace.ts
+ *
+ * `$streamStatus` / `$streamError` の read-only namespace proxy
+ * （docs/state-streams-design.md §4-1 / §4-2）。commandNamespace と対称。
+ *
+ * - state element 単位で memo 化し、同一 stateElement なら同じ proxy が返る。
+ * - 宣言された stream 名（`$streams` に列挙されたもの）のみ registry entry の
+ *   status / error を返す。宣言外の名前・Symbol キーは undefined
+ *   （`then` / `constructor` 等を内部機構が触っても throw しない寛容規約、
+ *    $command と同じ）。
+ * - 値は memo しない: proxy は getStreamEntries を毎回読む thin gateway
+ *   （status / error は runtime が随時書き換えるため。registry entry が正本、§2-1）。
+ * - set / deleteProperty は raiseError。setByAddress の親走査が namespace proxy に
+ *   到達したときの Reflect.set もここで落ちる（書き込み防御 S11 の終端）。
+ */
+const statusNamespaceByStateElement = new WeakMap();
+const errorNamespaceByStateElement = new WeakMap();
+function createStreamNamespaceProxy(stateElement, namespaceName, pick) {
+    return new Proxy(Object.create(null), {
+        get(_target, prop) {
+            if (typeof prop !== "string") {
+                return undefined;
+            }
+            const entry = getStreamEntries(stateElement).get(prop);
+            if (typeof entry === "undefined") {
+                return undefined;
+            }
+            return pick(entry);
+        },
+        has(_target, prop) {
+            return typeof prop === "string" && getStreamEntries(stateElement).has(prop);
+        },
+        ownKeys() {
+            return Array.from(getStreamEntries(stateElement).keys());
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (typeof prop !== "string") {
+                return undefined;
+            }
+            const entry = getStreamEntries(stateElement).get(prop);
+            if (typeof entry === "undefined") {
+                return undefined;
+            }
+            return {
+                configurable: true,
+                enumerable: true,
+                value: pick(entry),
+            };
+        },
+        set() {
+            raiseError(`${namespaceName} namespace is read-only; assigning to it is not allowed.`);
+        },
+        deleteProperty() {
+            raiseError(`${namespaceName} namespace is read-only; deleting from it is not allowed.`);
+        },
+    });
+}
+function getStreamStatusNamespace(stateElement) {
+    const cached = statusNamespaceByStateElement.get(stateElement);
+    if (typeof cached !== "undefined") {
+        return cached;
+    }
+    const proxy = createStreamNamespaceProxy(stateElement, STATE_STREAM_STATUS_NAMESPACE_NAME, (entry) => entry.status);
+    statusNamespaceByStateElement.set(stateElement, proxy);
+    return proxy;
+}
+function getStreamErrorNamespace(stateElement) {
+    const cached = errorNamespaceByStateElement.get(stateElement);
+    if (typeof cached !== "undefined") {
+        return cached;
+    }
+    const proxy = createStreamNamespaceProxy(stateElement, STATE_STREAM_ERROR_NAMESPACE_NAME, (entry) => entry.error);
+    errorNamespaceByStateElement.set(stateElement, proxy);
+    return proxy;
+}
+/**
+ * 両 namespace proxy の memo を破棄する（clearCommandNamespace と対称）。
+ * disconnectedCallback と `_state` 再 set 時に呼ばれる。
+ */
+function clearStreamNamespace(stateElement) {
+    statusNamespaceByStateElement.delete(stateElement);
+    errorNamespaceByStateElement.delete(stateElement);
+}
+
+const updateBatchListeners = new Set();
+/**
+ * drain 終了リスナーを登録する。
+ */
+function registerUpdateBatchListener(listener) {
+    updateBatchListeners.add(listener);
+}
+/**
+ * 全リスナーに drain のバッチを通知する。
+ * リスナーの throw は握りつぶさない（内部バグの隠蔽防止）。
+ * stream 側リスナーが entry ごとに自前で try/catch する契約（設計書 §3-2）。
+ */
+function notifyUpdateBatchListeners(batch) {
+    for (const listener of updateBatchListeners) {
+        listener(batch);
+    }
+}
+class Updater {
+    _queueAbsoluteAddresses = [];
+    constructor() {
+    }
+    enqueueAbsoluteAddress(absoluteAddress) {
+        const requireStartProcess = this._queueAbsoluteAddresses.length === 0;
+        this._queueAbsoluteAddresses.push(absoluteAddress);
+        if (requireStartProcess) {
+            queueMicrotask(() => {
+                const absoluteAddresses = this._queueAbsoluteAddresses;
+                this._queueAbsoluteAddresses = [];
+                this._applyChange(absoluteAddresses);
+            });
+        }
+    }
+    // テスト用に公開
+    testApplyChange(absoluteAddresses) {
+        this._applyChange(absoluteAddresses);
+    }
+    _applyChange(absoluteAddresses) {
+        // Note: AbsoluteStateAddress はキャッシュされているため、
+        // 同一の (stateName, address) は同じインスタンスとなり、
+        // Set による重複排除が正しく機能する    
+        const absoluteAddressSet = new Set(absoluteAddresses);
+        const processBindings = [];
+        for (const absoluteAddress of absoluteAddressSet) {
+            // peek: バインディングの無いアドレス（リスト置換で enqueue される中間
+            // アドレス等）に空 Set を生成・蓄積しない
+            const bindings = peekBindingSetByAbsoluteStateAddress(absoluteAddress);
+            if (bindings === undefined) {
+                continue;
+            }
+            for (const binding of bindings) {
+                if (binding.replaceNode.isConnected === false) {
+                    // 切断されているバインディングは無視
+                    continue;
+                }
+                processBindings.push(binding);
+            }
+        }
+        applyChangeFromBindings(processBindings);
+        // drain 終了フック: binding 適用後に dedup 済みバッチを通知する（設計書 §3-2）。
+        // testApplyChange も同じ _applyChange を通るため、テストから同期に駆動できる。
+        notifyUpdateBatchListeners(absoluteAddressSet);
+    }
+}
+const updater = new Updater();
+function getUpdater() {
+    return updater;
+}
+
+/**
+ * stream/argsTrace.ts
+ *
+ * `$streams` の args トレース（依存捕捉、docs/state-streams-design.md §3-1）。
+ *
+ * - モジュールスコープの collector を立てて readonly proxy 上で args を評価し、
+ *   getByAddress を通った読みを絶対アドレス（IAbsoluteStateAddress）として捕捉する。
+ *   AbsolutePathInfo / AbsoluteStateAddress は両方キャッシュ済みのため、捕捉した
+ *   アドレスは drain バッチと Set.has のインスタンス同一性で O(1) 照合できる（§2-1）。
+ * - collectStreamDependency は getByAddress のホットパスから毎読み呼ばれるため、
+ *   collector === null なら即 return し、それ以外の計算を一切しない。
+ * - 起動・restart のたびに traceArgs が呼ばれ、成功時は entry.depAddresses を
+ *   丸ごと置換する（per-run の動的再捕捉）。失敗時は前回成功 run の検証済み
+ *   捕捉を保持する（§2-2 の「error からも依存変化で restart」を保つ）。
+ * - lastNotified.ts と同じく import 循環回避のための小モジュール
+ *   （getByAddress → argsTrace ← streamRuntime の一方向依存に保つ）。
+ */
+/** トレース中のみ非 null。getByAddress を通った読みの絶対アドレスが溜まる。 */
+let collector = null;
+/**
+ * getByAddress の入口（checkDependency 直後）から毎読み呼ばれるフック。
+ * トレース外（collector === null）では何もしない。
+ */
+function collectStreamDependency(stateElement, address) {
+    if (collector === null) {
+        return;
+    }
+    const absolutePathInfo = getAbsolutePathInfo(stateElement, address.pathInfo);
+    collector.add(createAbsoluteStateAddress(absolutePathInfo, address.listIndex));
+}
+/**
+ * args を readonly proxy で同期評価し、読まれたパスを entry.depAddresses に
+ * 丸ごと置換で再捕捉する（§3-1）。評価値（source の第 1 引数になる）を返す。
+ *
+ * - args === null（宣言で省略）なら depAddresses を clear して undefined
+ *   （依存なし = 起動後 restart しない）。
+ * - 検査（違反は raiseError）:
+ *   (a) 評価値が Promise（同期契約違反）
+ *   (b) 自己依存 — `<name>` / `$streamStatus.<name>` / `$streamError.<name>` の読み
+ *       （restart の自己書き込みで再発火する無限ループ、S8）
+ *   (c) wildcard を含むパスの読み（`$getAll` 等も同様。第 1 段スコープ外）
+ * - 失敗時（args のユーザー例外・検査違反）は今回の捕捉（captured）を採用せず
+ *   伝播し、entry.depAddresses には**前回成功 run の検証済み捕捉を保持する**。
+ *   これにより drain リスナーが throw を error 経路に正規化したあとも、依存の
+ *   書き込みで再試行できる（§2-2「done / error からも依存変化で restart」——
+ *   一時的な args throw で stream が恒久固着しない）。ループ安全性:
+ *   保持されるのは前回**成功** run の捕捉のみ（自己依存・wildcard 検査済み）で
+ *   自分の `<name>` / `$streamStatus.<name>` / `$streamError.<name>` を含み得ず、
+ *   traceArgs throw 時の startStream は initial リセットに到達しないため、
+ *   error 正規化の書き込みが保持 deps に再 hit することはない。再試行は依存
+ *   書き込み 1 回につき高々 1 回で有界。未検査の captured を採用しないことが
+ *   ループ防止の要件であり、前回検証済み捕捉の保持はそれを侵さない。
+ * - collector は finally で必ず復元する（例外・再入安全。ネスト評価は想定しないが
+ *   防御的に「前の collector を復元」の形にしておく — コストは同等）。
+ */
+function traceArgs(stateElement, entry) {
+    const argsFn = entry.definition.args;
+    if (argsFn === null) {
+        entry.depAddresses.clear();
+        return undefined;
+    }
+    const previousCollector = collector;
+    const captured = new Set();
+    collector = captured;
+    let argsValue = undefined;
+    try {
+        stateElement.createState("readonly", (state) => {
+            argsValue = argsFn(state);
+        });
+    }
+    finally {
+        // args のユーザー例外時は captured を採用せずそのまま伝播する
+        // （entry.depAddresses は前回成功 run の検証済み捕捉を保持）
+        collector = previousCollector;
+    }
+    if (argsValue instanceof Promise) {
+        raiseError(`${STATE_STREAMS_NAME} entry "${entry.name}" args must be synchronous (it returned a Promise).`);
+    }
+    const selfStatusPath = `${STATE_STREAM_STATUS_NAMESPACE_NAME}${DELIMITER}${entry.name}`;
+    const selfErrorPath = `${STATE_STREAM_ERROR_NAMESPACE_NAME}${DELIMITER}${entry.name}`;
+    for (const dep of captured) {
+        const pathInfo = dep.absolutePathInfo.pathInfo;
+        if (dep.absolutePathInfo.stateElement === stateElement &&
+            (pathInfo.path === entry.name || pathInfo.path === selfStatusPath || pathInfo.path === selfErrorPath)) {
+            raiseError(`${STATE_STREAMS_NAME} entry "${entry.name}" args must not read the stream itself ("${pathInfo.path}"): a self-dependency would restart the stream on its own writes (infinite loop).`);
+        }
+        if (pathInfo.wildcardCount > 0) {
+            raiseError(`${STATE_STREAMS_NAME} entry "${entry.name}" args must not read wildcard paths ("${pathInfo.path}"): wildcard dependencies are out of scope.`);
+        }
+    }
+    entry.depAddresses = captured;
+    return argsValue;
+}
+
+/**
+ * stream/consumeSource.ts
+ *
+ * `$streams` のチャンク消費ループ（docs/state-streams-design.md §3-3）。
+ * packages/signals/src/streamResource.ts の consume / iterate /
+ * readableToAsyncIterable の移植（パッケージ間依存は持たない自己完結原則）。
+ *
+ * 唯一の構造差分は状態書き込みの IConsumeSink への委譲:
+ *   value.set(fold(value.peek(), chunk)) → sink.fold(chunk)
+ *   status.set("done")                   → sink.done()
+ *   error.set(e) + status.set("error")   → sink.fail(e)
+ *
+ * sink.fold() が throw した場合（fold throw）もループ内の throw として
+ * 既存の catch に流れ、signal.aborted なら return、でなければ sink.fail(e)。
+ * consumeSource 自体は fold throw と source throw を区別しない
+ * （producer の掃除 = controller.abort() は呼び出し側 runtime が fail 内で行う）。
+ * consumeSource は reject しない（全経路 catch 済み）。
+ *
+ * ---------------------------------------------------------------------------
+ * 以下、移植元モジュールヘッダの契約（原文英語のまま維持）:
+ *
+ * CONTRACT (cooperative cancellation — STRONG REQUIREMENT): the `source` MUST honor
+ * the `AbortSignal` it is given. Honoring it is what drives switchMap restart/dispose;
+ * a source that ignores it cannot be reliably cancelled.
+ *
+ * Rescue levels on abort:
+ *   - ReadableStream: FULLY rescued. A parked read() is force-unwound via
+ *     reader.cancel(), which both releases the underlying source and settles the
+ *     pending read() so the loop unwinds.
+ *   - AsyncIterable / async generator: PARTIALLY rescued. On abort we call
+ *     iterator.return() to trigger the generator's finally/cleanup. But a parked
+ *     `await` (the producer stalling before its next yield while IGNORING `signal`)
+ *     cannot be force-unwound from outside — return() only takes effect when the
+ *     generator next resumes. So a source that parks forever and never observes
+ *     `signal` still leaks its consume task. Honor `signal` to bound this.
+ * The `if (signal.aborted) return` check only runs after a chunk arrives, not while
+ * parked — it drops stale chunks but is not, by itself, a cancellation mechanism.
+ */
+async function consumeSource(source, args, signal, sink) {
+    // Obtain the iterator EXPLICITLY (not via `for await`'s implicit one) so abort can
+    // call `iterator.return()` to trigger an AsyncIterable / async generator's
+    // `finally`/cleanup. A `for await` only calls `.return()` when the loop itself exits;
+    // if the producer is PARKED (awaiting before the next yield while ignoring `signal`),
+    // the loop never advances, so the implicit `.return()` never runs and the task leaks
+    // past restart/dispose. Calling `.return()` on abort is the PARTIAL rescue: the
+    // parked `await` cannot be force-unwound from outside, but once the generator resumes
+    // (its next tick), `.return()` makes it run its `finally` and stop — recovering the
+    // common "generator wakes up after abort" case. The ReadableStream path is fully
+    // rescued via `reader.cancel()` (see `readableToAsyncIterable`).
+    let iterator = null;
+    // Guard against returning the SAME iterator twice. `onAbort` is reachable two ways:
+    // the abort listener, and the explicit call below when abort raced the
+    // `await source(...)`. The guard keys on the iterator instance (not a plain "ran"
+    // flag): the listener firing with iterator still null must NOT consume the single
+    // real cleanup that the explicit call performs once the iterator exists. So we only
+    // mark an iterator returned once we have actually called `.return()` on it.
+    let returned = null;
+    const onAbort = () => {
+        if (!iterator || iterator === returned) {
+            return; // nothing to release yet, or already released this iterator
+        }
+        returned = iterator;
+        // Fire the iterator's cleanup. Swallow any throw/rejection from `.return()` — we
+        // are tearing down; a producer that rejects on return must not surface here.
+        try {
+            void iterator.return?.()?.then?.(undefined, () => { });
+        }
+        catch {
+            // `.return()` threw synchronously while tearing down — ignore.
+        }
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    try {
+        const produced = await source(args, signal);
+        iterator = iterate(produced, signal)[Symbol.asyncIterator]();
+        if (signal.aborted) {
+            // Aborted while awaiting the source: the abort listener already ran (iterator
+            // was still null then), so explicitly release the just-produced iterator now —
+            // this fires a generator's finally / a ReadableStream's cancel for the
+            // resource we created but will never iterate.
+            onAbort();
+            return;
+        }
+        for (;;) {
+            const result = await iterator.next();
+            if (result.done) {
+                break;
+            }
+            if (signal.aborted) {
+                return; // stale chunk from a superseded/disposed run — drop it
+            }
+            sink.fold(result.value);
+        }
+        if (signal.aborted) {
+            return; // stream ended but this run was aborted — don't mark done
+        }
+        sink.done();
+    }
+    catch (e) {
+        if (signal.aborted) {
+            return; // an abort that surfaced as a throw is not an error
+        }
+        sink.fail(e); // keep the last folded value (do not reset)
+    }
+    finally {
+        signal.removeEventListener("abort", onAbort);
+    }
+}
+function iterate(produced, signal) {
+    // Optional chaining: a null/undefined source return value must fall through to the
+    // explicit TypeError below (symmetric with the `?.` on the getReader probe), not
+    // throw an opaque "Cannot read properties of null" from this property access.
+    if (typeof produced?.[Symbol.asyncIterator] === "function") {
+        return produced;
+    }
+    // Not async-iterable: must be a ReadableStream (read via getReader). Validate so
+    // a wrong source value yields a clear error instead of an opaque "getReader is
+    // not a function" from inside the generator.
+    if (typeof produced?.getReader !== "function") {
+        throw new TypeError("[@wcstack/state] $streams: source must return an AsyncIterable or a ReadableStream (got neither).");
+    }
+    return readableToAsyncIterable(produced, signal);
+}
+async function* readableToAsyncIterable(stream, signal) {
+    const reader = stream.getReader();
+    // A ReadableStream read() does NOT observe an AbortSignal on its own. Without
+    // this, a switchMap restart / dispose leaves the previous reader parked in a
+    // pending read() forever, leaking the underlying source. Cancelling on abort
+    // both releases the source AND settles the pending read() so the for-await
+    // unwinds and the finally below can release the lock. Abort is the only
+    // early-exit path for this generator (the consumer never calls .return()
+    // without aborting), so this is the sole place a non-drained stream is cancelled.
+    const onAbort = () => {
+        void reader.cancel().catch(() => { }); // tearing down; swallow a rejected cancel
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                return;
+            }
+            yield value;
+        }
+    }
+    finally {
+        signal.removeEventListener("abort", onAbort);
+        reader.releaseLock();
+    }
+}
+
+/**
+ * stream/streamRuntime.ts
+ *
+ * `$streams` の起動・チャンク反映・status 遷移（docs/state-streams-design.md
+ * §2-2 / §3-3 / §4-3）。
+ *
+ * スコープ:
+ * - eager 起動（startStreams）と start = restart の共通手順（startStream）。
+ * - args は traceArgs（stream/argsTrace.ts）で readonly proxy 評価と同時に依存を
+ *   per-run 再捕捉する（§3-1）。
+ * - 依存駆動 restart（§3-2）: モジュール初期化時に updater の drain 終了リスナーを
+ *   1 つ登録し（restartStreamsOnUpdateBatch）、起動中 stateElement
+ *   （stream/activeStateElements.ts — startStreams で add・abortAllStreams /
+ *   clearStreamRegistry で delete）の各 entry について depAddresses と batch を
+ *   交差させ、hit した entry を restart する。
+ *
+ * 切断後の後始末について（不変条件）:
+ * - disconnect（abortAllStreams）は registry entry を直接ミューテーションして
+ *   idle に戻す（$postUpdate は呼ばない — 切断済みで binding 更新は不要かつ
+ *   rootNode が無い）。
+ * - abort 済み run の sink コールバック（fold / done / fail）は consumeSource の
+ *   stale-drop（全経路の signal.aborted チェック）が createState 到達前に
+ *   落とすため、runtime 側に切断後ガードは不要。
+ *   「runtime が createState を呼ぶのは自分の controller が生きている間だけ」が
+ *   この 2 つの組み合わせで常に保たれる。
+ */
+/**
+ * 登録済みの全 stream を起動する（eager 起動、設計書 §2-3）。
+ * State.connectedCallback（$connectedCallback 完了後）と接続中の `_state` 再 set
+ * から呼ばれる想定。
+ *
+ * 同時に依存駆動 restart（§3-2）の対象として activeStateElements に登録する
+ * （delete 側は abortAllStreams / clearStreamRegistry —
+ *  stream/activeStateElements.ts のリーク防止不変条件を参照）。
+ * eager 起動の throw（args のユーザー例外等）はここでは正規化せず loud fail のまま
+ * （既存の $connectedCallback と同じ扱い。正規化は drain リスナー側の restart のみ）。
+ */
+function startStreams(stateElement) {
+    const entries = getStreamEntries(stateElement);
+    if (entries.size === 0) {
+        return;
+    }
+    addActiveStateElement(stateElement);
+    for (const entry of entries.values()) {
+        startStream(stateElement, entry);
+    }
+}
+/**
+ * stream を起動する。start = restart の共通手順（設計書 §2-2）:
+ *
+ * 1. 旧 run を abort（restart 時）→ 新 AbortController
+ * 2. traceArgs で args を readonly proxy 評価し依存を丸ごと再捕捉
+ *    （Promise / 自己依存 / wildcard 読みは raiseError、§3-1）
+ * 3. 値を initial にリセット（起動 = 最初の run も restart と同一セマンティクス、§1-3）
+ * 4. status="active"・error=null を反映
+ * 5. consumeSource で消費開始
+ */
+function startStream(stateElement, entry) {
+    entry.controller?.abort();
+    const controller = new AbortController();
+    entry.controller = controller;
+    // args 評価 ＋ 依存の per-run 再捕捉（args === null なら depAddresses を clear して
+    // undefined。Promise / 自己依存 / wildcard 読みは raiseError、§3-1）
+    const argsValue = traceArgs(stateElement, entry);
+    // 値リセット: setByAddress を通すことで updater coalesce・sameValueGuard・
+    // walkDependency（stream 値に依存する computed の dirty 化）がすべて乗る（§3-3）
+    stateElement.createState("writable", (state) => {
+        state[entry.name] = entry.definition.initial;
+    });
+    updateStreamStatus(stateElement, entry, "active", null);
+    const definition = entry.definition;
+    const sink = {
+        fold(chunk) {
+            // fold の throw はそのまま伝播させる（consumeSource が fail 経路に回す）
+            stateElement.createState("writable", (state) => {
+                state[entry.name] = definition.fold(state[entry.name], chunk);
+            });
+        },
+        done() {
+            updateStreamStatus(stateElement, entry, "done", null);
+        },
+        fail(error) {
+            // 値は直前の fold 結果を保持（リセットしない）
+            updateStreamStatus(stateElement, entry, "error", error);
+            // fold-throw 時の producer 掃除（iterator.return() / reader.cancel() を発火）。
+            // source-throw 時は producer が既に終了しているので abort は無害（§3-3）。
+            controller.abort();
+        },
+    };
+    void consumeSource(definition.source, argsValue, controller.signal, sink);
+}
+/**
+ * status / error の反映ヘルパ（設計書 §4-3）。
+ *
+ * - registry entry が正本。常に最新値へ書き換える。
+ * - 「最後に通知した観測値」（stream/lastNotified.ts — 再 set・再接続を跨いで
+ *   stateElement の寿命で生存する台帳）から変化した項目に対応する名前空間パス
+ *   （`$streamStatus.<name>` / `$streamError.<name>`）だけを writable proxy の
+ *   $postUpdate で通知する（updater enqueue ＋ walkDependency）。
+ * - 両方不変なら通知しない（名前空間パスは setByAddress を通らないため
+ *   sameValueGuard が効かず、同等の same-value 判定を runtime 側が持つ）。
+ *   abortAllStreams の無通知ミューテーションで台帳が invalidate されている場合は
+ *   同値扱いにならず必ず通知される（再接続ウィンドウ内の fresh 読みが描画した
+ *   idle の恒久陳腐化を防ぐ、§4-3）。
+ */
+function updateStreamStatus(stateElement, entry, status, error) {
+    entry.status = status;
+    entry.error = error;
+    const last = getLastNotified(stateElement, entry.name);
+    const statusChanged = last.status !== status;
+    const errorChanged = !Object.is(last.error, error);
+    if (!statusChanged && !errorChanged) {
+        return;
+    }
+    setLastNotified(stateElement, entry.name, status, error);
+    stateElement.createState("writable", (state) => {
+        if (statusChanged) {
+            state.$postUpdate(`${STATE_STREAM_STATUS_NAMESPACE_NAME}${DELIMITER}${entry.name}`);
+        }
+        if (errorChanged) {
+            state.$postUpdate(`${STATE_STREAM_ERROR_NAMESPACE_NAME}${DELIMITER}${entry.name}`);
+        }
+    });
+}
+/**
+ * 依存駆動 restart の drain リスナー（設計書 §3-2）。
+ * モジュール初期化時に registerUpdateBatchListener で 1 つだけ登録される。
+ *
+ * - 起動中の各 stateElement の各 entry について、depAddresses と batch の交差を
+ *   Set.has のインスタンス同一性で判定する（小さい方 = depAddresses を回して
+ *   batch.has(dep)。AbsoluteStateAddress はキャッシュにより同一 (stateName, path,
+ *   listIndex) が同一インスタンス、§2-1）。args なし（depAddresses 空）の entry は
+ *   自然にスキップされる。
+ * - status は問わず restart する（done / error からも依存の叩き直しで再試行、§2-2）。
+ * - hit は収集してから一括で restart する（イテレーション中の registry 変更を避ける。
+ *   entry ごとに最初の hit で break するため「1 drain につき 1 entry 最大 1 restart」
+ *   もここで自然に成立する — 同一 tick 内の複数依存書き込みは 1 restart に畳まれる）。
+ * - hits の実行時にも active ＋ entry identity を再チェックする: 先行 restart の
+ *   source / args は consumeSource / traceArgs の同期プレフィックスで同期実行される
+ *   ため、そこで (a) 他の stateElement（や自分自身のホスト）の同期切断、(b) 同一要素の
+ *   _state 同期再 set（clearStreamRegistry → startStreams で Set に再 add される）が
+ *   起こり得る。(a) は切断済み要素への startStream が rootNode 不在で throw する経路、
+ *   (b) は registry から置換済みの旧 entry を restart して到達不能な孤児 consume run を
+ *   リークする経路（§3-2「未接続の stateElement の entry は restart しない」・
+ *   §5-1「切断後は idle」に違反）で、いずれも「entry が現行 registry の live entry で
+ *   あること」の再検証で skip する。startStream **実行中**の自己切断・再 set は事前
+ *   チェックではガードできないため、catch 側でも同じ再検証を行ってから error に
+ *   正規化する（切断済みでの正規化は createState が再 throw して drain リスナー外へ
+ *   漏れ、後続 hits の restart を巻き添えにするため）。
+ * - restart（startStream）は entry ごとに try/catch し、throw（args のユーザー例外・
+ *   Promise 同期契約違反等）は controller.abort() → status="error"・$streamError 格納
+ *   に正規化する（§3-2 規範 3）。updater の drain を壊さず、他 entry の restart も
+ *   継続する。eager 起動（connect 時の startStreams）の throw は従来どおり loud fail。
+ * - restart 内の書き込み（initial リセット・status 通知）は updater への enqueue のみで
+ *   新しい microtask バッチを作る（drain 再入ではない）。自己依存は traceArgs が
+ *   宣言時に raiseError で検出するため、restart 書き込みが自分の依存に再 hit する
+ *   ループは起きない（§3-1）。
+ */
+function restartStreamsOnUpdateBatch(batch) {
+    const activeStateElements = getActiveStateElements();
+    if (activeStateElements.size === 0) {
+        // stream 未使用アプリの drain に配列・イテレータ割り当てのコストを載せない
+        return;
+    }
+    const hits = [];
+    for (const stateElement of activeStateElements) {
+        for (const entry of getStreamEntries(stateElement).values()) {
+            for (const dep of entry.depAddresses) {
+                if (batch.has(dep)) {
+                    hits.push({ stateElement, entry });
+                    break;
+                }
+            }
+        }
+    }
+    for (const { stateElement, entry } of hits) {
+        // 先行 restart の source / args 同期実行は他要素の切断や同一要素の _state 同期再 set を
+        // 行い得るため、実行時に再チェックする（live な Set / registry ビューで即時反映）:
+        // - 切断済み要素は skip（§3-2「未接続の stateElement の entry は restart しない」）
+        // - entry が現行 registry のものでなければ skip — 同期再 set で置換された旧 entry を
+        //   restart すると、registry から到達不能なため abortAllStreams でも止められない
+        //   孤児 consume run がリークする
+        if (!activeStateElements.has(stateElement) ||
+            getStreamEntries(stateElement).get(entry.name) !== entry) {
+            continue;
+        }
+        try {
+            startStream(stateElement, entry);
+        }
+        catch (e) {
+            entry.controller?.abort();
+            // startStream 実行中（args / source の同期プレフィックス）の自己切断・同期再 set は
+            // 上の再チェックではガードできない。切断済みだと updateStreamStatus の createState が
+            // rootNode 不在で再 throw して drain リスナー外へ漏れる（後続 hits の restart を
+            // 巻き添えにする）ため、entry がまだ現行の live entry である場合のみ error に
+            // 正規化する（切断済みなら abortAllStreams が idle に戻し済み。§3-2 規範 3 / §5-1）。
+            if (activeStateElements.has(stateElement) &&
+                getStreamEntries(stateElement).get(entry.name) === entry) {
+                updateStreamStatus(stateElement, entry, "error", e);
+            }
+        }
+    }
+}
+registerUpdateBatchListener(restartStreamsOnUpdateBatch);
+
+function getterFn(name) {
+    return function () {
+        const stateEl = this.stateElement;
+        if (!stateEl)
+            return undefined;
+        let value;
+        try {
+            stateEl.createState("readonly", (state) => {
+                value = state[name];
+            });
+        }
+        catch (e) {
+            console.warn(`[@wcstack/state] DCC getter "${name}" failed:`, e);
+            return undefined;
+        }
+        return value;
+    };
+}
+function setterFn(name) {
+    return function (value) {
+        const stateEl = this.stateElement;
+        if (!stateEl)
+            return;
+        stateEl.initializePromise.then(() => {
+            stateEl.createState("writable", (state) => {
+                state[name] = value;
+            });
+        });
+    };
+}
+function callFn(name, isAsync) {
+    if (isAsync) {
+        return function (...args) {
+            const stateEl = this.stateElement;
+            if (!stateEl)
+                return undefined;
+            return stateEl.initializePromise.then(() => {
+                let result;
+                return stateEl.createStateAsync("writable", async (state) => {
+                    result = await state[name](...args);
+                }).then(() => result);
+            });
+        };
+    }
+    return function (...args) {
+        const stateEl = this.stateElement;
+        if (!stateEl)
+            return undefined;
+        return stateEl.initializePromise.then(() => {
+            let result;
+            stateEl.createState("writable", (state) => {
+                result = state[name](...args);
+            });
+            return result;
+        });
+    };
+}
+function isInternalProperty(name) {
+    return name.startsWith("$");
+}
+
+function createWcBindable(tagName, bindables) {
+    const properties = bindables.map((propName) => ({
+        name: propName,
+        event: `${tagName}:${propName}-changed`,
+    }));
+    return {
+        protocol: "wc-bindable",
+        version: 1,
+        properties,
+    };
+}
+function createBindableEventMap(tagName, bindables) {
+    const map = {};
+    for (const propName of bindables) {
+        map[propName] = `${tagName}:${propName}-changed`;
+    }
+    return map;
+}
+
+function defineDCC(hostElement, shadowRoot, state) {
+    const tagName = hostElement.tagName.toLowerCase();
+    // バリデーション
+    if (!tagName.includes("-")) {
+        raiseError(`DCC: "${tagName}" is not a valid custom element name (must contain a hyphen).`);
+    }
+    if (customElements.get(tagName)) {
+        // 既に登録済みならスキップ（重複定義の検知のため警告は出す）
+        console.warn(`[@wcstack/state] DCC: "${tagName}" is already registered. Skipping redefinition.`);
         return;
     }
     // ShadowRoot は cloneNode 不可のため、template 経由で内容をクローン
@@ -5949,7 +7103,8 @@ function dirtyCacheEntryByAbsoluteStateAddress(address) {
 function checkDependency(handler, address) {
     // 動的依存関係の登録
     if (handler.addressStackLength > 0) {
-        const lastInfo = handler.lastAddressStack?.pathInfo ?? null;
+        const lastAddress = handler.lastAddressStack;
+        const lastInfo = lastAddress?.pathInfo ?? null;
         const stateElement = handler.stateElement;
         if (lastInfo !== null) {
             if (stateElement.getterPaths.has(lastInfo.path) &&
@@ -5957,6 +7112,27 @@ function checkDependency(handler, address) {
                 // lastInfo.pathはgetterの名前であり、address.pathInfo.pathは
                 // そのgetterが参照している値のパスである
                 stateElement.addDynamicDependency(address.pathInfo.path, lastInfo.path);
+                // 他行読み取りの検出: 評価中の getter と読み取り先が同じワイルドカード親
+                // （リスト）を共有し、その階層の listIndex が異なる場合、この getter は
+                // 自行の外に依存する（隣接項目参照など）。該当リストを crossRowListPaths に
+                // 記録し、walkDependency の diff-filter 展開を全行展開へフォールバックさせる。
+                if (address.pathInfo.wildcardCount > 0 && lastInfo.wildcardCount > 0) {
+                    const sharedLen = calcWildcardLen(address.pathInfo, lastInfo);
+                    if (sharedLen > 0) {
+                        let crossRow = false;
+                        for (let level = 0; level < sharedLen; level++) {
+                            if (address.listIndex?.at(level) !== lastAddress.listIndex?.at(level)) {
+                                crossRow = true;
+                                break;
+                            }
+                        }
+                        if (crossRow) {
+                            for (let level = 0; level < sharedLen; level++) {
+                                stateElement.addCrossRowListPath?.(address.pathInfo.wildcardParentPaths[level]);
+                            }
+                        }
+                    }
+                }
             }
         }
     }
@@ -5981,19 +7157,42 @@ function checkDependency(handler, address) {
  * - ワイルドカードや多重ループにも柔軟に対応し、再帰的な値取得を実現
  * - finallyでキャッシュへの格納を保証
  */
-function _getByAddress(target, address, receiver, handler, stateElement) {
-    if (address.pathInfo.segments[0] === STATE_COMMAND_NAMESPACE_NAME) {
-        // $command 名前空間配下のパスは raw state を持たないため、proxy の get トラップと
-        // 同じ namespace を辿る。1セグメント目は namespace 本体、2セグメント目以降は
-        // namespace 上のキー (= 宣言済み command token 名) を順に走査する。
-        let value = getCommandNamespace(stateElement);
-        for (let i = 1; i < address.pathInfo.segments.length; i++) {
-            if (value == null) {
-                return undefined;
-            }
-            value = Reflect.get(value, address.pathInfo.segments[i]);
+/**
+ * namespace 配下のパスは raw state を持たないため、proxy の get トラップと同じ
+ * namespace オブジェクトを辿る。1セグメント目は namespace 本体、2セグメント目以降は
+ * namespace 上のキーを順に走査する。走査値が object / function 以外（null /
+ * undefined / primitive の葉）になったら undefined を返す — 葉より深い読み
+ * （例: `$streamStatus.<name>.<key>`、error が primitive throw のときの
+ * `$streamError.<name>.message`）は宣言外アクセスと同じ undefined 解決とし、
+ * Reflect.get の non-object TypeError を updater の drain に漏らさない
+ * （§4-1 の throw しない寛容規約）。
+ */
+function walkNamespace(namespace, segments) {
+    let value = namespace;
+    for (let i = 1; i < segments.length; i++) {
+        // Object(v) !== v は「v が object / function でない」（= primitive / null / undefined）判定
+        if (Object(value) !== value) {
+            return undefined;
         }
-        return value;
+        value = Reflect.get(value, segments[i]);
+    }
+    return value;
+}
+function _getByAddress(target, address, receiver, handler, stateElement) {
+    const firstSegment = address.pathInfo.segments[0];
+    if (firstSegment === STATE_COMMAND_NAMESPACE_NAME) {
+        // $command 名前空間: キーは宣言済み command token 名
+        return walkNamespace(getCommandNamespace(stateElement), address.pathInfo.segments);
+    }
+    if (firstSegment === STATE_STREAM_STATUS_NAMESPACE_NAME) {
+        // $streamStatus / $streamError 名前空間: キーは宣言済み stream 名
+        // （registry entry が正本の thin gateway、docs/state-streams-design.md §4-2）。
+        // setByAddress の親走査もここを通るため、子への Reflect.set が namespace proxy の
+        // raiseError に到達する = 書き込み防御（S11）もこの分岐で成立する。
+        return walkNamespace(getStreamStatusNamespace(stateElement), address.pathInfo.segments);
+    }
+    if (firstSegment === STATE_STREAM_ERROR_NAMESPACE_NAME) {
+        return walkNamespace(getStreamErrorNamespace(stateElement), address.pathInfo.segments);
     }
     if (address.pathInfo.path in target) {
         // getterの中で参照の可能性があるので、addressをプッシュする
@@ -6039,6 +7238,8 @@ function _getByAddressWithCache(target, address, receiver, handler, stateElement
 }
 function getByAddress(target, address, receiver, handler) {
     checkDependency(handler, address);
+    // $streams の args トレース中のみ絶対アドレスを捕捉（collector 非活性なら即 return）
+    collectStreamDependency(handler.stateElement, address);
     const stateElement = handler.stateElement;
     const cacheable = address.pathInfo.wildcardCount > 0 ||
         stateElement.getterPaths.has(address.pathInfo.path);
@@ -6082,49 +7283,6 @@ function getContextListIndex(handler, structuredPath) {
     return address.listIndex?.at(index) ?? null;
 }
 
-class Updater {
-    _queueAbsoluteAddresses = [];
-    constructor() {
-    }
-    enqueueAbsoluteAddress(absoluteAddress) {
-        const requireStartProcess = this._queueAbsoluteAddresses.length === 0;
-        this._queueAbsoluteAddresses.push(absoluteAddress);
-        if (requireStartProcess) {
-            queueMicrotask(() => {
-                const absoluteAddresses = this._queueAbsoluteAddresses;
-                this._queueAbsoluteAddresses = [];
-                this._applyChange(absoluteAddresses);
-            });
-        }
-    }
-    // テスト用に公開
-    testApplyChange(absoluteAddresses) {
-        this._applyChange(absoluteAddresses);
-    }
-    _applyChange(absoluteAddresses) {
-        // Note: AbsoluteStateAddress はキャッシュされているため、
-        // 同一の (stateName, address) は同じインスタンスとなり、
-        // Set による重複排除が正しく機能する    
-        const absoluteAddressSet = new Set(absoluteAddresses);
-        const processBindings = [];
-        for (const absoluteAddress of absoluteAddressSet) {
-            const bindings = getBindingSetByAbsoluteStateAddress(absoluteAddress);
-            for (const binding of bindings) {
-                if (binding.replaceNode.isConnected === false) {
-                    // 切断されているバインディングは無視
-                    continue;
-                }
-                processBindings.push(binding);
-            }
-        }
-        applyChangeFromBindings(processBindings);
-    }
-}
-const updater = new Updater();
-function getUpdater() {
-    return updater;
-}
-
 const swapInfoByStateAddress = new WeakMap();
 function getSwapInfoByAddress(address) {
     return swapInfoByStateAddress.get(address) ?? null;
@@ -6177,6 +7335,37 @@ function _walkExpandWildcard(context, currentWildcardIndex, parentListIndex) {
         }
     }
 }
+/**
+ * 静的子展開で訪問する listIndex 群を選ぶ。"diff" でも次の場合は全行に倒す:
+ * - diff に変化が一切見えない再代入（同一参照および内容同一コピーの再代入。
+ *   `arr[0].v = 5; s.items = [...arr]` のような in-place 変異後のリフレッシュ
+ *   イディオムは diff に映らないため、全行展開で従来挙動を保つ。
+ *   削除だけの置換は除く — 残存行に変化は無く、集計はコンテナ動的エッジが担う）
+ * - 他行を読む getter が検出されたリスト（隣接項目参照など。未変更行の派生値も変わりうる）
+ */
+function selectExpansionIndexes(context, sourcePath, _lastValue, _newValue, listDiff) {
+    if (context.listExpansion === "full") {
+        return listDiff.newIndexes;
+    }
+    if (context.stateElement.crossRowListPaths?.has(sourcePath)) {
+        return listDiff.newIndexes;
+    }
+    if (listDiff.addIndexSet.size === 0 && listDiff.changeIndexSet.size === 0) {
+        // 追加も移動も無い。削除も無ければ「変化が見えない再代入」= リフレッシュ意図
+        if (listDiff.deleteIndexSet.size === 0) {
+            return listDiff.newIndexes;
+        }
+        // 削除のみ: 残存行は位置も値も不変なので展開しない
+        return listDiff.changeIndexSet;
+    }
+    if (listDiff.addIndexSet.size === 0) {
+        return listDiff.changeIndexSet;
+    }
+    if (listDiff.changeIndexSet.size === 0) {
+        return listDiff.addIndexSet;
+    }
+    return [...listDiff.addIndexSet, ...listDiff.changeIndexSet];
+}
 function _walkDependency(context, startAddress, callback) {
     const stack = [{ address: startAddress, depth: 0 }];
     while (stack.length > 0) {
@@ -6209,7 +7398,7 @@ function _walkDependency(context, startAddress, callback) {
                     const absAddress = createAbsoluteStateAddress(absPathInfo, address.listIndex);
                     const lastValue = getLastListValueByAbsoluteStateAddress(absAddress);
                     const listDiff = createListDiff(address.listIndex, lastValue, newValue);
-                    for (const listIndex of listDiff.newIndexes) {
+                    for (const listIndex of selectExpansionIndexes(context, sourcePath, lastValue, newValue, listDiff)) {
                         const depAddress = createStateAddress(depPathInfo, listIndex);
                         context.result.add(depAddress);
                         nextEntries.push({ address: depAddress, depth: nextDepth });
@@ -6303,7 +7492,7 @@ function _walkDependency(context, startAddress, callback) {
         }
     }
 }
-function walkDependency(stateName, stateElement, startAddress, staticDependency, dynamicDependency, listPathSet, stateProxy, searchType, callback) {
+function walkDependency(stateName, stateElement, startAddress, staticDependency, dynamicDependency, listPathSet, stateProxy, searchType, callback, options) {
     const context = {
         stateElement: stateElement,
         staticMap: staticDependency,
@@ -6313,6 +7502,7 @@ function walkDependency(stateName, stateElement, startAddress, staticDependency,
         visited: new Set(),
         stateProxy: stateProxy,
         searchType: searchType,
+        listExpansion: options?.listExpansion ?? "full",
     };
     _walkDependency(context, startAddress, callback);
     return Array.from(context.result);
@@ -6378,7 +7568,10 @@ function _setByAddress(target, address, absAddress, value, receiver, handler) {
             dirtyCacheEntryByAbsoluteStateAddress(absDepAddress);
             // 更新対象として登録
             updater.enqueueAbsoluteAddress(absDepAddress);
-        });
+        }, 
+        // リスト置換時は追加行・位置変更行のみ展開する（未変更行の再訪を省く。
+        // $postUpdate の手動リフレッシュは従来通り全行展開のまま）
+        { listExpansion: "diff" });
     }
 }
 function _setByAddressWithSwap(target, address, absAddress, value, receiver, handler) {
@@ -6821,6 +8014,9 @@ async function setLoopContextAsync(handler, loopContext, callback) {
  * - 通常のプロパティアクセスもバインディングや多重ループに対応
  * - シンボルAPIやReflect.getで拡張性・互換性も確保
  */
+// `$streamStatus.<name>` / `$streamError.<name>` の dotted パス判定用プレフィックス
+const STREAM_STATUS_PATH_PREFIX = `${STATE_STREAM_STATUS_NAMESPACE_NAME}${DELIMITER}`;
+const STREAM_ERROR_PATH_PREFIX = `${STATE_STREAM_ERROR_NAMESPACE_NAME}${DELIMITER}`;
 function get(target, prop, receiver, handler) {
     const index = INDEX_BY_INDEX_NAME[prop];
     if (typeof index !== "undefined") {
@@ -6859,14 +8055,27 @@ function get(target, prop, receiver, handler) {
                 case STATE_COMMAND_NAMESPACE_NAME: {
                     return getCommandNamespace(handler.stateElement);
                 }
+                case STATE_STREAM_STATUS_NAMESPACE_NAME: {
+                    return getStreamStatusNamespace(handler.stateElement);
+                }
+                case STATE_STREAM_ERROR_NAMESPACE_NAME: {
+                    return getStreamErrorNamespace(handler.stateElement);
+                }
+            }
+            // switch 不一致の $ プロパティのうち、`$streamStatus.<name>` / `$streamError.<name>`
+            // の dotted パスだけは通常のパス解決（getByAddress）へフォールスルーさせる。
+            // これが computed（getter）内での依存追跡付き読み取りの正規形
+            // （checkDependency が getter スコープで動的依存を登録し、$postUpdate の
+            //  walkDependency で computed が無効化される、docs/state-streams-design.md §4-3）。
+            // それ以外の未知 $ プロパティは従来どおり undefined を返す。
+            if (!prop.startsWith(STREAM_STATUS_PATH_PREFIX) && !prop.startsWith(STREAM_ERROR_PATH_PREFIX)) {
+                return undefined;
             }
         }
-        else {
-            const resolvedAddress = getResolvedAddress(prop);
-            const listIndex = getListIndex(target, resolvedAddress, receiver, handler);
-            const stateAddress = createStateAddress(resolvedAddress.pathInfo, listIndex);
-            return getByAddress(target, stateAddress, receiver, handler);
-        }
+        const resolvedAddress = getResolvedAddress(prop);
+        const listIndex = getListIndex(target, resolvedAddress, receiver, handler);
+        const stateAddress = createStateAddress(resolvedAddress.pathInfo, listIndex);
+        return getByAddress(target, stateAddress, receiver, handler);
     }
     else if (typeof prop === "symbol") {
         switch (prop) {
@@ -7441,6 +8650,10 @@ class State extends HTMLElement {
         return getBindingsReady(rootNode);
     }
     __state;
+    _hasUpdatedCallback = false;
+    // 他行を読む getter が検出されたリストパス（diff-filter 展開の全行フォールバック対象）。
+    // 依存マップ（static/dynamic）と同様に追加のみ・クリアしない（安全側に固定される）。
+    _crossRowListPaths = new Set();
     _name = 'default';
     _initialized = false;
     _initializePromise;
@@ -7466,6 +8679,17 @@ class State extends HTMLElement {
     _bindableEventMap = {};
     _commandTokenNames = new Set();
     _eventTokenNames = new Set();
+    _dcc = false;
+    // connect サイクルの世代カウンタ（connectedCallback 冒頭でインクリメント）。
+    // $connectedCallback の await 中の「切断 → 即再接続」では、新 connect が
+    // _rootNode を再設定済みのため陳腐化した旧 connect の再開が _rootNode ガードを
+    // 素通りして startStreams に到達し、同一の再接続に対して source が二重起動する。
+    // 末尾で冒頭に捕捉した世代と照合し、陳腐 connect からの起動を skip する（設計書 §2-3）。
+    _connectGeneration = 0;
+    // _state セッター側の startStreams が走った connect 世代
+    // （connectedCallback 末尾の startStreams との二重起動防止、設計書 §2-3。
+    //  世代が進めば不一致となり自然に無効化される — サイクル単位のフラグリセット相当）
+    _streamsStartedGeneration = 0;
     constructor() {
         super();
         this._initializePromise = new Promise((resolve) => {
@@ -7491,12 +8715,22 @@ class State extends HTMLElement {
         this._commandTokenNames = processCommandTokensDeclaration(value);
         this._eventTokenNames = processEventTokensDeclaration(value);
         this.__state = value;
+        // $updatedCallback の有無を state セット時に確定しておく（in はプロトタイプ
+        // チェーンも見る・getter を評価しない）。drain 側はこのフラグで更新アドレスの
+        // 集計と writable createState をスキップできる。
+        // 注: state セット後に生オブジェクトへ直接 $updatedCallback を後付けする
+        // パターンは検知できない（bindProperty / _state 再セットは検知する）。
+        // ライフサイクルフックは宣言時に定義するのが規約。
+        this._hasUpdatedCallback = STATE_UPDATED_CALLBACK_NAME in value;
         // 再 set 時に二重 subscribe しないよう registry をクリアしてから $on を配線し直す。
         clearEventTokenRegistry(this);
         processOnDeclaration(this, value, this._eventTokenNames);
         this._listPaths.clear();
         this._elementPaths.clear();
         this._getterPaths.clear();
+        // 再 set 時の残骸が $streams の衝突検査（processStreamsDeclaration）に
+        // 偽陽性で命中しないよう getterPaths と対称にクリアする。
+        this._setterPaths.clear();
         this._pathSet.clear();
         const stateInfo = getStateInfo(value);
         for (const path of stateInfo.getterPaths) {
@@ -7505,6 +8739,25 @@ class State extends HTMLElement {
         for (const path of stateInfo.setterPaths) {
             this._setterPaths.add(path);
         }
+        // $streams: 再 set 時の二重起動防止のため旧 stream を abort ＋ registry 全削除してから
+        // 新宣言をパースする（clearEventTokenRegistry → processOnDeclaration と同じ再配線パターン）。
+        // getterPaths / setterPaths の収集後であること（宣言バリデーションが衝突検査で参照する）。
+        // namespace proxy の memo も破棄して古い proxy を捨てる（clearCommandNamespace と対称）。
+        clearStreamNamespace(this);
+        clearStreamRegistry(this);
+        processStreamsDeclaration(this, value);
+        // 接続中の再 set（S13）は新宣言で即再起動する。
+        // 初回（_initialize 中）は _initialized が false なのでここでは起動されず、
+        // connectedCallback 側の startStreams（$connectedCallback 完了後）が担う。
+        if (this._initialized && this._rootNode !== null && !inSsr()) {
+            startStreams(this);
+            // $connectedCallback 実行中の再 set（setInitialState）では、ここで新宣言が
+            // 起動済みのため connectedCallback 末尾の startStreams を skip させる。
+            // skip しないと同一 connect サイクルで新宣言の source が 2 回起動する
+            // （1 回目は即 abort — switchMap 意味論で状態は壊れないが、副作用を持つ
+            // source が 2 回発火してしまう）。
+            this._streamsStartedGeneration = this._connectGeneration;
+        }
         this._resolveLoading?.();
     }
     get name() {
@@ -7655,6 +8908,7 @@ class State extends HTMLElement {
             raiseError(`DCC: Failed to load state: ${e}`);
         }
         defineDCC(hostElement, shadowRoot, state);
+        this._dcc = true;
         this._initialized = true;
         this._rootNode = null; // disconnectedCallbackでのstate参照を防止
         this._resolveInitialize?.();
@@ -7670,6 +8924,11 @@ class State extends HTMLElement {
     }
     async connectedCallback() {
         this._rootNode = this.getRootNode();
+        // connect 世代を進めて冒頭で捕捉する（末尾の startStreams 前に照合し、
+        // $connectedCallback の await 中に「切断 → 即再接続」された陳腐 connect の
+        // 再開からの起動を防ぐ）。前回接続中の再 set（S13）で立った
+        // _streamsStartedGeneration も世代不一致となり自然に無効化される。
+        const connectGeneration = ++this._connectGeneration;
         if (!this._initialized) {
             // DCC 検出: ShadowRoot 内かつホストに data-wc-definition がある場合
             const parentNode = this.parentNode;
@@ -7683,6 +8942,12 @@ class State extends HTMLElement {
             this._initialized = true;
             this._resolveInitialize?.();
         }
+        else if (!this._dcc && getStateElementByName(this._rootNode, this._name) !== this) {
+            // 再接続（disconnect で名前登録が解除された後の再 connect）: 登録を復元する。
+            // createState が rootNode 経由でこの要素を解決できるようにするために必要
+            // （$connectedCallback の再実行と $streams の initial からの再起動が依存する、設計書 §2-3）。
+            setStateElementByName(this._rootNode, this._name, this);
+        }
         // enable-ssr (クライアント側): SSR で $connectedCallback 済みなのでスキップ
         // inSsr() (サーバー側): レンダリング中なので実行する
         if (!this.hasAttribute('enable-ssr') || inSsr()) {
@@ -7699,16 +8964,53 @@ class State extends HTMLElement {
             Ssr.buildContent(ssrEl, stateData);
             this.parentNode?.insertBefore(ssrEl, this);
         }
+        // $streams の eager 起動（$connectedCallback 完了後、設計書 §2-3）。
+        // inSsr() 時は起動しない（SSR 出力には initial が乗る、§7-1）。
+        // enable-ssr のクライアント側は $connectedCallback をスキップしても起動する
+        // （stream はシリアライズ不能なランタイム副作用のため）。
+        // _rootNode ガード: $connectedCallback の await 中に切断された場合は起動しない。
+        // ガードなしだと startStream 内の createState が rootNode 解決（disconnectedCallback
+        // で null 化済み）の raiseError で throw し、connectedCallbackPromise が永遠に
+        // 未解決になる。「未接続の entry は restart しない」設計書 §3-2 とも整合し、
+        // _state セッター側の startStreams 前ガード（_rootNode !== null）と対称。
+        // 世代ガード（connectGeneration 照合）: await 中に「切断 → 即再接続」された場合、
+        // 新 connect が _rootNode を再設定済みで上のガードを素通りするため、世代不一致で
+        // 陳腐化した connect の再開を検出して skip する。起動点が新 connect の末尾に
+        // 一本化され、「$connectedCallback 完了後に起動」（S1）の順序保証も保たれる。
+        // _streamsStartedGeneration ガード: $connectedCallback 内の setInitialState
+        // （接続中の再 set）で _state セッター側が新宣言を起動済みの場合は skip する
+        // （skip しないと同一 connect サイクルで source が 2 回起動する、設計書 §2-3）。
+        if (!inSsr() &&
+            this._rootNode !== null &&
+            connectGeneration === this._connectGeneration &&
+            this._streamsStartedGeneration !== connectGeneration) {
+            startStreams(this);
+        }
         this._resolveConnectedCallback?.();
     }
     disconnectedCallback() {
         if (this._rootNode !== null) {
-            this._callStateDisconnectedCallback();
-            setStateElementByName(this.rootNode, this._name, null);
-            clearCommandTokenRegistry(this);
-            clearCommandNamespace(this);
-            clearEventTokenRegistry(this);
-            this._rootNode = null;
+            // try/finally: ユーザーの $disconnectedCallback が throw しても後続の後始末を
+            // 必ず実行する。特に abortAllStreams が飛ぶと stream が消費を続け（ゾンビ I/O）、
+            // activeStateElements の強参照残留で GC が妨げられ、切断済み要素が依存駆動
+            // restart の対象にも残る（設計書 §3-2 / §5-1 違反）。throw 自体は従来どおり
+            // 呼び出し元へ伝播させる（変わるのは後始末の保証のみ）。
+            try {
+                this._callStateDisconnectedCallback();
+            }
+            finally {
+                setStateElementByName(this.rootNode, this._name, null);
+                clearCommandTokenRegistry(this);
+                clearCommandNamespace(this);
+                clearEventTokenRegistry(this);
+                // stream は abort のみで registry は保持する（再接続時に同じ宣言から
+                // initial で再起動できる、設計書 §5-1 / §5-2）。
+                // namespace proxy の memo は破棄する（clearCommandNamespace と対称。
+                // registry は残るため再接続後の初回アクセスで同内容の proxy が再生成される）。
+                abortAllStreams(this);
+                clearStreamNamespace(this);
+                this._rootNode = null;
+            }
         }
     }
     get initializePromise() {
@@ -7842,8 +9144,20 @@ class State extends HTMLElement {
         this._version++;
         return this._version;
     }
+    get hasUpdatedCallback() {
+        return this._hasUpdatedCallback;
+    }
+    get crossRowListPaths() {
+        return this._crossRowListPaths;
+    }
+    addCrossRowListPath(path) {
+        this._crossRowListPaths.add(path);
+    }
     bindProperty(prop, desc) {
         Object.defineProperty(this._state, prop, desc);
+        if (prop === STATE_UPDATED_CALLBACK_NAME) {
+            this._hasUpdatedCallback = true;
+        }
     }
     setInitialState(state) {
         if (!this._initialized) {