patch-cc 0.5.0__tar.gz → 0.5.1__tar.gz

{patch_cc-0.5.0 → patch_cc-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: patch-cc
-Version: 0.5.0
+Version: 0.5.1
 Summary: Interactive patcher for the Claude Code native binary
 Project-URL: Homepage, https://github.com/anfreire/patch-cc
 Project-URL: Repository, https://github.com/anfreire/patch-cc

{patch_cc-0.5.0 → patch_cc-0.5.1}/docs/PLAYBOOK.md

@@ -824,12 +824,15 @@ for you. Each entry: what it changes, the stable anchor, and where it lives.
 
 - **`live-thinking`** — the fourteen-step patch above.
 
-  **`prop-threading`** inserts `streamingThinking:<state>,` before the
-  `conversationId` property of every props bag *handed to a component* — an
-  argument — that also carries `messages`. Being an argument is part of the
-  identity: a module-level literal, a return-value payload, or a config object
-  may legitimately carry the pair, and none of them is a render. Three things
-  do the work, and each replaced something that had broken:
+  **`prop-threading`** hands the live-thinking state to every conversation
+  render — a props bag *handed to a component* (an argument) that carries
+  `conversationId` and `messages`. Being an argument is part of the identity:
+  a module-level literal, a return-value payload, or a config object may
+  legitimately carry the pair, and none of them is a render. On a build whose
+  component owns the state it inserts `streamingThinking:<state>,` before the
+  bag's `conversationId`; on a store build it reroutes the render through a
+  wrapper component of ours that subscribes itself (below). Three things do
+  the work, and each replaced something that had broken:
 
   - **Identity is membership — of the essential props alone.** The props that
     make a render a conversation render, asked of one object rather than of a
@@ -868,37 +871,96 @@ for you. Each entry: what it changes, the stable anchor, and where it lives.
     *initialised* to is deliberately not asked: `useState(null)` is every
     build's spelling and `useState(void 0)` would be the same state, while the
     setter is the identity that matters.
-  - **The state has two homes, and each is proven by the only name it has.**
-    Through 2.1.235 the scope that hands `onStreamingThinking` declared the
-    state itself, and the state is the array pattern binding the handed setter
-    — `useState`'s pair, which nothing else names. 2.1.236 moved it into an
+  - **The state has two semantic homes, and each is identified by the only
+    name it has.** Through 2.1.235 the scope that hands `onStreamingThinking`
+    declared the state itself, and the state is the array pattern binding the
+    handed setter — `useState`'s pair, which nothing else names; its value is
+    threaded into the bag as it stands. 2.1.236 moved the state into an
     external stream store (`subscribe`/`getSnapshot`/`_publish` — the
-    `useSyncExternalStore` shape) that a component reads back by destructuring
-    a hook call (`{streamingToolUses:…}=useX(<store>)`), so the state is that
-    pattern's own `streamingThinking` binding — upstream's the day it takes
-    one, the goal achieved, and until then ours, inserted at the front of the
-    pattern. The pattern names *itself*: it binds the store's own
-    `streamingToolUses` field — the name the store publishes and the
-    transcript signature already rests on — and that membership is its whole
-    identity, provided its value is a call taking exactly one argument, one
-    answer or none (`js.only`). It was once proven by the handing instead —
-    "the call's only argument is the very expression the setter was read off"
-    — and 2.1.246 moved the handing into the engine
-    (`this.stream.setStreamingThinking`), out of every component, without
-    moving the state: four renders that plainly draw the conversation read as
-    having none in scope, with `onStreamingThinking:` still twice in the
-    bundle. The handed setter was `agentDefinitions` again — a neighbour
-    standing in for the thing itself, one more fact upstream had to keep.
-    Sole argument stays deliberate — a second is a selector whose result is
-    no longer the snapshot, and extending a pattern of unknowable provenance
-    binds `undefined` with every count green. The insertion also pays for a
-    witness the way `thinking-summaries` does: the field it binds must still
-    be named by the bundle's own objects (the store's snapshot initialiser,
-    its publish call), so a store that renames the field reads as the step
-    reporting the store rather than threading `undefined`. Two things come
-    free with the store: its setter takes functional updaters — React's own
-    contract, which the reducer splices already speak — and it hides a
-    finished block itself after 30 s, upstream's own linger.
+    `useSyncExternalStore` shape), and there the question this step used to
+    ask — *which idiom holds the state* — is retired, because it broke on
+    every answer it ever gave. Each answer was a spelling of React's
+    data-access fashion, the busiest surface upstream owns: the handing ("the
+    call's only argument is the very expression the setter was read off")
+    died on 2.1.246, when the handing moved into the engine
+    (`this.stream.setStreamingThinking`) with the state unmoved and
+    `onStreamingThinking:` still twice in the bundle; the whole-snapshot
+    destructure that replaced it (`{streamingToolUses:…}=useX(<store>)`, the
+    pattern naming the store's own field) died on 2.1.247, which reads the
+    store through per-field selectors instead (`et(<store>,wv)` with
+    `wv=(s)=>s.streamingToolUses`) — same store, same fields, a third
+    spelling, and a fourth break in this one question while the other
+    thirteen steps rode through both restructures untouched. A matcher
+    enumerating idioms is a whitelist against a fashion, each branch buying
+    exactly one build.
+
+    What survives every spelling is the **twin**. Live thinking is the
+    sibling of live tool-uses — same store, same snapshot, same renderer —
+    and the tool-use half is a feature upstream ships working, so every build
+    must carry, in the render's own reach, a read of `streamingToolUses` off
+    the store. That read is the *production*, found as whichever of the field
+    name's two grammar positions this build spells — a snapshot pattern's own
+    key (the hook call its sole argument, since a second would make the
+    pattern something other than the snapshot), or a selector beside the
+    store (a function answering the field off its own parameter, inline or
+    hoisted behind a module-local name) — one answer or none per scope
+    (`js.only`), behind whatever `??` fallback the read wears (`js.values`;
+    2.1.247 arrived wearing one). The production is then *reused verbatim* —
+    the reuse-their-expression rule `org-label` and the extras memo already
+    follow — so the state is read the way this build reads its twin, with one
+    field name swapped, and upstream can only break the claim by breaking
+    their own feature. That is the anchor-selection rule this step's whole
+    history teaches: prefer claims upstream cannot drop without paying for
+    them — the dispatch strings, the store's field names, the twin's dataflow
+    — over claims only this patch needs; a neighbour prop, a handing site and
+    a storage idiom were all the second kind, and every break above was one
+    of them.
+
+  - **On a store build the rewrite is a subscription, not a value.**
+    Threading the state's value was sound while the resolved render was
+    live-computed, and 2.1.247 retired that render too: the surviving
+    conversation render is react-compiler cached behind a fixed slot-test
+    chain (`if(Yr[15]!==ph||…)Du=r(Ih,{…})`), and a prop the compiler never
+    saw is a prop no slot tests — the element is reused, the child bails on
+    identity, and a perfectly threaded value renders exactly once.
+    Parse-green and frozen, a failure class `doctor` cannot see. So the
+    render is rerouted through a module-scope wrapper component
+    (`__cc_LiveConversation`) spliced beside it: the bag gains
+    `__cc_stream:<store>,` (the production's own store argument, whose
+    identity is as fresh as the conversation the cache already tests), the
+    render's component argument becomes the wrapper, and the wrapper
+    subscribes itself through the production's own hook with a selector of
+    ours in upstream's per-field shape, handing the component
+    `streamingThinking:` beside the spread props. The hook's optional
+    selector parameter is upstream's since the store era began — 2.1.236's
+    hook and 2.1.247's are the same two-parameter function, measured — and
+    where the destructure spelling leaves it undemonstrated, an in-module
+    hook is held to it (resolved, and required to declare a second
+    parameter), because a hook that ignored the argument would thread the
+    whole snapshot with every count green; an *imported* hook is accepted on
+    the measurement, a residue accepted by name rather than a cross-module
+    resolver built for a build that has never shipped. The transcript
+    renderer's own memo comparator compares unknown props by
+    identity (since 2.1.210), so a fresh value re-renders it and a quiet one
+    does not, cached parent or not: a component re-rendering from its own
+    subscription is the one contract in this chain no minifier or compiler
+    rewrites. Every name the wrapper re-spells — the JSX callee, the
+    component, the hook — is read off the site and owed module-scope meaning
+    (`_unshadowed`): any binding of the spelling on the way — a parameter, a
+    declarator, a function's or class's declared name, a catch clause's
+    parameter — would make the wrapper name something else that parses,
+    verifies, and throws at first render, so it refuses the wrap loudly
+    instead, and the store expression's own spellings are walked the same
+    way, bounded at the scope upstream wrote them in. The witness is
+    unchanged, paid the way `thinking-summaries` pays
+    it: the field the wrapper selects must still be named by the bundle's own
+    objects (the store's snapshot initialiser, its publish call —
+    `streamingThinking:null`, upstream's own since 2.1.236), so a store that
+    renames the field reads as the step reporting the store rather than
+    subscribing to `undefined`. Two things still come free with the store:
+    its setter takes functional updaters — React's own contract, which the
+    reducer splices already speak — and it hides a finished block itself
+    after 30 s, upstream's own linger.
 
   A render was once selected by *position* — the observation that the real sites
   fall after the state's `useState` declaration. That is worth recording as a

{patch_cc-0.5.0 → patch_cc-0.5.1}/docs/corpus.md

@@ -21,8 +21,8 @@ matches means the file changed under you, not that a number moved.
 
 ## On disk now
 
-The whole published span `2.1.210` → `2.1.246` — 2.1.230 and 2.1.244 were never
-published — one pristine binary per version, 35 in all. It straddles the
+The whole published span `2.1.210` → `2.1.247` — 2.1.230 and 2.1.244 were never
+published — one pristine binary per version, 36 in all. It straddles the
 **2.1.242 code split** (INTERNALS.md): `2.1.242`/`2.1.243` are the first
 many-module builds, and they jump ~35 MB over `2.1.241` for it. Several pairs
 share a byte count
@@ -67,10 +67,12 @@ the whole file, `sha256sum <version>.orig`) and never the size:
 | `2.1.243` | 378 MB | `4b0dafeedd0b469c41988e200036fd773e7553ba960349c9f02a82c6d1f2ba27` |
 | `2.1.245` | 392 MB | `16ad2b94deaf7b29abed966d981c9991a47af0420f5be8ed4a3f83bea9f678bc` |
 | `2.1.246` | 248 MB | `1a0a662dc1bb938eaec38545abce9a4a69113d7d7f7c5e1a553ea276617b906a` |
+| `2.1.247` | 239 MB | `5fb321bf417ffc5cd4e3f36e7c9c7e029bf47aaa36d5621db979fcc5e6eabe15` |
 
 This set covers the span the playbook's tree-move measurements were taken over
-(`2.1.210` → `2.1.233`), the 2.1.242 split, and the 2.1.246 stream-store
-migration, so each is re-checkable here rather than historical.
+(`2.1.210` → `2.1.233`), the 2.1.242 split, the 2.1.246 stream-store
+migration, and the 2.1.247 selector reads it was read back through, so each is
+re-checkable here rather than historical.
 
 ## Rebuild or extend it
 

{patch_cc-0.5.0 → patch_cc-0.5.1}/src/patch_cc/__init__.py

@@ -1,3 +1,3 @@
 """patch-cc: an interactive patcher for the Claude Code native binary."""
 
-__version__ = "0.5.0"
+__version__ = "0.5.1"

{patch_cc-0.5.0 → patch_cc-0.5.1}/src/patch_cc/patches/streaming.py

@@ -151,9 +151,14 @@ _TOOL_USES = "streamingToolUses"
 #: build in the corpus: the pair already names the same one renderer.
 _TRANSCRIPT_SIGNATURE = ("messages", _TOOL_USES)
 #: Our local for the threaded state, wherever one has to be minted: the
-#: renderer signatures `transcript-signature` extends, and the store-snapshot
-#: pattern `prop-threading` extends on builds that keep the state in a store.
+#: renderer signatures `transcript-signature` extends, and the live wrapper's
+#: own subscription on builds that keep the state in a store.
 _INJECTED = "__cc_streamingThinking"
+#: The store handle the live wrapper reads, one prop of ours beside upstream's.
+_STORE_PROP = "__cc_stream"
+#: The component a store-era render is rerouted through: the subscription the
+#: build makes for tool uses, made once more for thinking.
+_WRAPPER = "__cc_LiveConversation"
 
 
 def _outermost(scope: js.Node) -> bool:
@@ -239,55 +244,242 @@ def _bound_in_scope(site: js.Node, prop: str) -> str | None:
     return None
 
 
-def _state_in_scope(site: js.Node) -> tuple[str, js.Node | None] | None:
-    """The live-thinking state at this render: the name to thread, and the
-    snapshot pattern to extend first when the state has to be read out of a
-    store rather than a binding upstream already made.
+def _bound_names(pattern: js.Node | None) -> set[str]:
+    """Every name a binding pattern binds -- and none it merely references.
 
-    Resolved from the site outwards, so what is threaded is a variable actually
-    in scope where it is threaded -- the one thing the old matcher named as
-    owed and could not discharge without a parse. It mattered: on 2.1.232 the
+    A pattern's *keys* rename, its *defaults* are read, and only what lands on
+    the binding side is a name the scope owns; walking every identifier in the
+    subtree would claim both halves and refuse wraps over names nobody binds.
+    """
+    if pattern is None:
+        return set()
+    if pattern.type in ("identifier", "shorthand_property_identifier_pattern"):
+        return {js.text(pattern)}
+    if pattern.type == "pair_pattern":
+        return _bound_names(pattern.child_by_field_name("value"))
+    if pattern.type in ("assignment_pattern", "object_assignment_pattern"):
+        return _bound_names(pattern.child_by_field_name("left"))
+    if pattern.type in (
+        "object_pattern",
+        "array_pattern",
+        "formal_parameters",
+        "rest_pattern",
+    ):
+        found: set[str] = set()
+        for child in js.children(pattern):
+            found |= _bound_names(child)
+        return found
+    return set()
+
+
+def _binds(scope: js.Node, name: str) -> bool:
+    """Does this scope bind that spelling, by any binding form it has?
+
+    One home for the question two callers ask -- :func:`_unshadowed` to refuse
+    a wrap, :func:`_module_function` to stop a resolve -- because a binding
+    form the list misses is a hole in both at once. The forms are the
+    grammar's own: the scope's parameters, its declarators, and the
+    declarations that bind by existing -- a function's name, a class's, a
+    catch clause's parameter. The first version listed parameters, declarators
+    and function declarations, and independent review demonstrated the gap the
+    same day: a catch parameter and a class name are bindings too, and a
+    wrapper re-spelling either would parse, verify, and throw at first render.
+    """
+    for holder in (
+        scope.child_by_field_name("parameters"),
+        scope.child_by_field_name("parameter"),
+    ):
+        if name in _bound_names(holder):
+            return True
+    for declarator in js.every(scope, js.of_type("variable_declarator"), scoped=True):
+        if name in _bound_names(declarator.child_by_field_name("name")):
+            return True
+    for declaration in js.every(
+        scope,
+        js.of_type(
+            "function_declaration",
+            "generator_function_declaration",
+            "class_declaration",
+        ),
+        scoped=True,
+    ):
+        bound = declaration.child_by_field_name("name")
+        if bound is not None and js.text(bound) == name:
+            return True
+    for clause in js.every(scope, js.of_type("catch_clause"), scoped=True):
+        if name in _bound_names(clause.child_by_field_name("parameter")):
+            return True
+    return False
+
+
+def _module_function(source: Source, local: js.Node) -> js.Node | None:
+    """The function this spelling means *at this use*, resolved lexically.
+
+    A selector is usually hoisted (``function wv(sL){return
+    sL.streamingToolUses}``) and its call site carries only the minified name,
+    which is a spelling until its scope is said: in the monolith the same two
+    letters bind functions in a hundred unrelated scopes. So the walk out from
+    the use asks each scope in turn, and the innermost binding decides: a
+    function bound there is the answer, and any *other* binding of the name
+    blocks the resolve -- the engine would resolve the spelling to that
+    binding, not to a function further out, and the first version skipped
+    non-function bindings while claiming the engine's answer. Only when no
+    enclosing scope binds the name at all does the single module-scope
+    function answer from afar; anything still ambiguous answers ``None``.
+    This is a predicate's resolver, not a locator: an unresolvable name here
+    just means "not a provable selector", and the loudness belongs to the
+    step whose production then fails to resolve.
+    """
+    name = js.text(local)
+    owned: dict[int, js.Node] = {}
+    module_scope: dict[int, js.Node] = {}
+    for node in source.find_local(local, name):
+        parent = node.parent
+        if parent is None:
+            continue
+        fn = None
+        if (
+            parent.type == "function_declaration"
+            and parent.child_by_field_name("name") == node
+        ):
+            fn = parent
+        elif (
+            parent.type == "variable_declarator"
+            and parent.child_by_field_name("name") == node
+            and (value := parent.child_by_field_name("value")) is not None
+            and value.type in js.FUNCTIONS
+        ):
+            fn = value
+        if fn is None:
+            continue
+        owner = js.climb(fn.parent, lambda n: n.type in js.FUNCTIONS)
+        if owner is None or _outermost(owner):
+            module_scope[fn.id] = fn
+        else:
+            owned[owner.id] = fn
+    scope = js.climb(local, lambda n: n.type in js.FUNCTIONS)
+    while scope is not None and not _outermost(scope):
+        if scope.id in owned:
+            return owned[scope.id]
+        if _binds(scope, name):
+            return None
+        scope = js.climb(scope.parent, lambda n: n.type in js.FUNCTIONS)
+    found = list(module_scope.values())
+    return found[0] if len(found) == 1 else None
+
+
+def _selects(source: Source, argument: js.Node, field: str) -> bool:
+    """Is this argument a *selector* for that snapshot field?
+
+    A selector is a function answering the field read off its own parameter --
+    2.1.247's ``function wv(sL){return sL.streamingToolUses}``, handed to the
+    store hook beside the store. The field name is the identity, in the one
+    grammar position a per-field read gives it; whether the function is inline
+    or hoisted behind a name is spelling (:func:`_module_function`), and the
+    answer routes through :func:`js.values` like every other answer here.
+    """
+    fn = argument
+    if argument.type == "identifier":
+        resolved = _module_function(source, argument)
+        if resolved is None:
+            return False
+        fn = resolved
+    if fn.type not in js.FUNCTIONS:
+        return False
+    taken = [js.binding(parameter) for parameter in js.positional(fn)]
+    if len(taken) != 1:
+        return False
+    param = js.text(taken[0])
+    block = js.body(fn)
+    if block is None:
+        return False
+    answers = (
+        [block]
+        if block.type != "statement_block"
+        else [
+            expression
+            for statement in js.every(fn, js.of_type("return_statement"), scoped=True)
+            for expression in js.children(statement)
+        ]
+    )
+    return any(
+        js.reads(value, field) and js.text(js.receiver(value)) == param
+        for answer in answers
+        for value in js.values(answer)
+    )
+
+
+@dataclass(slots=True)
+class _PairState:
+    """The component-owned state (through 2.1.235): thread its value."""
+
+    state: str
+
+
+@dataclass(slots=True)
+class _StoreRead:
+    """A store-era production: wrap the render with a subscription through it.
+
+    ``selected`` records whether the spelling itself demonstrated the hook
+    taking a selector -- what licenses :func:`_wrap` to skip its arity check.
+    """
+
+    production: js.Node
+    store: js.Node
+    selected: bool
+
+
+def _state_in_scope(source: Source, site: js.Node) -> _PairState | _StoreRead | None:
+    """The live-thinking state at this render: how this build's own scope
+    reaches the live stream data, resolved from the site outwards.
+
+    Outwards, so what is spliced is valid where it is spliced: on 2.1.232 the
     two conversation renders sit in *different* top-level components, only one
-    of which declares the state, and threading a single bundle-wide answer into
-    both put an out-of-scope identifier into a shipped binary. It parses, so no
-    gate could see it; it throws when that component renders. The binding
-    threaded has to be one this render can *see* (:func:`js.visible`), which a
-    nested function's is not and a block's own is not either.
-
-    The state has two upstream shapes, and each is proven by the only name it
-    has:
-
-    - **A ``useState`` pair** -- every build through 2.1.235. Nothing names the
-      pair itself (``useState(null)`` and ``useState(void 0)`` are the same
-      state, so the initialiser is never asked); what names it is its *setter*,
-      handed to the reducer as ``onStreamingThinking:`` in this very scope. The
-      state is the array pattern whose second binding is a handed setter. The
-      handing is asked of the whole subtree on purpose -- a scope may hand it
-      from inside a callback, and that says nothing about where the state
-      lives.
-    - **A store snapshot** -- 2.1.236 moved the state into an external stream
-      store (``subscribe``/``getSnapshot``/``_publish``), which a component
-      reads back by destructuring a hook call
-      (``{streamingToolUses:…}=useX(<store>)``). That pattern *does* name
-      itself: it binds the store's own ``streamingToolUses`` field -- the name
-      the store publishes and the transcript signature already rests on -- and
-      that membership is its identity, the same question every props bag here
-      answers. Which scope hands the setter is deliberately no part of it:
-      through 2.1.245 the same component handed ``<store>.setStreamingThinking``
-      to the reducer, and 2.1.246 moved the handing into the engine
-      (``this.stream.setStreamingThinking``) without moving the state -- an
-      identity resting on the handing read four renders that plainly draw the
-      conversation as having none in scope. The handed setter was
-      `agentDefinitions` again: a neighbour standing in for the thing itself,
-      one more fact upstream had to keep. The state is the pattern's own
-      ``streamingThinking`` binding: upstream's, the day it takes one -- the
-      goal achieved, same as every other judged-on-achievement step -- and
-      until then ours, inserted into the pattern. The pattern is proven a
-      *produced* snapshot by its value being a call with exactly one argument;
-      sole argument is deliberate -- a second is a selector whose result is no
-      longer the snapshot, and extending a pattern of unknowable provenance
-      binds ``undefined`` with every count green, so that shape is refused
-      loudly instead (one answer or none, :func:`js.only`).
+    of which declares the state, and a single bundle-wide answer put an
+    out-of-scope identifier into a shipped binary -- it parses, so no gate
+    could see it, and it throws when that component renders. A binding used
+    here has to be one this render can *see* (:func:`js.visible`).
+
+    The state has two semantic homes, and each is identified by the only name
+    it has:
+
+    - **The component's own pair** -- every build through 2.1.235. Nothing
+      names the pair itself (``useState(null)`` and ``useState(void 0)`` are
+      the same state, so the initialiser is never asked); what names it is its
+      *setter*, handed to the reducer as ``onStreamingThinking:`` in this very
+      scope. The state is the array pattern whose second binding is a handed
+      setter, and the handing is asked of the whole subtree on purpose -- a
+      scope may hand it from inside a callback, and that says nothing about
+      where the state lives. Answered as a :class:`_PairState`: the state is
+      a binding of this scope, and threading its value is the whole rewrite.
+    - **The stream store** -- 2.1.236 on. Here the question this function used
+      to ask -- *which idiom holds the state* -- is retired, because it broke
+      on every answer it ever gave: the whole-snapshot destructure it knew
+      (``{streamingToolUses:…}=useX(<store>)``, 2.1.236-2.1.246) was retired
+      by 2.1.247's per-field selector reads (``et(<store>,wv)``), the handing
+      it once rested on moved into the engine on 2.1.246, and each repair
+      bought exactly one build. Those are spellings of React's data-access
+      fashion, the busiest surface upstream owns, and a matcher enumerating
+      them is a whitelist against a fashion. What survives every spelling is
+      the **twin**: live tool-uses ride the same store, and that feature ships
+      working, so somewhere in this scope upstream reads ``streamingToolUses``
+      off the store -- as a snapshot pattern's own key, or through a selector
+      handed to the hook beside the store. That read is the **production**,
+      answered as a :class:`_StoreRead`: the hook and the store, upstream's
+      own, read out of whatever spelling this build uses and reused verbatim
+      by :func:`_wrap` -- the same
+      reuse-their-expression rule `org-label` and the extras memo follow,
+      because what is copied cannot drift from what it was copied from.
+
+    A production is a declarator this site can see whose value is one call
+    among its possible values (:func:`js.values` -- 2.1.247 arrived with a
+    ``??`` fallback on the read, and the exact-node question would have read
+    it as no call at all), taking the store alone (the destructure spelling:
+    the pattern names the field as its own key, sole argument since a second
+    would make the pattern something other than the snapshot) or the store
+    beside exactly one selector for the field (the selector spelling). One
+    answer or none per scope (:func:`js.only`): two reads of the store is a
+    cardinality change to be told about, not a first to win.
     """
     scope = js.climb(site, lambda n: n.type in js.FUNCTIONS)
     while scope is not None and not _outermost(scope):
@@ -300,7 +492,7 @@ def _state_in_scope(site: js.Node) -> tuple[str, js.Node | None] | None:
             if (pair := js.named(node)) is not None
             and (value := pair.child_by_field_name("value")) is not None
         }
-        snapshots: dict[int, js.Node] = {}
+        productions: dict[int, _StoreRead] = {}
         for declarator in js.every(scope, js.of_type("variable_declarator")):
             name = declarator.child_by_field_name("name")
             if name is None or not js.visible(declarator, site):
@@ -308,49 +500,209 @@ def _state_in_scope(site: js.Node) -> tuple[str, js.Node | None] | None:
             if name.type == "array_pattern":
                 bound = [js.text(child) for child in name.named_children]
                 if len(bound) == 2 and bound[1] in setters:
-                    return bound[0], None
-                continue
-            value = declarator.child_by_field_name("value")
-            if name.type != "object_pattern" or not js.children(name):
-                continue
-            if value is None or value.type != "call_expression":
+                    return _PairState(bound[0])
                 continue
-            if len(js.arguments(value)) != 1:
+            calls = [
+                v
+                for v in js.values(declarator.child_by_field_name("value"))
+                if v.type == "call_expression"
+            ]
+            if len(calls) != 1:
                 continue
-            if _TOOL_USES not in js.props(name):
-                continue
-            snapshots[declarator.id] = name
-        pattern = js.only(
-            list(snapshots.values()), "snapshot reads of the live-thinking store"
-        )
-        if pattern is not None:
-            carried = js.props(pattern)
-            if _STREAMING in carried:
-                return js.text(js.binding(carried[_STREAMING])), None
-            return _INJECTED, pattern
+            production = calls[0]
+            args = js.arguments(production)
+            if name.type == "object_pattern" and js.children(name):
+                if _TOOL_USES not in js.props(name) or len(args) != 1:
+                    continue
+                productions[declarator.id] = _StoreRead(production, args[0], False)
+            elif name.type == "identifier" and len(args) == 2:
+                chosen = [a for a in args if _selects(source, a, _TOOL_USES)]
+                if len(chosen) == 1:
+                    store = args[0] if chosen[0] == args[1] else args[1]
+                    productions[declarator.id] = _StoreRead(production, store, True)
+        found = js.only(list(productions.values()), "reads of the live stream store")
+        if found is not None:
+            return found
         scope = js.climb(scope.parent, lambda n: n.type in js.FUNCTIONS)
     return None
 
 
+def _module_statement(node: js.Node) -> js.Node:
+    """The module-scope statement this node is part of -- where a declaration
+    meant for the whole module goes.
+
+    Module scope is a fact about the build, not a fixed depth: a split
+    module's ``program`` is the scope, and the monolith's is the wrapper
+    IIFE's own body (:func:`_outermost` -- inserting before the IIFE itself
+    would put the declaration outside every binding it needs).
+    """
+    statement = node
+    while statement.parent is not None:
+        parent = statement.parent
+        if parent.type == "program":
+            return statement
+        if parent.type == "statement_block":
+            owner = js.climb(parent, lambda n: n.type in js.FUNCTIONS)
+            if owner is not None and _outermost(owner):
+                return statement
+        statement = parent
+    return statement
+
+
+def _root(expression: js.Node) -> js.Node | None:
+    """The identifier an expression resolves through -- ``X`` in
+    ``X.createElement`` -- or nothing when there is no lone name to check."""
+    node: js.Node | None = expression
+    while node is not None and node.type in (
+        "member_expression",
+        "subscript_expression",
+        "parenthesized_expression",
+    ):
+        node = node.child_by_field_name("object") or next(iter(js.children(node)), None)
+    return node if node is not None and node.type == "identifier" else None
+
+
+def _unshadowed(name: str, site: js.Node, *, above: js.Node | None = None) -> bool:
+    """Does this spelling keep its meaning from the site up to ``above``?
+
+    The live wrapper is a module-scope function that re-spells names it read
+    off the render -- the JSX callee, the component, the hook -- and a
+    component-scope binding of the same spelling between the two would make
+    the wrapper name something else entirely: it parses, verifies, and throws
+    when the wrapper first renders, the 2.1.232 class of damage. So the name
+    is walked from the site outwards, and any scope that binds it
+    (:func:`_binds`, every binding form at once) refuses the wrap loudly
+    rather than shipping it. With no ``above`` the walk runs to module scope,
+    for a name the wrapper re-spells there; the store expression's spellings
+    name ``above`` instead -- the scope upstream wrote them in -- because a
+    spelling copied *down* into the bag only has to mean at the bag what it
+    meant where it was copied from.
+    """
+    scope = js.climb(site, lambda n: n.type in js.FUNCTIONS)
+    while scope is not None and not _outermost(scope):
+        if above is not None and scope.id == above.id:
+            return True
+        if _binds(scope, name):
+            return False
+        scope = js.climb(scope.parent, lambda n: n.type in js.FUNCTIONS)
+    return True
+
+
+def _wrap(
+    source: Source, bag: js.Node, resolved: _StoreRead, serial: int
+) -> list[Edit] | str:
+    """Reroute this render through a component of ours that subscribes itself.
+
+    Threading the state's *value* into the props bag was sound while the
+    resolved render was live-computed, and 2.1.247 retired that render: the
+    surviving one is react-compiler cached behind a fixed slot-test chain
+    (``if(Yr[15]!==ph||…)Du=r(Ih,{…})``), and a prop the compiler never saw is
+    a prop no slot tests -- the element is reused, the child bails out on
+    identity, and a perfectly threaded value renders exactly once. The
+    compiler's cache is a representation this patch refuses to model; what
+    needs no modelling is React's own contract that a component re-renders
+    from its own subscription. So the render is rerouted through a wrapper
+    that makes the subscription this scope stopped making: it reads the store
+    through the *production's own hook* -- whose optional selector parameter
+    is upstream's since the store era began (2.1.236's hook and 2.1.247's are
+    the same two-parameter function, measured) -- with a selector of ours in
+    upstream's own per-field shape, and hands the component the state under
+    the prop every other step already speaks. The transcript renderer's own
+    memo comparator compares unknown props by identity (and has since
+    2.1.210), so a fresh value re-renders it and a quiet one does not, cached
+    parent or not.
+
+    Everything the wrapper spells is read off the site -- the JSX callee, the
+    component, the hook -- so the one thing owed is that those names mean at
+    module scope what they mean at the render (:func:`_unshadowed`); a
+    shadowed name refuses the wrap loudly, and the answer is the *reason*, so
+    the step's note names what refused rather than one sentence covering
+    three facts. The store expression is not module-scope and never has to
+    be: it rides into the props bag (``__cc_stream:``), evaluated exactly
+    where the old threading evaluated its state, its spellings walked the
+    same way but bounded at the scope upstream wrote them in, and the bag
+    being cached is harmless for it -- the store's identity is as fresh as
+    the conversation the cache already tests. A bag that is not a JSX props
+    argument (the render call's second argument) is refused the same way:
+    rerouting a call this step misread would be rubble, not a wrap.
+
+    Where the destructure spelling leaves the selector undemonstrated, an
+    in-module hook is held to it -- resolved and required to declare a second
+    parameter -- because a hook that ignores the argument would thread the
+    whole snapshot as the state with every count green, the one silent
+    failure this rewrite could otherwise add. A hook defined elsewhere is
+    accepted on the measurement above: following the import hop would mean
+    cross-module function resolution built for a build that has never
+    shipped, and that residue -- a future destructure build importing a
+    selectorless hook -- is accepted here by name rather than guessed at.
+    """
+    handed = bag.parent
+    render = handed.parent if handed is not None else None
+    if render is None:
+        return "the conversation bag is not a component call's props"
+    args = js.arguments(render)
+    if len(args) < 2 or args[1] != bag:
+        return "the conversation bag is not a component call's props"
+    component = args[0]
+    jsx = render.child_by_field_name("function")
+    hook = resolved.production.child_by_field_name("function")
+    if jsx is None or hook is None:
+        return "the conversation bag is not a component call's props"
+    for expression in (jsx, component, hook):
+        root = _root(expression)
+        if root is None or not _unshadowed(js.text(root), bag):
+            return "a name the live wrapper needs is not the render's to use"
+    origin = js.climb(resolved.production, lambda n: n.type in js.FUNCTIONS)
+    references = {
+        js.text(node) for node in js.every(resolved.store, js.of_type("identifier"))
+    }
+    if resolved.store.type == "identifier":
+        references.add(js.text(resolved.store))
+    if origin is not None and any(
+        not _unshadowed(reference, bag, above=origin) for reference in references
+    ):
+        return "the store's spelling does not reach the render"
+    if not resolved.selected and hook.type == "identifier":
+        defined = _module_function(source, hook)
+        if defined is not None and len(js.positional(defined)) < 2:
+            return "the store hook takes no selector on this build"
+    name = _WRAPPER if serial == 0 else f"{_WRAPPER}{serial + 1}"
+    declaration = (
+        f"function {name}(__cc_props){{"
+        f"let {_INJECTED}={js.text(hook)}(__cc_props.{_STORE_PROP},"
+        f"(__cc_snapshot)=>__cc_snapshot.{_STREAMING});"
+        f"return {js.text(jsx)}({js.text(component)},"
+        f"{{...__cc_props,{_STREAMING}:{_INJECTED}}})}}"
+    )
+    return [
+        Edit.before(_module_statement(render), declaration),
+        Edit.replace(component, name),
+        Edit.before(
+            js.entry(js.props(bag)[_CONVERSATION[0]]),
+            f"{_STORE_PROP}:{js.text(resolved.store)},",
+        ),
+    ]
+
+
 def _step_prop_threading(source: Source, outcome: Outcome) -> Source:
     """Pass the live-thinking state into the renderers that need it."""
     step = outcome.step("prop-threading")
-    edits = []
+    edits: list[Edit] = []
     renders = _conversation_renders(source)
-    # The durable witness behind a snapshot insertion: the field it binds is
-    # one the bundle's own objects still name (the store's snapshot initialiser
-    # and its publish call, on 2.1.236). Extending the pattern is a rewrite the
-    # matcher can only vouch for itself, and a store that renames the field
-    # would leave it threading `undefined` with every count green -- the same
+    # The durable witness behind a store read: the field the wrapper selects
+    # is one the bundle's own objects still name (the store's snapshot
+    # initialiser and its publish call -- `streamingThinking:null`, upstream's
+    # own since 2.1.236). A store that renames the field would leave the
+    # wrapper subscribing to `undefined` with every count green -- the same
     # hole `thinking-summaries` pays a header-name count for.
     field_named = any(
         (pair := js.named(node)) is not None and pair.type == "pair"
         for node in source.find(_STREAMING)
     )
-    extended: set[int] = set()
+    wrapped = 0
     unreached = 0
     for bag in renders:
-        resolved = _state_in_scope(bag)
+        resolved = _state_in_scope(source, bag)
         if resolved is None:
             # By design on every build we hold: the resume view, the transcript
             # overlay and the message picker draw conversations too, in scopes
@@ -360,26 +712,33 @@ def _step_prop_threading(source: Source, outcome: Outcome) -> Source:
             # 2.1.232 out-of-scope threading).
             unreached += 1
             continue
-        state, pattern = resolved
-        if pattern is not None and not field_named:
-            step.note(f"the stream store no longer names a {_STREAMING} field")
-            continue
-        step.candidates += 1
-        step.applied += 1
         carried = js.props(bag)
         if _STREAMING in carried:
             # Upstream already threads it into this render; the goal achieved.
+            step.candidates += 1
+            step.applied += 1
             continue
-        if pattern is not None and pattern.id not in extended:
-            # Two renders in one scope read one snapshot: the pattern gains the
-            # field once, at the front, which is valid whatever it ends with.
-            extended.add(pattern.id)
+        if isinstance(resolved, _PairState):
+            step.candidates += 1
+            step.applied += 1
             edits.append(
-                Edit.before(pattern.named_children[0], f"{_STREAMING}:{state},")
+                Edit.before(
+                    js.entry(carried[_CONVERSATION[0]]),
+                    f"{_STREAMING}:{resolved.state},",
+                )
             )
-        edits.append(
-            Edit.before(js.entry(carried[_CONVERSATION[0]]), f"{_STREAMING}:{state},")
-        )
+            continue
+        if not field_named:
+            step.note(f"the stream store no longer names a {_STREAMING} field")
+            continue
+        step.candidates += 1
+        wrap = _wrap(source, bag, resolved, wrapped)
+        if isinstance(wrap, str):
+            step.note(wrap)
+            continue
+        step.applied += 1
+        wrapped += 1
+        edits += wrap
     # Printed every run, green ones included: an early warning held back until
     # something breaks arrives too late to be one.
     step.note(