tigrbl-runtime 0.4.5.dev1__py3-none-any.whl → 0.4.5.dev6__py3-none-any.whl

tigrbl_runtime/channel/_asgi_jsonrpc.py

@@ -36,3 +36,14 @@ def _resolve_jsonrpc_endpoint(ctx: Any, channel: OpChannel) -> str | None:
         if path == _normalize_path(mapped_path):
             return endpoint
     return None
+
+
+_NO_ERROR_DATA = object()
+
+
+def _jsonrpc_error_payload(code: int, message: str, request_id: Any, *, data: Any = _NO_ERROR_DATA) -> dict[str, Any]:
+    """Construct the existing compatibility error envelope without choosing policy."""
+    error: dict[str, Any] = {"code": code, "message": message}
+    if data is not _NO_ERROR_DATA:
+        error["data"] = data
+    return {"jsonrpc": "2.0", "error": error, "id": request_id}

tigrbl_runtime/channel/_asgi_send.py

@@ -19,6 +19,52 @@ from ._asgi_webtransport import (
 )
 
 
+def _webtransport_event_projection(ctx: Any) -> Mapping[str, Any]:
+    projection = ctx.get("channel_event_projection")
+    if isinstance(projection, Mapping):
+        return projection
+    channel = ctx.get("channel")
+    state = getattr(channel, "state", None) if channel is not None else None
+    if isinstance(state, dict):
+        projection = state.get("event_projection")
+        if isinstance(projection, Mapping):
+            return projection
+    return {}
+
+
+def _is_receive_only_webtransport_stream(ctx: Any) -> bool:
+    projection = _webtransport_event_projection(ctx)
+    if (
+        projection.get("lane") == "unidi_client_stream"
+        or projection.get("exchange") == "client_stream"
+    ):
+        return True
+    message = ctx.get("channel_message")
+    return bool(
+        isinstance(message, Mapping)
+        and message.get("type") == "webtransport.stream.receive"
+        and message.get("stream_direction") == "client_to_server"
+    )
+
+
+def _validate_receive_only_webtransport_output(payload: Any) -> None:
+    if payload is None:
+        return
+    if not isinstance(payload, Mapping) or not any(
+        key in payload
+        for key in ("bidirectional_streams", "unidirectional_streams", "datagrams")
+    ):
+        raise ValueError(
+            "cannot automatically reply on a client_to_server WebTransport stream; "
+            "return None or emit an explicit server_to_client stream or datagram"
+        )
+    if payload.get("bidirectional_streams"):
+        raise ValueError(
+            "bidirectional_streams output is invalid for a client_to_server "
+            "WebTransport stream; use unidirectional_streams or datagrams"
+        )
+
+
 async def _send_session_payload(
     env: Any,
     payload: Any,
@@ -87,11 +133,15 @@ async def _send_webtransport_payload(env: Any, ctx: Any, payload: Any) -> None:
         for key in ("bidirectional_streams", "unidirectional_streams", "datagrams")
     )
     if structured_payload:
-        if not queue and message_type in {
-            "webtransport.stream.receive",
-            "webtransport.datagram.receive",
-        }:
-            queue = [message]
+        if (
+            message_type
+            in {
+                "webtransport.stream.receive",
+                "webtransport.datagram.receive",
+            }
+            and message not in queue
+        ):
+            queue.append(message)
         if not queue:
             raise ValueError(
                 "structured WebTransport payloads require inbound stream.receive or datagram.receive events"
@@ -125,6 +175,12 @@ async def _send_webtransport_payload(env: Any, ctx: Any, payload: Any) -> None:
             )
     if payload is not None:
         base = {**message, "session_id": session_id}
+        temp = getattr(ctx, "temp", None)
+        dispatch = temp.get("dispatch") if isinstance(temp, Mapping) else None
+        if isinstance(dispatch, Mapping):
+            request = dispatch.get("rpc") or dispatch.get("rpc_envelope")
+            if isinstance(request, Mapping) and request.get("id") is not None:
+                base["jsonrpc_request_id"] = request.get("id")
         if structured_payload:
             for event in _webtransport_structured_payload_events(
                 session_id=session_id,
@@ -151,6 +207,14 @@ async def _send_webtransport_payload(env: Any, ctx: Any, payload: Any) -> None:
                 )
                 await _run_webtransport_hooks(env, ctx, direction="send", message=event)
                 await send(event)
+            if isinstance(state, dict):
+                raw_queue = state.get("receive_queue")
+                consumed = min(len(queue), len(raw_queue or ()))
+                if isinstance(raw_queue, deque):
+                    for _ in range(consumed):
+                        raw_queue.popleft()
+                elif isinstance(raw_queue, list):
+                    del raw_queue[:consumed]
         else:
             event = _webtransport_payload_event(base=base, payload=payload)
             if isinstance(session, WebTransportSessionState):
@@ -222,6 +286,16 @@ async def send_transport_via_channel(env: Any, ctx: Any) -> None:
         if payload is None:
             payload = getattr(ctx, "result", None)
         if scope_type == "webtransport":
+            if _is_receive_only_webtransport_stream(ctx):
+                _validate_receive_only_webtransport_output(payload)
+                if payload is None:
+                    if isinstance(state, dict):
+                        state["egress_disposition"] = "suppressed_receive_only"
+                        state["emitted"] = False
+                    if isinstance(egress, dict):
+                        egress["response_suppressed"] = True
+                        egress["suppression_reason"] = "receive_only_stream"
+                    return
             await _send_webtransport_payload(env, ctx, payload)
         else:
             await _send_session_payload(

tigrbl_runtime/channel/_asgi_webtransport.py

@@ -15,9 +15,12 @@ from tigrbl_kernel.channel_taxonomy import (
     webtransport_event_metadata as _webtransport_event_metadata,
 )
 from tigrbl_kernel.webtransport_events import validate_webtransport_event_payload
+from tigrbl_kernel.webtransport_session_plan import WebTransportSessionPlan
 from tigrbl_atoms.runtime_channel import WebTransportSessionState
 from tigrbl_typing.channel import OpChannel
 
+MAX_EAGER_DRAIN_EVENTS = 16
+
 
 def _webtransport_scope_state(env: Any) -> dict[str, Any]:
     scope = getattr(env, "scope", {}) or {}
@@ -242,6 +245,20 @@ async def _receive_webtransport_session_messages(
     queue: deque[Mapping[str, Any]] = deque()
     session: WebTransportSessionState | None = None
 
+    session_plan = shared_state.get("session_plan")
+    if not isinstance(session_plan, WebTransportSessionPlan):
+        session_plan = WebTransportSessionPlan()
+        shared_state["session_plan"] = session_plan
+
+    async def _receive_record_or_event() -> Mapping[str, Any]:
+        if session_plan.has_pending():
+            return session_plan.pop_pending()
+        while True:
+            raw = _enrich_webtransport_message(env, await receive())
+            session_plan.project_receive(raw)
+            if session_plan.has_pending():
+                return session_plan.pop_pending()
+
     def _ensure_session(message: Mapping[str, Any]) -> WebTransportSessionState | None:
         nonlocal session
         session_id = message.get("session_id") or _webtransport_scope_session_id(env)
@@ -292,6 +309,8 @@ async def _receive_webtransport_session_messages(
                 channel="receive",
                 payload={**message, "session_id": state.get("session_id")},
             )
+            state["event_projection"] = dict(projection)
+            ctx["channel_event_projection"] = dict(projection)
             if current_session is not None:
                 current_session.apply_event(
                     event=message_type,
@@ -334,18 +353,26 @@ async def _receive_webtransport_session_messages(
             return
         ctx["channel_message"] = message
 
-    message = await receive()
+    message = await _receive_record_or_event()
     await _record_payload_message(message)
     if message.get("type") == "webtransport.connect":
         if "channel_message" not in ctx:
-            message = await receive()
+            message = await _receive_record_or_event()
             await _record_payload_message(message)
 
-    while shared_state.get("eager_drain") is True and not state.get("disconnected"):
+    drained_events = 0
+    while (
+        shared_state.get("eager_drain") is True
+        and not state.get("disconnected")
+        and drained_events < MAX_EAGER_DRAIN_EVENTS
+    ):
         try:
-            message = await asyncio.wait_for(receive(), timeout=0.001)
+            message = await asyncio.wait_for(
+                _receive_record_or_event(), timeout=0.001
+            )
         except TimeoutError:
             break
         await _record_payload_message(message)
+        drained_events += 1
 
     state["receive_queue"] = queue

tigrbl_runtime/executors/ctx/context.py

@@ -16,11 +16,7 @@ from typing import (
     runtime_checkable,
 )
 
-try:
-    from sqlalchemy.ext.asyncio import AsyncSession
-    from sqlalchemy.orm import Session
-except Exception:  # pragma: no cover - optional ORM dependency for runtime typing
-    AsyncSession = Session = Any  # type: ignore[assignment]
+AsyncSession = Session = Any  # type: ignore[assignment]
 
 from tigrbl_atoms.types import BaseCtx
 from tigrbl_base._base import AttrDict

tigrbl_runtime/executors/ctx/hot_namespace_values.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from collections.abc import Mapping as ABCMapping
+from typing import Any, Mapping
+
+from .hot_state import (
+    HotCtx,
+    _ensure_hot_assembled_values_view,
+    _ensure_hot_in_values_view,
+    _ensure_hot_virtual_in_view,
+    _LAZY_MISSING,
+)
+
+
+def _coerce_optional_dict(value: Any) -> dict[str, Any] | None:
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, ABCMapping):
+        return dict(value)
+    return None
+
+
+def _namespace_lazy_value(kind: str, hot: HotCtx, key: str) -> Any:
+    if kind == "route":
+        if key == "selector":
+            value = hot.route_selector
+            return value if value else _LAZY_MISSING
+        if key == "protocol":
+            value = hot.route_protocol
+            return value if value else _LAZY_MISSING
+        if key == "program_id":
+            value = (
+                hot.route_program_id if hot.route_program_id >= 0 else hot.program_id
+            )
+            return value if value >= 0 else _LAZY_MISSING
+        if key == "opmeta_index":
+            value = (
+                hot.route_opmeta_index
+                if hot.route_opmeta_index >= 0
+                else hot.route_program_id
+            )
+            return value if value >= 0 else _LAZY_MISSING
+        if key == "method_not_allowed":
+            return True if hot.route_method_not_allowed else _LAZY_MISSING
+        if key == "short_circuit":
+            return True if hot.route_short_circuit else _LAZY_MISSING
+        if key == "payload":
+            if hot.route_payload is not None:
+                return hot.route_payload
+            value = _ensure_hot_in_values_view(hot)
+            return value if value is not None else _LAZY_MISSING
+        if key == "path_params":
+            value = hot.route_path_params or hot.path_params
+            return value if value is not None else _LAZY_MISSING
+        if key == "rpc_envelope":
+            value = hot.route_rpc_envelope or hot.dispatch_rpc_envelope
+            return value if value is not None else _LAZY_MISSING
+        return _LAZY_MISSING
+    if kind == "dispatch":
+        if key == "binding_protocol":
+            value = hot.dispatch_binding_protocol
+            return value if value else _LAZY_MISSING
+        if key == "binding_selector":
+            value = hot.dispatch_binding_selector
+            return value if value else _LAZY_MISSING
+        if key == "channel_protocol":
+            value = hot.dispatch_channel_protocol
+            return value if value else _LAZY_MISSING
+        if key == "channel_selector":
+            value = hot.dispatch_channel_selector
+            return value if value else _LAZY_MISSING
+        if key in {"normalized_input", "parsed_payload"}:
+            value = _ensure_hot_in_values_view(hot)
+            return value if value is not None else _LAZY_MISSING
+        if key == "rpc":
+            value = hot.dispatch_rpc_envelope or hot.route_rpc_envelope
+            return value if value is not None else _LAZY_MISSING
+        if key == "rpc_method":
+            value = hot.dispatch_rpc_method
+            return value if value is not None else _LAZY_MISSING
+        return _LAZY_MISSING
+    if kind == "egress":
+        if key == "transport_response":
+            value = hot.egress_transport_response
+            return value if value is not None else _LAZY_MISSING
+        if key == "sent":
+            return True if hot.egress_sent else _LAZY_MISSING
+        return _LAZY_MISSING
+    return _LAZY_MISSING
+
+
+def _sync_hot_namespace_value(kind: str, hot: HotCtx, key: str, value: Any) -> None:
+    if kind == "route":
+        if key == "selector" and isinstance(value, str):
+            hot.route_selector = value
+        elif key == "protocol" and isinstance(value, str):
+            hot.route_protocol = value
+        elif key == "program_id" and isinstance(value, int):
+            hot.route_program_id = value
+            hot.program_id = value
+        elif key == "opmeta_index" and isinstance(value, int):
+            hot.route_opmeta_index = value
+            if hot.route_program_id < 0:
+                hot.route_program_id = value
+            if hot.program_id < 0:
+                hot.program_id = value
+        elif key == "method_not_allowed":
+            hot.route_method_not_allowed = bool(value)
+        elif key == "short_circuit":
+            hot.route_short_circuit = bool(value)
+        elif key == "payload":
+            hot.route_payload = _coerce_optional_dict(value)
+        elif key == "path_params":
+            path_params = _coerce_optional_dict(value)
+            hot.route_path_params = path_params
+            hot.path_params = path_params
+        elif key == "rpc_envelope":
+            envelope = _coerce_optional_dict(value)
+            hot.route_rpc_envelope = envelope
+            if envelope is not None:
+                hot.dispatch_jsonrpc_request_id = envelope.get("id")
+                method = envelope.get("method")
+                hot.dispatch_rpc_method = method if isinstance(method, str) else None
+    elif kind == "dispatch":
+        if key == "binding_protocol" and isinstance(value, str):
+            hot.dispatch_binding_protocol = value
+        elif key == "binding_selector" and isinstance(value, str):
+            hot.dispatch_binding_selector = value
+        elif key == "channel_protocol" and isinstance(value, str):
+            hot.dispatch_channel_protocol = value
+        elif key == "channel_selector" and isinstance(value, str):
+            hot.dispatch_channel_selector = value
+        elif key == "rpc":
+            envelope = _coerce_optional_dict(value)
+            hot.dispatch_rpc_envelope = envelope
+            if envelope is not None:
+                hot.dispatch_jsonrpc_request_id = envelope.get("id")
+                method = envelope.get("method")
+                hot.dispatch_rpc_method = method if isinstance(method, str) else None
+        elif key == "rpc_method":
+            hot.dispatch_rpc_method = value if isinstance(value, str) else None
+        elif key in {"normalized_input", "parsed_payload"}:
+            route_payload = _coerce_optional_dict(value)
+            if route_payload is not None:
+                hot.route_payload = route_payload
+        elif key == "jsonrpc_request_id":
+            hot.dispatch_jsonrpc_request_id = value
+    elif kind == "egress":
+        if key == "transport_response":
+            hot.egress_transport_response = _coerce_optional_dict(value)
+        elif key == "sent":
+            hot.egress_sent = bool(value)
+
+
+def _clear_hot_namespace_value(kind: str, hot: HotCtx, key: str) -> None:
+    if kind == "route":
+        if key == "selector":
+            hot.route_selector = ""
+        elif key == "protocol":
+            hot.route_protocol = ""
+        elif key == "program_id":
+            hot.route_program_id = -1
+        elif key == "opmeta_index":
+            hot.route_opmeta_index = -1
+        elif key == "method_not_allowed":
+            hot.route_method_not_allowed = False
+        elif key == "short_circuit":
+            hot.route_short_circuit = False
+        elif key == "payload":
+            hot.route_payload = None
+        elif key == "path_params":
+            hot.route_path_params = None
+            hot.path_params = None
+        elif key == "rpc_envelope":
+            hot.route_rpc_envelope = None
+            hot.dispatch_jsonrpc_request_id = None
+            hot.dispatch_rpc_method = None
+    elif kind == "dispatch":
+        if key == "binding_protocol":
+            hot.dispatch_binding_protocol = ""
+        elif key == "binding_selector":
+            hot.dispatch_binding_selector = ""
+        elif key == "channel_protocol":
+            hot.dispatch_channel_protocol = ""
+        elif key == "channel_selector":
+            hot.dispatch_channel_selector = ""
+        elif key == "rpc":
+            hot.dispatch_rpc_envelope = None
+            hot.dispatch_jsonrpc_request_id = None
+            hot.dispatch_rpc_method = None
+        elif key == "rpc_method":
+            hot.dispatch_rpc_method = None
+        elif key == "jsonrpc_request_id":
+            hot.dispatch_jsonrpc_request_id = None
+    elif kind == "egress":
+        if key == "transport_response":
+            hot.egress_transport_response = None
+        elif key == "sent":
+            hot.egress_sent = False
+

tigrbl_runtime/executors/ctx/hot_namespaces.py

@@ -10,193 +10,12 @@ from .hot_state import (
     _ensure_hot_virtual_in_view,
     _LAZY_MISSING,
 )
-
-
-def _coerce_optional_dict(value: Any) -> dict[str, Any] | None:
-    if isinstance(value, dict):
-        return value
-    if isinstance(value, ABCMapping):
-        return dict(value)
-    return None
-
-
-def _namespace_lazy_value(kind: str, hot: HotCtx, key: str) -> Any:
-    if kind == "route":
-        if key == "selector":
-            value = hot.route_selector
-            return value if value else _LAZY_MISSING
-        if key == "protocol":
-            value = hot.route_protocol
-            return value if value else _LAZY_MISSING
-        if key == "program_id":
-            value = (
-                hot.route_program_id if hot.route_program_id >= 0 else hot.program_id
-            )
-            return value if value >= 0 else _LAZY_MISSING
-        if key == "opmeta_index":
-            value = (
-                hot.route_opmeta_index
-                if hot.route_opmeta_index >= 0
-                else hot.route_program_id
-            )
-            return value if value >= 0 else _LAZY_MISSING
-        if key == "method_not_allowed":
-            return True if hot.route_method_not_allowed else _LAZY_MISSING
-        if key == "short_circuit":
-            return True if hot.route_short_circuit else _LAZY_MISSING
-        if key == "payload":
-            if hot.route_payload is not None:
-                return hot.route_payload
-            value = _ensure_hot_in_values_view(hot)
-            return value if value is not None else _LAZY_MISSING
-        if key == "path_params":
-            value = hot.route_path_params or hot.path_params
-            return value if value is not None else _LAZY_MISSING
-        if key == "rpc_envelope":
-            value = hot.route_rpc_envelope or hot.dispatch_rpc_envelope
-            return value if value is not None else _LAZY_MISSING
-        return _LAZY_MISSING
-    if kind == "dispatch":
-        if key == "binding_protocol":
-            value = hot.dispatch_binding_protocol
-            return value if value else _LAZY_MISSING
-        if key == "binding_selector":
-            value = hot.dispatch_binding_selector
-            return value if value else _LAZY_MISSING
-        if key == "channel_protocol":
-            value = hot.dispatch_channel_protocol
-            return value if value else _LAZY_MISSING
-        if key == "channel_selector":
-            value = hot.dispatch_channel_selector
-            return value if value else _LAZY_MISSING
-        if key in {"normalized_input", "parsed_payload"}:
-            value = _ensure_hot_in_values_view(hot)
-            return value if value is not None else _LAZY_MISSING
-        if key == "rpc":
-            value = hot.dispatch_rpc_envelope or hot.route_rpc_envelope
-            return value if value is not None else _LAZY_MISSING
-        if key == "rpc_method":
-            value = hot.dispatch_rpc_method
-            return value if value is not None else _LAZY_MISSING
-        return _LAZY_MISSING
-    if kind == "egress":
-        if key == "transport_response":
-            value = hot.egress_transport_response
-            return value if value is not None else _LAZY_MISSING
-        if key == "sent":
-            return True if hot.egress_sent else _LAZY_MISSING
-        return _LAZY_MISSING
-    return _LAZY_MISSING
-
-
-def _sync_hot_namespace_value(kind: str, hot: HotCtx, key: str, value: Any) -> None:
-    if kind == "route":
-        if key == "selector" and isinstance(value, str):
-            hot.route_selector = value
-        elif key == "protocol" and isinstance(value, str):
-            hot.route_protocol = value
-        elif key == "program_id" and isinstance(value, int):
-            hot.route_program_id = value
-            hot.program_id = value
-        elif key == "opmeta_index" and isinstance(value, int):
-            hot.route_opmeta_index = value
-            if hot.route_program_id < 0:
-                hot.route_program_id = value
-            if hot.program_id < 0:
-                hot.program_id = value
-        elif key == "method_not_allowed":
-            hot.route_method_not_allowed = bool(value)
-        elif key == "short_circuit":
-            hot.route_short_circuit = bool(value)
-        elif key == "payload":
-            hot.route_payload = _coerce_optional_dict(value)
-        elif key == "path_params":
-            path_params = _coerce_optional_dict(value)
-            hot.route_path_params = path_params
-            hot.path_params = path_params
-        elif key == "rpc_envelope":
-            envelope = _coerce_optional_dict(value)
-            hot.route_rpc_envelope = envelope
-            if envelope is not None:
-                hot.dispatch_jsonrpc_request_id = envelope.get("id")
-                method = envelope.get("method")
-                hot.dispatch_rpc_method = method if isinstance(method, str) else None
-    elif kind == "dispatch":
-        if key == "binding_protocol" and isinstance(value, str):
-            hot.dispatch_binding_protocol = value
-        elif key == "binding_selector" and isinstance(value, str):
-            hot.dispatch_binding_selector = value
-        elif key == "channel_protocol" and isinstance(value, str):
-            hot.dispatch_channel_protocol = value
-        elif key == "channel_selector" and isinstance(value, str):
-            hot.dispatch_channel_selector = value
-        elif key == "rpc":
-            envelope = _coerce_optional_dict(value)
-            hot.dispatch_rpc_envelope = envelope
-            if envelope is not None:
-                hot.dispatch_jsonrpc_request_id = envelope.get("id")
-                method = envelope.get("method")
-                hot.dispatch_rpc_method = method if isinstance(method, str) else None
-        elif key == "rpc_method":
-            hot.dispatch_rpc_method = value if isinstance(value, str) else None
-        elif key in {"normalized_input", "parsed_payload"}:
-            route_payload = _coerce_optional_dict(value)
-            if route_payload is not None:
-                hot.route_payload = route_payload
-        elif key == "jsonrpc_request_id":
-            hot.dispatch_jsonrpc_request_id = value
-    elif kind == "egress":
-        if key == "transport_response":
-            hot.egress_transport_response = _coerce_optional_dict(value)
-        elif key == "sent":
-            hot.egress_sent = bool(value)
-
-
-def _clear_hot_namespace_value(kind: str, hot: HotCtx, key: str) -> None:
-    if kind == "route":
-        if key == "selector":
-            hot.route_selector = ""
-        elif key == "protocol":
-            hot.route_protocol = ""
-        elif key == "program_id":
-            hot.route_program_id = -1
-        elif key == "opmeta_index":
-            hot.route_opmeta_index = -1
-        elif key == "method_not_allowed":
-            hot.route_method_not_allowed = False
-        elif key == "short_circuit":
-            hot.route_short_circuit = False
-        elif key == "payload":
-            hot.route_payload = None
-        elif key == "path_params":
-            hot.route_path_params = None
-            hot.path_params = None
-        elif key == "rpc_envelope":
-            hot.route_rpc_envelope = None
-            hot.dispatch_jsonrpc_request_id = None
-            hot.dispatch_rpc_method = None
-    elif kind == "dispatch":
-        if key == "binding_protocol":
-            hot.dispatch_binding_protocol = ""
-        elif key == "binding_selector":
-            hot.dispatch_binding_selector = ""
-        elif key == "channel_protocol":
-            hot.dispatch_channel_protocol = ""
-        elif key == "channel_selector":
-            hot.dispatch_channel_selector = ""
-        elif key == "rpc":
-            hot.dispatch_rpc_envelope = None
-            hot.dispatch_jsonrpc_request_id = None
-            hot.dispatch_rpc_method = None
-        elif key == "rpc_method":
-            hot.dispatch_rpc_method = None
-        elif key == "jsonrpc_request_id":
-            hot.dispatch_jsonrpc_request_id = None
-    elif kind == "egress":
-        if key == "transport_response":
-            hot.egress_transport_response = None
-        elif key == "sent":
-            hot.egress_sent = False
+from .hot_namespace_values import (
+    _clear_hot_namespace_value,
+    _coerce_optional_dict,
+    _namespace_lazy_value,
+    _sync_hot_namespace_value,
+)
 
 
 class _HotNamespaceDict(dict[str, Any]):

tigrbl_runtime/executors/packed/__init__.py

@@ -0,0 +1,4 @@
+from ._shared import _DirectWebSocketUnary
+from .executor import PackedPlanExecutor
+
+__all__ = ["PackedPlanExecutor"]