tigrbl-runtime 0.4.5.dev4__py3-none-any.whl → 0.4.5.dev8__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/packed/_shared.py

@@ -13,7 +13,7 @@ from types import SimpleNamespace
 from tigrbl_atoms._ctx import _ctx_view
 from tigrbl_core.config.constants import __JSONRPC_DEFAULT_ENDPOINT_MAPPINGS__
 from tigrbl_atoms.types import build_error_ctx, error_phase_for, select_error_edge
-from tigrbl_atoms.atoms.wire.validate_in import _coerce_if_needed
+from tigrbl_core.schema.materialize import _materialize_field_value
 from tigrbl_atoms.atoms.transport.websocket_unary import (
     DirectWebSocketUnary as _DirectWebSocketUnary,
 )
@@ -91,6 +91,7 @@ from tigrbl_kernel.packed_selectors import (
     resolve_hot_exact_websocket_routes as _kernel_resolve_hot_exact_websocket_routes,
     resolve_program_id_from_exact_route as _kernel_resolve_program_id_from_exact_route,
     resolve_program_id_from_exact_websocket as _kernel_resolve_program_id_from_exact_websocket,
+    resolve_webtransport_program as _kernel_resolve_webtransport_program,
 )
 from tigrbl_typing.status.exceptions import HTTPException
 from tigrbl_typing.phases import canonicalize_phase_input as normalize_phase
@@ -165,5 +166,3 @@ __all__ = [
     for name in globals()
     if not name.startswith("__") or name == "__JSONRPC_DEFAULT_ENDPOINT_MAPPINGS__"
 ]
-
-

tigrbl_runtime/executors/packed/batch.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from ._shared import *
+from ...channel._asgi_jsonrpc import _jsonrpc_error_payload
 
 
 class _PackedBatchMixin:
@@ -210,15 +211,7 @@ class _PackedBatchMixin:
 
         rpc_code = _HTTP_TO_RPC.get(int(status_code), -32603)
         data = dict(detail) if isinstance(detail, Mapping) else {"detail": detail}
-        return {
-            "jsonrpc": "2.0",
-            "error": {
-                "code": rpc_code,
-                "message": ERROR_MESSAGES.get(rpc_code, "Internal error"),
-                "data": data,
-            },
-            "id": rpc_id,
-        }
+        return _jsonrpc_error_payload(rpc_code, ERROR_MESSAGES.get(rpc_code, 'Internal error'), rpc_id, data=data)
 
     @staticmethod
     def _reject_jsonrpc_wrapper_keys(
@@ -273,11 +266,7 @@ class _PackedBatchMixin:
         for item in batch_payload:
             if not isinstance(item, Mapping):
                 responses.append(
-                    {
-                        "jsonrpc": "2.0",
-                        "error": {"code": -32600, "message": "Invalid Request"},
-                        "id": None,
-                    }
+                    _jsonrpc_error_payload(-32600, 'Invalid Request', None)
                 )
                 continue
 
@@ -285,25 +274,13 @@ class _PackedBatchMixin:
             method = item.get("method")
             if not isinstance(method, str):
                 responses.append(
-                    {
-                        "jsonrpc": "2.0",
-                        "error": {"code": -32601, "message": "Method not found"},
-                        "id": rpc_id,
-                    }
+                    _jsonrpc_error_payload(-32601, 'Method not found', rpc_id)
                 )
                 continue
 
             if not callable(router_or_app) or not scope:
                 responses.append(
-                    {
-                        "jsonrpc": "2.0",
-                        "error": {
-                            "code": -32603,
-                            "message": "Internal error",
-                            "data": {"detail": "RPC invoker unavailable."},
-                        },
-                        "id": rpc_id,
-                    }
+                    _jsonrpc_error_payload(-32603, 'Internal error', rpc_id, data={'detail': 'RPC invoker unavailable.'})
                 )
                 continue
 
@@ -323,15 +300,7 @@ class _PackedBatchMixin:
                 await router_or_app(dict(scope), _receive, _send)
             except Exception as exc:
                 responses.append(
-                    {
-                        "jsonrpc": "2.0",
-                        "error": {
-                            "code": -32603,
-                            "message": "Internal error",
-                            "data": {"detail": str(exc)},
-                        },
-                        "id": rpc_id,
-                    }
+                    _jsonrpc_error_payload(-32603, 'Internal error', rpc_id, data={'detail': str(exc)})
                 )
                 continue
 
@@ -349,15 +318,7 @@ class _PackedBatchMixin:
             try:
                 decoded = json.loads(response_body.decode("utf-8"))
             except Exception:
-                decoded = {
-                    "jsonrpc": "2.0",
-                    "error": {
-                        "code": -32603,
-                        "message": "Internal error",
-                        "data": {"detail": response_body.decode("utf-8", errors="replace")},
-                    },
-                    "id": rpc_id,
-                }
+                decoded = _jsonrpc_error_payload(-32603, 'Internal error', rpc_id, data={'detail': response_body.decode('utf-8', errors='replace')})
             if isinstance(decoded, Mapping):
                 response = dict(decoded)
                 if response.get("id") is None:

tigrbl_runtime/executors/packed/execute.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from ._shared import *
+from ...channel._asgi_jsonrpc import _jsonrpc_error_payload
 
 
 class _PackedExecuteMixin:
@@ -29,7 +30,11 @@ class _PackedExecuteMixin:
         ):
             request = self._ensure_hot_request(ctx, hot)
             body_bytes = await self._ensure_body_bytes(ctx, hot)
-            if request is not None and body_bytes is not None and hasattr(request, "body"):
+            if (
+                request is not None
+                and body_bytes is not None
+                and hasattr(request, "body")
+            ):
                 request.body = body_bytes
             if not hot.parsed_json_loaded:
                 parsed = None
@@ -40,7 +45,10 @@ class _PackedExecuteMixin:
                         parsed = None
                 hot.parsed_json = parsed
                 hot.parsed_json_loaded = True
-            if isinstance(hot.parsed_json, Mapping) and hot.parsed_json.get("jsonrpc") == "2.0":
+            if (
+                isinstance(hot.parsed_json, Mapping)
+                and hot.parsed_json.get("jsonrpc") == "2.0"
+            ):
                 params = hot.parsed_json.get("params", {})
                 if isinstance(params, Mapping) and set(params) == {"params"}:
                     egress = temp.setdefault("egress", {})
@@ -62,21 +70,30 @@ class _PackedExecuteMixin:
                 )
                 return
 
-        program_id = self._require_program_id_from_ctx(ctx)
-        if program_id < 0:
+        if hot.scope_type == "webtransport":
+            program_id = self._prime_webtransport_program(ctx, env, plan, packed)
+        else:
+            program_id = self._require_program_id_from_ctx(ctx)
+        if program_id < 0 and hot.scope_type != "webtransport":
             program_id = self._prime_exact_route_program(ctx, env, packed)
-        if program_id < 0:
-            program_id = await self._prime_exact_jsonrpc_program(
-                ctx, env, plan, packed
-            )
-        if program_id < 0:
+        if program_id < 0 and hot.scope_type != "webtransport":
+            program_id = await self._prime_exact_jsonrpc_program(ctx, env, plan, packed)
+        if program_id < 0 and hot.scope_type != "webtransport":
             program_id = self._prime_exact_channel_program(ctx, env, plan, packed)
         if program_id < 0:
             program_id = await self._probe_ingress_for_program(ctx, plan, packed)
         if program_id < 0:
             scope = getattr(env, "scope", {}) or {}
-            transport = hot.egress_transport_response
-            if isinstance(transport, dict):
+            wt_selection = temp.get("webtransport_selection")
+            disposition = getattr(wt_selection, "disposition", None)
+            rpc_envelope = getattr(wt_selection, "rpc_envelope", None)
+            if disposition in {"method_not_found", "invalid_jsonrpc"}:
+                ctx.result = _jsonrpc_error_payload(
+                    -32601 if disposition == "method_not_found" else -32600,
+                    "Method not found" if disposition == "method_not_found" else "Invalid Request",
+                    rpc_envelope.get("id") if isinstance(rpc_envelope, Mapping) else None,
+                )
+            if disposition in {"lifecycle", "method_not_found", "invalid_jsonrpc"} or isinstance(hot.egress_transport_response, dict):
                 await _send_transport_response(env, ctx)
                 return
 
@@ -176,7 +193,7 @@ class _PackedExecuteMixin:
                 error_phase_segments = self._resolve_error_segments(
                     packed,
                     program_id,
-            )
+                )
 
             try:
                 await self._run_hot_jsonrpc_security_dependencies(
@@ -190,10 +207,11 @@ class _PackedExecuteMixin:
                     opview = getattr(ctx, "opview", None)
                     schema_in = getattr(opview, "schema_in", None)
                     field_names = tuple(getattr(schema_in, "fields", ()) or ())
-                    self._reject_jsonrpc_wrapper_keys(
-                        hot.parsed_json.get("params", {}),
-                        field_names=field_names,
-                    )
+                    if field_names:
+                        self._reject_jsonrpc_wrapper_keys(
+                            hot.parsed_json.get("params", {}),
+                            field_names=field_names,
+                        )
                 await self._resolve_program_runner(
                     packed,
                     program_id,
@@ -252,8 +270,15 @@ class _PackedExecuteMixin:
                 status_code = int(getattr(std, "status_code", 500) or 500)
                 persistence_error = self._is_persistence_exception(exc)
                 if persistence_error:
-                    status_code = 500
-                    detail = "Internal error"
+                    if status_code >= 500:
+                        status_code = 500
+                        detail = "Internal error"
+                    else:
+                        detail = (
+                            "Conflict"
+                            if status_code == 409
+                            else "Persistence constraint failed"
+                        )
                 payload = self._jsonrpc_error_payload(
                     ctx,
                     status_code,

tigrbl_runtime/executors/packed/input_compile.py

@@ -102,7 +102,9 @@ class _PackedInputCompileMixin:
             if not (0 <= slot_id < len(field_names)):
                 continue
             field_name = field_names[slot_id]
-            field_meta = by_field.get(field_name, {}) if isinstance(by_field, Mapping) else {}
+            field_meta = (
+                by_field.get(field_name, {}) if isinstance(by_field, Mapping) else {}
+            )
             source_mask = self._hot_int_at(
                 packed,
                 "param_shape_source_masks",
@@ -156,7 +158,11 @@ class _PackedInputCompileMixin:
         )
         paired_index = getattr(opview, "paired_index", {}) or {}
         for field_name, desc in paired_index.items():
-            if isinstance(field_name, str) and field_name and field_name not in field_index:
+            if (
+                isinstance(field_name, str)
+                and field_name
+                and field_name not in field_index
+            ):
                 reserved_input_keys.add(field_name)
             alias = desc.get("alias") if isinstance(desc, Mapping) else None
             if isinstance(alias, str) and alias:
@@ -217,18 +223,15 @@ class _PackedInputCompileMixin:
                 continue
 
             target_type = field_plan.py_type
-            if value is not None and isinstance(target_type, type):
-                ok, new_val, msg = _coerce_if_needed(
-                    value,
-                    target_type,
-                    allow=field_plan.coerce,
-                )
-                if not ok:
+            if value is not None and target_type is not None:
+                try:
+                    new_val = _materialize_field_value(value, target_type)
+                except Exception:
                     errors.append(
                         {
                             "field": field_plan.field_name,
                             "code": "type_mismatch",
-                            "message": msg or f"Expected {target_type.__name__}.",
+                            "message": f"Could not materialize {target_type!s}.",
                         }
                     )
                     continue
@@ -267,7 +270,9 @@ class _PackedInputCompileMixin:
                     )
 
         hot.compiled_in_invalid = bool(errors)
-        hot.compiled_in_errors = tuple(dict(error) for error in errors) if errors else None
+        hot.compiled_in_errors = (
+            tuple(dict(error) for error in errors) if errors else None
+        )
         hot.compiled_in_coerced = tuple(coerced)
         hot.in_present_names = tuple(
             field_names[idx]
@@ -306,7 +311,11 @@ class _PackedInputCompileMixin:
 
             absent.append(field_plan.field_name)
             default_fn = field_plan.default_factory
-            if callable(default_fn) and field_plan.in_enabled and not field_plan.is_virtual:
+            if (
+                callable(default_fn)
+                and field_plan.in_enabled
+                and not field_plan.is_virtual
+            ):
                 if view is None:
                     view = _ctx_view(ctx)
                 try:

tigrbl_runtime/executors/packed/input_extract.py

@@ -185,7 +185,7 @@ class _PackedInputExtractMixin:
         body_payload = hot.parsed_json
         if hot.transport_kind_id == _TRANSPORT_KIND_JSONRPC and isinstance(body_payload, dict):
             body_payload = body_payload.get("params", {})
-        if hot.transport_kind_id == _TRANSPORT_KIND_JSONRPC:
+        if hot.transport_kind_id == _TRANSPORT_KIND_JSONRPC and plan.field_names:
             self._reject_jsonrpc_wrapper_keys(
                 body_payload,
                 field_names=plan.field_names,

tigrbl_runtime/executors/packed/route_select.py

@@ -1,34 +1,110 @@
 from __future__ import annotations
 
 from ._shared import *
+from .route_select_websocket import _PackedWebSocketRouteSelectMixin
 
 
-class _PackedRouteSelectMixin:
-    def _resolve_hot_exact_websocket_routes(
-        self,
-        plan: KernelPlan,
-        packed: PackedKernel,
-    ) -> Mapping[tuple[str, str], int]:
-        return _kernel_resolve_hot_exact_websocket_routes(
-            plan,
-            packed,
-            self._hot_exact_websocket_route_cache,
-        )
+class _PackedRouteSelectMixin(_PackedWebSocketRouteSelectMixin):
+
 
-    def _resolve_program_id_from_exact_websocket(
+    def _prime_webtransport_program(
         self,
+        ctx: _Ctx,
+        env: Any,
         plan: KernelPlan,
         packed: PackedKernel,
-        protocol: str,
-        path: str,
     ) -> int:
-        return _kernel_resolve_program_id_from_exact_websocket(
+        del packed
+        hot = self._ensure_hot_ctx(ctx, env)
+        if hot.scope_type != "webtransport" or not hot.path:
+            return -1
+        message = ctx.get("channel_message")
+        if not isinstance(message, Mapping):
+            return -1
+
+        selection = _kernel_resolve_webtransport_program(
             plan,
-            packed,
-            protocol,
-            path,
-            self._hot_exact_websocket_route_cache,
+            path=hot.path,
+            message=message,
+        )
+        temp = getattr(ctx, "temp", None)
+        if not isinstance(temp, dict):
+            return -1
+        temp["webtransport_selection"] = selection
+        if selection.path_params is not None:
+            path_params = dict(selection.path_params)
+            hot.path_params = path_params
+            hot.route_path_params = path_params
+            temp.setdefault("route", {})["path_params"] = path_params
+            temp.setdefault("dispatch", {})["path_params"] = path_params
+            channel = ctx.get("channel")
+            if channel is not None:
+                channel.path_params = path_params
+
+        if selection.program_id < 0:
+            return -1
+
+        protocol = (
+            "webtransport.jsonrpc"
+            if selection.rpc_envelope is not None
+            else "webtransport"
         )
+        selector = hot.path
+        if selection.rpc_envelope is not None:
+            rpc_method = selection.rpc_envelope.get("method")
+            selector = f"{hot.path}:{rpc_method}"
+            params = selection.rpc_envelope.get("params")
+            hot.parsed_json = dict(selection.rpc_envelope)
+            hot.parsed_json_loaded = True
+            hot.route_rpc_envelope = dict(selection.rpc_envelope)
+            hot.dispatch_rpc_envelope = dict(selection.rpc_envelope)
+            hot.dispatch_jsonrpc_request_id = selection.rpc_envelope.get("id")
+            hot.dispatch_rpc_method = (
+                rpc_method if isinstance(rpc_method, str) else None
+            )
+            hot.route_payload = dict(params) if isinstance(params, Mapping) else {}
+            route = temp.setdefault("route", {})
+            dispatch = temp.setdefault("dispatch", {})
+            route["rpc_envelope"] = dict(selection.rpc_envelope)
+            route["payload"] = hot.route_payload
+            dispatch["rpc"] = dict(selection.rpc_envelope)
+            dispatch["rpc_method"] = rpc_method
+            dispatch["parsed_payload"] = hot.route_payload
+
+        program_id = int(selection.program_id)
+        hot.program_id = program_id
+        hot.route_program_id = program_id
+        hot.route_opmeta_index = program_id
+        hot.route_protocol = protocol
+        hot.route_selector = selector
+        hot.dispatch_binding_protocol = protocol
+        hot.dispatch_binding_selector = selector
+        hot.dispatch_channel_protocol = "webtransport"
+        hot.dispatch_channel_selector = hot.path
+        hot.transport_kind_id = (
+            _TRANSPORT_KIND_JSONRPC
+            if selection.rpc_envelope is not None
+            else _TRANSPORT_KIND_CHANNEL
+        )
+        temp["program_id"] = program_id
+        temp.setdefault("route", {}).update(
+            {
+                "program_id": program_id,
+                "opmeta_index": program_id,
+                "protocol": protocol,
+                "selector": selector,
+            }
+        )
+        temp.setdefault("dispatch", {}).update(
+            {
+                "binding_protocol": protocol,
+                "binding_selector": selector,
+                "channel_protocol": "webtransport",
+                "channel_selector": hot.path,
+            }
+        )
+        ctx.path = hot.path
+        return program_id
 
     def _prime_exact_channel_program(
         self,
@@ -140,7 +216,9 @@ class _PackedRouteSelectMixin:
                 owner = ctx.get(owner_key)
             mounts = getattr(owner, "_jsonrpc_endpoint_mounts", None)
             if isinstance(mounts, Mapping):
-                endpoint = mounts.get(path) or mounts.get(hot.path) or mounts.get(f"{path}/")
+                endpoint = (
+                    mounts.get(path) or mounts.get(hot.path) or mounts.get(f"{path}/")
+                )
                 if isinstance(endpoint, str) and endpoint:
                     return endpoint
         for endpoint, mapped_path in __JSONRPC_DEFAULT_ENDPOINT_MAPPINGS__.items():

tigrbl_runtime/executors/packed/route_select_websocket.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from ._shared import *
+
+
+class _PackedWebSocketRouteSelectMixin:
+    def _resolve_hot_exact_websocket_routes(
+        self,
+        plan: KernelPlan,
+        packed: PackedKernel,
+    ) -> Mapping[tuple[str, str], int]:
+        return _kernel_resolve_hot_exact_websocket_routes(
+            plan,
+            packed,
+            self._hot_exact_websocket_route_cache,
+        )
+
+
+    def _resolve_program_id_from_exact_websocket(
+        self,
+        plan: KernelPlan,
+        packed: PackedKernel,
+        protocol: str,
+        path: str,
+    ) -> int:
+        return _kernel_resolve_program_id_from_exact_websocket(
+            plan,
+            packed,
+            protocol,
+            path,
+            self._hot_exact_websocket_route_cache,
+        )
+
+

tigrbl_runtime/lowering_services.py

@@ -0,0 +1,22 @@
+"""Lazy runtime bridge to canonical kernel lowering services.
+
+Functions retain their kernel identity. Loading one service does not import
+unrelated protocol chains during concrete model initialization.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+__all__ = ["compile_opview_from_specs", "build_websocket_jsonrpc_session_handler"]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "compile_opview_from_specs":
+        from tigrbl_kernel.opview_compiler import compile_opview_from_specs
+
+        return compile_opview_from_specs
+    if name == "build_websocket_jsonrpc_session_handler":
+        from tigrbl_kernel.protocol_chains.websocket import build_websocket_jsonrpc_session_handler
+
+        return build_websocket_jsonrpc_session_handler
+    raise AttributeError(name)

{tigrbl_runtime-0.4.5.dev4.dist-info → tigrbl_runtime-0.4.5.dev8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl-runtime
-Version: 0.4.5.dev4
+Version: 0.4.5.dev8
 Summary: Execution bridge for compiled Tigrbl kernel plans and narrow runtime context/carrier compatibility.
 License: Apache License
                                     Version 2.0, January 2004
@@ -226,16 +226,16 @@ Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: numba (>=0.61.2)
-Requires-Dist: tigrbl-atoms
-Requires-Dist: tigrbl-base
-Requires-Dist: tigrbl-core
-Requires-Dist: tigrbl-kernel
+Requires-Dist: tigrbl-atoms (>=0.4.5.dev5)
+Requires-Dist: tigrbl-base (>=0.4.5.dev6)
+Requires-Dist: tigrbl-core (>=0.4.5.dev6)
+Requires-Dist: tigrbl-kernel (>=0.4.5.dev5)
 Requires-Dist: tigrbl-typing
 Project-URL: Discord, https://discord.gg/K4YTAPapjR
 Project-URL: Homepage, https://github.com/tigrbl/tigrbl
 Project-URL: Issues, https://github.com/tigrbl/tigrbl/issues
 Project-URL: Organization, https://github.com/tigrbl
-Project-URL: Repository, https://github.com/tigrbl/tigrbl/tree/master/pkgs/core/tigrbl_runtime
+Project-URL: Repository, https://github.com/tigrbl/tigrbl/tree/master/pkgs/50_runtime/tigrbl_runtime
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -245,7 +245,7 @@ Description-Content-Type: text/markdown
 <a href="https://pypi.org/project/tigrbl-runtime/"><img src="https://img.shields.io/pypi/v/tigrbl-runtime?label=PyPI" alt="PyPI version for tigrbl-runtime"/></a>
 <a href="https://pypi.org/project/tigrbl-runtime/"><img src="https://static.pepy.tech/badge/tigrbl-runtime" alt="Downloads for tigrbl-runtime"/></a>
 <a href="https://discord.gg/K4YTAPapjR"><img src="https://img.shields.io/badge/Discord-Join%20chat-5865F2?logo=discord&logoColor=white" alt="Discord community for tigrbl-runtime"/></a>
-<a href="https://github.com/tigrbl/tigrbl/blob/master/pkgs/core/tigrbl_runtime/README.md"><img src="https://hits.sh/github.com/tigrbl/tigrbl/blob/master/pkgs/core/tigrbl_runtime/README.md.svg?label=hits" alt="Repository hits for tigrbl-runtime README"/></a>
+<a href="https://github.com/tigrbl/tigrbl/blob/master/pkgs/50_runtime/tigrbl_runtime/README.md"><img src="https://hits.sh/github.com/tigrbl/tigrbl/blob/master/pkgs/50_runtime/tigrbl_runtime/README.md.svg?label=hits" alt="Repository hits for tigrbl-runtime README"/></a>
 <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-525252" alt="Apache 2.0 license"/></a>
 <a href="pyproject.toml"><img src="https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-3776ab" alt="Python versions 3.10 | 3.11 | 3.12 | 3.13 | 3.14 for tigrbl-runtime"/></a>
 <a href="https://github.com/tigrbl/tigrbl/blob/master/docs/README.md"><img src="https://img.shields.io/badge/workspace-core-1f6feb" alt="Workspace group for tigrbl-runtime"/></a>
@@ -269,7 +269,7 @@ Framework maintainers, extension authors, and advanced users composing Tigrbl fr
 
 ## Where does tigrbl-runtime fit?
 
-`tigrbl-runtime` lives at `pkgs/core/tigrbl_runtime` and serves a focused layer in the split Tigrbl framework.
+`tigrbl-runtime` lives at `pkgs/50_runtime/tigrbl_runtime` and serves a focused layer in the split Tigrbl framework.
 
 ## How does tigrbl-runtime work?
 
@@ -291,7 +291,7 @@ pip install tigrbl-runtime
 | Surface | Value |
 |---|---|
 | PyPI package | [`tigrbl-runtime`](https://pypi.org/project/tigrbl-runtime/) |
-| Repository path | [`pkgs/core/tigrbl_runtime`](https://github.com/tigrbl/tigrbl/tree/master/pkgs/core/tigrbl_runtime) |
+| Repository path | [`pkgs/50_runtime/tigrbl_runtime`](https://github.com/tigrbl/tigrbl/tree/master/pkgs/50_runtime/tigrbl_runtime) |
 | Python import root | `tigrbl_runtime` |
 | Console scripts | none declared |
 | Entry points | none declared |
@@ -387,7 +387,7 @@ Choose `tigrbl-runtime` when the quick-answer table matches your use case. Choos
 
 - Community: [Discord](https://discord.gg/K4YTAPapjR).
 - Issues: [GitHub Issues](https://github.com/tigrbl/tigrbl/issues).
-- Repository: [pkgs/core/tigrbl_runtime](https://github.com/tigrbl/tigrbl/tree/master/pkgs/core/tigrbl_runtime).
+- Repository: [pkgs/50_runtime/tigrbl_runtime](https://github.com/tigrbl/tigrbl/tree/master/pkgs/50_runtime/tigrbl_runtime).
 
 ## Package-local Boundary
 
@@ -398,10 +398,14 @@ This README is the package-local distribution entry point for `tigrbl-runtime`.
 - Package status: governed package in the `tigrbl/tigrbl` workspace.
 - Governance source: [SSOT registry](https://github.com/tigrbl/tigrbl/blob/master/.ssot/registry.json).
 - Release evidence: [publish workflow](https://github.com/tigrbl/tigrbl/actions/workflows/publish.yml) validates package builds, tests, GitHub release assets, and PyPI publication for managed packages.
-- Local certification guard: `pkgs/core/tigrbl_tests/tests/unit/test_package_badges_and_notices.py` verifies every package README keeps the Discord badge, Apache 2.0 badge, explicit Python-version badge, `LICENSE`, and `NOTICE`.
+- Local certification guard: `pkgs/97_tests/tigrbl_tests/tests/unit/test_package_badges_and_notices.py` verifies every package README keeps the Discord badge, Apache 2.0 badge, explicit Python-version badge, `LICENSE`, and `NOTICE`.
 - Scope note: this README documents the package boundary. Runtime feature support remains governed by `.ssot/` entities and the conformance docs linked below.
 
 ## License
 
 Licensed under the Apache License, Version 2.0. See `LICENSE`, `NOTICE`, and the official [Apache 2.0 license text](https://www.apache.org/licenses/LICENSE-2.0).
 
+## Lowering integration
+
+`lowering_services` lazily exposes canonical kernel operation-view compilation and WebSocket JSON-RPC session construction to concrete integration code. It preserves the kernel function objects and keeps kernel imports out of concrete authoring modules.
+

{tigrbl_runtime-0.4.5.dev4.dist-info → tigrbl_runtime-0.4.5.dev8.dist-info}/RECORD

@@ -3,11 +3,11 @@ tigrbl_runtime/callbacks.py,sha256=lVxlghq6GuS5JbCo4JeuCwRkwIoItjQLzShShLKzK1o,3
 tigrbl_runtime/channel/__init__.py,sha256=myE6r8SGOX0WOdmoRWugJDw6sUhJWjI6lFibscgFvoU,451
 tigrbl_runtime/channel/_asgi_completion.py,sha256=Ye_wsleVhpUNoZ_uW1TiJdcIoExS4ZW6tTvplW6BYoI,966
 tigrbl_runtime/channel/_asgi_context.py,sha256=5ULCWsi_yhswCuXgI7swcVe-OFpgjqOs9oFT7wRjmaA,3802
-tigrbl_runtime/channel/_asgi_jsonrpc.py,sha256=E4GpyW-2RX9npiDjlXEE5eHsHAWQ67U4gNR-4UmpYFs,1269
+tigrbl_runtime/channel/_asgi_jsonrpc.py,sha256=-JBIB_IouR_EhlsEd0EtP39BdZOrFvOyJbLyq3O3450,1696
 tigrbl_runtime/channel/_asgi_receive.py,sha256=Ry1YDQVHMJWxe9DhsnTABHiO9vLb0AuukD9cMiHtk5w,2076
 tigrbl_runtime/channel/_asgi_scope.py,sha256=zMiSh-zmEKI-sHoFbz1Wog2IgdInGXSJLe2K_VyFMHk,2322
-tigrbl_runtime/channel/_asgi_send.py,sha256=iieRuVfyA6NmOx9ehim9wEWezFfw2Jzjub6UW5CEdi0,9290
-tigrbl_runtime/channel/_asgi_webtransport.py,sha256=-0J5qTCTFB1GRUTKgbWpmCfIYbse4h2sasEY4CexPhw,12009
+tigrbl_runtime/channel/_asgi_send.py,sha256=bgw5TVYwu3QShxRx5-dsMJFWkfqfR4Y1dFTgPIQ-PJs,12370
+tigrbl_runtime/channel/_asgi_webtransport.py,sha256=r2TsMv4jlVEmpV1e4_nNqp9kRHCJMEFZbvXFEVjF2ho,13035
 tigrbl_runtime/channel/asgi.py,sha256=_y0arRyNeQkzmsl7mcrTMp_1SXWDatvU23ztp8tgsCE,2307
 tigrbl_runtime/channel/capabilities.py,sha256=x6pURZvGu8dM_uIMmBXhFKM4K3gtpiQocPMfhU9MtCA,1802
 tigrbl_runtime/channel/websocket.py,sha256=IDf_KLmCoSXcKk5m389sZ2IT80orstgPZs_uF8fmT3A,4076
@@ -25,22 +25,24 @@ tigrbl_runtime/executors/ctx/hot_state.py,sha256=CjC_DXtYE93G7nsTT4AVD6VCrvE1k5q
 tigrbl_runtime/executors/kernel_executor.py,sha256=QXMyZspKQX8CF7mjEecmor0NJprig4PO35qhAFsxh7g,2734
 tigrbl_runtime/executors/numba_packed.py,sha256=ICntbbFDO05NOuW6F2sU0pre0Z2ipiJrgp9WOeU_Jd8,2930
 tigrbl_runtime/executors/packed/__init__.py,sha256=0rTrOfFv0hc6uZHyuFt1vXO-T_v8sRVXH1GdqMsGiSM,118
-tigrbl_runtime/executors/packed/_shared.py,sha256=o75DhfCtUV7-jZA_DZ94BbxP4duI2L8TvOto-54H-EQ,6129
-tigrbl_runtime/executors/packed/batch.py,sha256=CnX0NEEj6OSQz05hkzcXE3tUP4Vpvk6ExZdT0pqaD3w,13544
+tigrbl_runtime/executors/packed/_shared.py,sha256=ggCnzYUNotdVkKwf0sSlt_UW2jrT3nq4JW3-P-4PYz8,6203
+tigrbl_runtime/executors/packed/batch.py,sha256=UjgxpABAnT34yItOHlv-ndxd37DzsMlgeyJOiElWtN4,12514
 tigrbl_runtime/executors/packed/error_edges.py,sha256=iKgqeSAER17H3qhHaVyltpxJ3MU_hdAcE6PSijsrwlc,11928
-tigrbl_runtime/executors/packed/execute.py,sha256=Zs0VeGgkCYPo9jr_MwsC8OSR-SUESh3NQRLWKwRPKWg,13623
+tigrbl_runtime/executors/packed/execute.py,sha256=_O4pyMIRXp4D3GuollEO-gLnuCerzJLJjSn7ZwVGB4A,15018
 tigrbl_runtime/executors/packed/executor.py,sha256=oaywnJ-smqcqhQbvSQukLy94-A7RE76Sfl15BXyW8MU,3314
 tigrbl_runtime/executors/packed/hot_access.py,sha256=2Xh0v79uHp_TqaqbkL918y6mEz6K0mpZPLCtTXy3eIw,7784
 tigrbl_runtime/executors/packed/hot_context.py,sha256=xDO70_-WvIv0LemBLXweoJ9scPfSMK9e1YybgFAcEZM,12470
-tigrbl_runtime/executors/packed/input_compile.py,sha256=_IBvsho6ZBrN_YPC9GWdJwm9S4N8S8VnAtd96AfVUMU,13051
-tigrbl_runtime/executors/packed/input_extract.py,sha256=-3zrU87y_sWPLBgYZjx72-cgKpolH0Jj5ICH_5cS0HU,13213
+tigrbl_runtime/executors/packed/input_compile.py,sha256=onSBcZrozBcBvRXbvr198G01qkDaE52TByLBBzZ3bc0,13154
+tigrbl_runtime/executors/packed/input_extract.py,sha256=DXqOMSME062p9K1kx0gLzMBEjYT2OXB6xvYn-CY4siQ,13234
 tigrbl_runtime/executors/packed/request_select.py,sha256=U1w3rPQMn7Uf0WLnHgiVqP49uOS-2Y1tM_KAFrEObwA,8763
-tigrbl_runtime/executors/packed/route_select.py,sha256=AuSdUDeloNCD17MPe177LU4y5eJgf_sNcnMSfG-87VU,12130
+tigrbl_runtime/executors/packed/route_select.py,sha256=mL-bTNjjRTMmlgJFJ5aSbl16EVqSO7C5YxSnRvgQzTY,15349
+tigrbl_runtime/executors/packed/route_select_websocket.py,sha256=XbVqPt0fX0sTGAdepl5QCdm7x1-zba5mCCGHULqDp3c,797
 tigrbl_runtime/executors/packed/runner_resolve.py,sha256=R82Y9MBAlXDc3kKjGXeVOBtimmCprvKuOe8q8oX9NWA,15489
 tigrbl_runtime/executors/packed/segments.py,sha256=-smyIbjgr3RLK_spWEGxo1E-8gJALBTwD0diaIA1hkg,12881
 tigrbl_runtime/executors/phase.py,sha256=9HxJUbdh1-FLvhb6cGe3sOaz_Ej6xydDT9hUpVi2ERQ,1057
 tigrbl_runtime/executors/phase_runner.py,sha256=OshCk29OFn-5IMBgLO5_23zLHsewgk_tXOMAXgBZNrg,9856
 tigrbl_runtime/executors/types.py,sha256=r4GsnCFXXvbi8XA2vVl8rP9hCsV0W3r_HyTnQq0DS04,1127
+tigrbl_runtime/lowering_services.py,sha256=1pasQDSPyVJCKRr1nGts68m0kMfJw6JG-5KLvuUq_iY,794
 tigrbl_runtime/runtime/__init__.py,sha256=oy7pj5NN8inWiXhkdU5htTxxqYcsbgkeEBRbRIIz_hc,652
 tigrbl_runtime/runtime/_typing_aliases.py,sha256=sOkj2em2t7nzf1z6VD7U5AHGxhDqmfdcSOzLl-mZXcc,108
 tigrbl_runtime/runtime/base.py,sha256=ejEE0JIoYC41OcLm4ikUR23MfITVs9ruSv2EftX1-R4,882
@@ -51,8 +53,8 @@ tigrbl_runtime/runtime/response.py,sha256=SCJKN-hyjeVoKmlLdf_N7RkTyx_f6noCx-fSgL
 tigrbl_runtime/runtime/runtime.py,sha256=gCIuwJkj_DmPzVfXAIpp5-3hEilv_yfyYvLDjrcBF7E,3624
 tigrbl_runtime/runtime/system.py,sha256=5GWVYZscff1nUymCKJAEa7VYbqIeFfppV3seYyDxlvA,4301
 tigrbl_runtime/semantics.py,sha256=UwPeNdKXJ421XoXqL3oyko5gi9vNrXkBKwk5X9Ug2So,9972
-tigrbl_runtime-0.4.5.dev4.dist-info/METADATA,sha256=hV6eGInHd9bmo1PYrRQW_bfLi4DPJDlMIell2pr-Uy8,23325
-tigrbl_runtime-0.4.5.dev4.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
-tigrbl_runtime-0.4.5.dev4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-tigrbl_runtime-0.4.5.dev4.dist-info/licenses/NOTICE,sha256=EvJMTshzsWz43LiK-DeN2ZuLtrP49cxvlrFlJ8F_buc,221
-tigrbl_runtime-0.4.5.dev4.dist-info/RECORD,,
+tigrbl_runtime-0.4.5.dev8.dist-info/METADATA,sha256=0KZXUXZAqSxhnNq2HqZ4srK2EzuyBqSE0WUTyBo--3g,23717
+tigrbl_runtime-0.4.5.dev8.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
+tigrbl_runtime-0.4.5.dev8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tigrbl_runtime-0.4.5.dev8.dist-info/licenses/NOTICE,sha256=EvJMTshzsWz43LiK-DeN2ZuLtrP49cxvlrFlJ8F_buc,221
+tigrbl_runtime-0.4.5.dev8.dist-info/RECORD,,

{tigrbl_runtime-0.4.5.dev4.dist-info → tigrbl_runtime-0.4.5.dev8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.4.1
+Generator: poetry-core 2.5.0
 Root-Is-Purelib: true
 Tag: py3-none-any