위젯 값 변경 → dependents-only 리액티브 재실행 경로

WS setUiValue {blockId, elementId, value, blocks} 메시지를 추가해, 위젯 값이 바뀌면 워커 store를
갱신(session.setUiValue → engine → worker command)한 뒤 그 변수를 쓰는 다운스트림 셀만 재실행한다
(includeSource=False, 위젯 정의 셀은 제외해 값 리셋 방지). kernelWebSocket의 reactive 송신 로직을
_runReactiveAndSend로 추출해 executeReactive와 공유.

테스트: setUiValue 50 → consumer 셀이 100으로 갱신, executionOrder가 위젯 셀(w)을 제외하고 [c]만.
세션 레벨 + WS 라운드트립 양쪽 검증. 프론트 송신은 다음 커밋(H2c).

Author: eddmpython

src/codaro/api/kernelWebSocket.py

@@ -14,6 +14,7 @@
     WsGetVariablesMessage,
     WsInterruptMessage,
     WsResetMessage,
+    WsSetUiValueMessage,
     WsStatusMessage,
 )
 from ..kernel.uiEventFlow import resetKernelUiCallbacks
@@ -89,6 +90,8 @@ async def handleKernelWsMessage(websocket: WebSocket, session: Any, message: Any
         logger.debug("kernel-variables %s", formatLogFields(transport="ws", sessionId=session.sessionId))
     elif isinstance(message, WsExecuteReactiveMessage):
         await handleReactiveMessage(websocket, session, message, logger)
+    elif isinstance(message, WsSetUiValueMessage):
+        await handleSetUiValueMessage(websocket, session, message, logger)
     elif isinstance(message, WsResetMessage):
         session.reset()
         resetKernelUiCallbacks()
@@ -106,6 +109,8 @@ def validateKernelWsMessage(message: dict[str, Any]) -> Any:
         return WsGetVariablesMessage.model_validate(message)
     if messageType == "executeReactive":
         return WsExecuteReactiveMessage.model_validate(message)
+    if messageType == "setUiValue":
+        return WsSetUiValueMessage.model_validate(message)
     if messageType == "reset":
         return WsResetMessage.model_validate(message)
     raise ValueError(f"Unsupported websocket message type: {messageType or 'unknown'}.")
@@ -152,28 +157,55 @@ async def handleReactiveMessage(
     message: WsExecuteReactiveMessage,
     logger: Any,
 ) -> None:
-    requestId = message.requestId
-    changedBlockId = message.blockId
     blocks = [block.model_dump() for block in message.blocks]
+    await _runReactiveAndSend(
+        websocket, session, message.requestId, message.blockId, blocks, logger,
+        includeSource=True, kind="reactive",
+    )
+
+
+async def handleSetUiValueMessage(
+    websocket: WebSocket,
+    session: Any,
+    message: WsSetUiValueMessage,
+    logger: Any,
+) -> None:
+    # 위젯 값 store 갱신 → 그 변수를 쓰는 다운스트림만 재실행(위젯 셀 자신은 제외).
+    session.setUiValue(message.elementId, message.value)
+    blocks = [block.model_dump() for block in message.blocks]
+    await _runReactiveAndSend(
+        websocket, session, message.requestId, message.blockId, blocks, logger,
+        includeSource=False, kind="setUiValue",
+    )
+
 
+async def _runReactiveAndSend(
+    websocket: WebSocket,
+    session: Any,
+    requestId: str,
+    changedBlockId: str,
+    blocks: list[dict[str, Any]],
+    logger: Any,
+    *,
+    includeSource: bool,
+    kind: str,
+) -> None:
     if not await _safeSendJson(websocket, WsStatusMessage(type="status", engineStatus="busy").model_dump()):
         return
     reactiveEvents: list[dict[str, Any]] = []
 
     async def eventHandler(event: Any) -> None:
-        reactiveEvents.append(
-            {
-                "blockId": event.blockId,
-                "eventType": event.eventType,
-            }
-        )
+        reactiveEvents.append({"blockId": event.blockId, "eventType": event.eventType})
         await sendExecutionEvent(websocket, requestId, event)
 
-    payload = await executeKernelReactive(session, blocks, changedBlockId, eventHandler=eventHandler)
+    payload = await executeKernelReactive(
+        session, blocks, changedBlockId, eventHandler=eventHandler, includeSource=includeSource
+    )
     logger.debug(
         "kernel-reactive %s",
         formatLogFields(
             transport="ws",
+            kind=kind,
             sessionId=session.sessionId,
             requestId=requestId,
             changedBlockId=changedBlockId,

src/codaro/kernel/protocol.py

@@ -111,6 +111,15 @@ class WsExecuteReactiveMessage(BaseModel):
     blocks: list[ReactiveBlockPayload]
 
 
+class WsSetUiValueMessage(BaseModel):
+    type: Literal["setUiValue"] = "setUiValue"
+    requestId: str
+    blockId: str
+    elementId: str
+    value: Any = None
+    blocks: list[ReactiveBlockPayload]
+
+
 class WsResetMessage(BaseModel):
     type: Literal["reset"] = "reset"
 

src/codaro/kernel/session.py

@@ -65,6 +65,9 @@ async def engineEventHandler(event: RuntimeExecutionEvent) -> None:
             status=result.status,
         )
 
+    def setUiValue(self, elementId: str, value: object) -> None:
+        self._engine.setUiValue(elementId, value)
+
     def removeCellDefinitions(self, blockId: str) -> None:
         self._engine.removeBlockDefinitions(blockId)
 

src/codaro/runtime/localEngine.py

@@ -283,6 +283,15 @@ def removeBlockDefinitions(self, blockId: str) -> None:
             self._replaceWorker()
             self._cellDefinitions.pop(blockId, None)
 
+    def setUiValue(self, elementId: str, value: Any) -> None:
+        """리액티브 위젯 값을 워커 store에 갱신한다(registry/변수 불변, 값만)."""
+        if not self._hasLiveWorker():
+            return
+        try:
+            self._sendCommand({"action": "setUiValue", "elementId": elementId, "value": value})
+        except (BrokenPipeError, EOFError, OSError):
+            self._replaceWorker()
+
     def reset(self, *, preserveDefinitions: bool = False) -> None:
         if self._hasLiveWorker():
             action = "resetVariables" if preserveDefinitions else "reset"

src/codaro/runtime/localWorker.py

@@ -26,7 +26,7 @@
 from ..document.analysis import analyzeCode
 from ..errorGuard import safeRepr
 from ..outputDescriptor import isDescriptorPayload
-from ..uiValue import beginBlock, resetStore
+from ..uiValue import beginBlock, resetStore, setStoredValue
 
 
 def runLocalWorker(
@@ -145,6 +145,11 @@ def emitEvent(eventType: str, payload: Any = None) -> None:
                 )
                 continue
 
+            if action == "setUiValue":
+                setStoredValue(command["elementId"], command.get("value"))
+                _workerSend(connection, {"ok": True})
+                continue
+
             _workerSend(connection, {"error": f"Unsupported worker action: {action}"})
         except (BrokenPipeError, EOFError, OSError):
             _uninstallInterruptTrace(interruptFlag)

tests/testServerApi.py

@@ -891,6 +891,52 @@ def testKernelWebSocketReactiveAndReset() -> None:
         assert websocket.receive_json() == {"type": "status", "engineStatus": "ready"}
 
 
+def testKernelWebSocketSetUiValueRerunsDependentsOnly() -> None:
+    client = TestClient(createServerApp())
+    sessionId = client.post("/api/kernel/create", json={}).json()["sessionId"]
+    widgetBlock = {
+        "id": "w",
+        "type": "code",
+        "content": "from codaro.outputDescriptor import ui\nslider = ui.slider(0, 100)",
+    }
+    consumerBlock = {"id": "c", "type": "code", "content": "doubled = slider.value * 2\ndoubled"}
+
+    def drainUntilReady(websocket) -> list[dict]:
+        messages: list[dict] = []
+        while True:
+            message = websocket.receive_json()
+            messages.append(message)
+            if message.get("type") == "status" and message.get("engineStatus") == "ready":
+                return messages
+
+    with client.websocket_connect(f"/ws/kernel/{sessionId}") as websocket:
+        websocket.receive_json()  # initial ready
+        for requestId, block in (("rw", widgetBlock), ("rc", consumerBlock)):
+            websocket.send_json({"type": "execute", "requestId": requestId, "blockId": block["id"], "code": block["content"]})
+            consumerMessages = drainUntilReady(websocket)
+        firstResult = next(m for m in consumerMessages if m["type"] == "result")
+        assert "0" in str(firstResult["data"])  # slider.value=0 → doubled=0
+
+        websocket.send_json({
+            "type": "setUiValue",
+            "requestId": "rs",
+            "blockId": "w",
+            "elementId": "w#0",
+            "value": 50,
+            "blocks": [widgetBlock, consumerBlock],
+        })
+        messages: list[dict] = []
+        while True:
+            message = websocket.receive_json()
+            messages.append(message)
+            if message.get("type") == "reactiveComplete":
+                break
+        complete = messages[-1]
+        assert complete["executionOrder"] == ["c"]  # 위젯 셀 w는 재실행 제외
+        results = [m for m in messages if m["type"] == "result"]
+        assert any("100" in str(result["data"]) for result in results)  # 50 * 2
+
+
 def testKernelWebSocketRejectsInvalidPayload() -> None:
     client = TestClient(createServerApp())
     sessionId = client.post("/api/kernel/create", json={}).json()["sessionId"]

tests/testUiValueBinding.py

@@ -3,6 +3,7 @@
 
 import asyncio
 
+from codaro.kernel.reactive import executeReactive
 from codaro.kernel.session import KernelSession
 from codaro.uiValue import (
     UiValue,
@@ -81,3 +82,23 @@ def testSessionSliderRendersAndValueReadable() -> None:
     consumer = _run(session.execute("print(slider.value)", blockId="b2"))
     assert "0" in consumer.stdout
     session.dispose()
+
+
+def testSetUiValueRerunsDependentsOnly() -> None:
+    session = KernelSession()
+    blocks = [
+        {"id": "w", "type": "code", "content": "from codaro.outputDescriptor import ui\nslider = ui.slider(0, 100)\nslider"},
+        {"id": "c", "type": "code", "content": "doubled = slider.value * 2\nprint(doubled)"},
+    ]
+    _run(session.execute(blocks[0]["content"], blockId="w"))
+    initial = _run(session.execute(blocks[1]["content"], blockId="c"))
+    assert "0" in initial.stdout  # slider.value=0 → doubled=0
+
+    # 위젯 값 변경 → store 갱신, dependents만 재실행(위젯 셀 w 제외).
+    session.setUiValue("w#0", 50)
+    results, order = _run(executeReactive(session, blocks, "w", includeSource=False))
+    assert "w" not in order  # 위젯 정의 셀은 재실행 안 함(값 리셋 방지)
+    assert "c" in order
+    consumer = next(result for result in results if result.blockId == "c")
+    assert "100" in consumer.stdout  # 50 * 2
+    session.dispose()