tigrbl-kernel 0.4.4.dev1__py3-none-any.whl → 0.4.4.dev8__py3-none-any.whl

tigrbl_kernel/_compile.py

@@ -5,7 +5,17 @@ from types import SimpleNamespace
 from typing import Any, Mapping
 
 from tigrbl_atoms import StepFn
-from tigrbl_core._spec.binding_spec import HttpRestBindingSpec
+from tigrbl_core._spec.binding_spec import (
+    HttpJsonRpcProtocolBindingSpec,
+    HttpRestBindingSpec,
+    HttpRestProtocolBindingSpec,
+    WebSocketProtocolBindingSpec,
+    WebTransportProtocolBindingSpec,
+    derive_websocket_subprotocol_for_framing,
+    derive_session_metadata_for_framing,
+    framing_kind,
+    framing_spec_name,
+)
 from tigrbl_core.config.constants import __JSONRPC_DEFAULT_ENDPOINT__
 from tigrbl_core._spec.op_spec import OpSpec
 from tigrbl_core._spec.well_known_spec import well_known_op_alias
@@ -28,6 +38,69 @@ from .utils import (
 DEFAULT_PHASE_ORDER = tuple(getattr(_ev, "PHASES", ())) or _DEFAULT_PHASE_ORDER
 
 
+def _route_metadata_for_binding(binding: Any) -> dict[str, Any]:
+    framing_obj = getattr(binding, "framing", None)
+    framing = framing_kind(framing_obj)
+    metadata: dict[str, Any] = {
+        "framing": framing,
+        "framing_kind": framing,
+        "framing_spec": framing_spec_name(framing_obj),
+    }
+    proto = str(getattr(binding, "proto", "") or "")
+    if isinstance(binding, WebSocketProtocolBindingSpec):
+        derived_subprotocol = derive_websocket_subprotocol_for_framing(framing_obj)
+        if derived_subprotocol is not None:
+            metadata["websocket_subprotocol"] = derived_subprotocol
+    elif proto in {"ws", "wss"}:
+        metadata.update(
+            derive_session_metadata_for_framing(
+                binding_kind=proto,
+                framing=framing_obj,
+                subprotocols=tuple(getattr(binding, "subprotocols", ()) or ()),
+            )
+        )
+    if isinstance(binding, WebTransportProtocolBindingSpec):
+        if binding.control_stream is not None:
+            control = binding.control_stream
+            metadata["control_stream"] = {
+                "name": control.name,
+                "kind": control.kind,
+                "opens": control.opens,
+                "purpose": control.purpose,
+                "framing": framing_kind(control.framing),
+                "framing_spec": framing_spec_name(control.framing),
+            }
+        metadata["streams"] = tuple(
+            {
+                "name": stream.name,
+                "kind": stream.kind,
+                "purpose": stream.purpose,
+                "framing": framing_kind(stream.framing),
+                "framing_spec": framing_spec_name(stream.framing),
+            }
+            for stream in binding.streams
+        )
+        metadata["datagrams"] = tuple(
+            {
+                "name": datagram.name,
+                "purpose": datagram.purpose,
+                "framing": framing_kind(datagram.framing),
+                "framing_spec": framing_spec_name(datagram.framing),
+            }
+            for datagram in binding.datagrams
+        )
+    elif proto == "webtransport":
+        lane = getattr(binding, "lane", None) or getattr(binding, "profile", None)
+        inner_framing = getattr(binding, "inner_framing", None)
+        metadata["lane"] = lane
+        metadata["inner_framing"] = framing_kind(inner_framing)
+        metadata["inner_framing_spec"] = framing_spec_name(inner_framing)
+        if inner_framing is not None:
+            metadata["inner_framing_kind"] = str(inner_framing)
+            metadata["inner_framing_spec"] = framing_spec_name(inner_framing)
+    return metadata
+
+
 def _pathspec_iter(app: Any) -> tuple[Any, ...]:
     collected: list[Any] = []
     collected.extend(tuple(getattr(app, "_tigrbl_path_specs", ()) or ()))
@@ -133,9 +206,13 @@ def _compile_plan(self: Any, app: Any) -> KernelPlan:
     from tigrbl_core._spec.binding_spec import (
         HttpJsonRpcBindingSpec,
         HttpRestBindingSpec,
+        HttpJsonRpcProtocolBindingSpec,
+        HttpRestProtocolBindingSpec,
         HttpStreamBindingSpec,
         SseBindingSpec,
+        WebSocketProtocolBindingSpec,
         WebTransportBindingSpec,
+        WebTransportProtocolBindingSpec,
         WsBindingSpec,
     )
 
@@ -169,7 +246,12 @@ def _compile_plan(self: Any, app: Any) -> KernelPlan:
             for binding in getattr(sp, "bindings", ()) or ():
                 if isinstance(
                     binding,
-                    (HttpRestBindingSpec, HttpStreamBindingSpec, SseBindingSpec),
+                    (
+                        HttpRestBindingSpec,
+                        HttpRestProtocolBindingSpec,
+                        HttpStreamBindingSpec,
+                        SseBindingSpec,
+                    ),
                 ):
                     bucket = route_data.setdefault(
                         binding.proto, {"exact": {}, "templated": []}
@@ -199,34 +281,53 @@ def _compile_plan(self: Any, app: Any) -> KernelPlan:
                                     meta_index
                                 )
 
-                elif isinstance(binding, HttpJsonRpcBindingSpec):
-                    endpoint = str(
-                        getattr(binding, "endpoint", __JSONRPC_DEFAULT_ENDPOINT__)
+                elif isinstance(binding, (HttpJsonRpcBindingSpec, HttpJsonRpcProtocolBindingSpec)):
+                    rpc_path = str(
+                        getattr(
+                            binding,
+                            "path",
+                            getattr(binding, "endpoint", __JSONRPC_DEFAULT_ENDPOINT__),
+                        )
                         or __JSONRPC_DEFAULT_ENDPOINT__
                     )
-                    selector = f"{endpoint}:{binding.rpc_method}"
+                    rpc_method = getattr(
+                        binding,
+                        "method",
+                        getattr(binding, "rpc_method", None),
+                    )
+                    selector = f"{rpc_path}:{rpc_method}"
                     opkey_to_meta[OpKey(proto=binding.proto, selector=selector)] = (
                         meta_index
                     )
                     proto_bucket = route_data.setdefault(
-                        binding.proto, {"endpoints": {}}
-                    )
-                    endpoint_bucket = proto_bucket.setdefault("endpoints", {}).setdefault(
-                        endpoint, {}
+                        binding.proto, {"paths": {}, "endpoints": {}}
                     )
-                    proto_bucket[binding.rpc_method] = meta_index
-                    endpoint_bucket[binding.rpc_method] = {
+                    path_bucket = proto_bucket.setdefault("paths", {}).setdefault(rpc_path, {})
+                    endpoint_bucket = proto_bucket.setdefault("endpoints", {}).setdefault(rpc_path, {})
+                    proto_bucket[rpc_method] = meta_index
+                    row = {
                         "meta_index": meta_index,
                         "selector": selector,
-                        "rpc_method": binding.rpc_method,
-                        "endpoint": endpoint,
+                        "method": rpc_method,
+                        "path": rpc_path,
                     }
+                    path_bucket[rpc_method] = row
+                    endpoint_bucket[rpc_method] = row
 
-                elif isinstance(binding, (WsBindingSpec, WebTransportBindingSpec)):
+                elif isinstance(
+                    binding,
+                    (
+                        WsBindingSpec,
+                        WebSocketProtocolBindingSpec,
+                        WebTransportBindingSpec,
+                        WebTransportProtocolBindingSpec,
+                    ),
+                ):
                     bucket = route_data.setdefault(
                         binding.proto, {"exact": {}, "templated": []}
                     )
                     selector = binding.path
+                    route_metadata = _route_metadata_for_binding(binding)
                     opkey_to_meta[OpKey(proto=binding.proto, selector=selector)] = (
                         meta_index
                     )
@@ -240,13 +341,17 @@ def _compile_plan(self: Any, app: Any) -> KernelPlan:
                                 "names": names,
                                 "meta_index": meta_index,
                                 "selector": selector,
-                                "subprotocols": tuple(
-                                    getattr(binding, "subprotocols", ()) or ()
-                                ),
+                                **route_metadata,
                             }
                         )
                     else:
                         bucket["exact"][selector] = meta_index
+                        bucket.setdefault("exact_metadata", {})[selector] = {
+                            "path": binding.path,
+                            "meta_index": meta_index,
+                            "selector": selector,
+                            **route_metadata,
+                        }
 
     semantic = KernelPlan(
         proto_indices=route_data,

tigrbl_kernel/contract_classification.py

@@ -61,6 +61,9 @@ CANONICAL_CONTRACT_EVENTS: tuple[str, ...] = (
     "webtransport.stream.stop_sending",
     "webtransport.datagram.receive",
     "webtransport.datagram.send",
+    "stream.resume.request",
+    "stream.resume.accept",
+    "stream.resume.reject",
     "webtransport.disconnect",
     "webtransport.close",
     "transport.emit.complete",
@@ -71,6 +74,7 @@ _EVENT_SCOPE_PREFIXES: dict[str, str] = {
     "http.": "http",
     "websocket.": "websocket",
     "webtransport.": "webtransport",
+    "stream.resume.": "webtransport",
     "transport.emit.": "webtransport",
 }
 

tigrbl_kernel/core.py

@@ -24,7 +24,6 @@ from .cache import _SpecsOnceCache, _WeakMaybeDict
 from .models import KernelPlan, OpView
 from .opview_compiler import compile_opview_from_specs
 from .types import DEFAULT_PHASE_ORDER as _DEFAULT_PHASE_ORDER
-from .rust_compile import build_rust_kernel as _build_rust_kernel
 from .utils import (
     _opspecs,
     _table_iter,
@@ -155,9 +154,6 @@ class Kernel:
             return payload
         return {}
 
-    def compile_rust_plan(self, app: Any):
-        return _build_rust_kernel(app)
-
     def invalidate_kernelz_payload(self, app: Optional[Any] = None) -> None:
         with self._lock:
             if app is None:

tigrbl_kernel/cross_transport.py

@@ -27,7 +27,7 @@ TRANSPORT_ENVELOPE_KEYS = frozenset(
 class EquivalenceCase:
     op_id: str
     category: str
-    bindings: tuple[Mapping[str, Any], ...]
+    bindings: tuple[Any, ...]
 
 
 def canonical_operation_id(op_id: str) -> str:
@@ -42,7 +42,7 @@ def canonical_operation_id(op_id: str) -> str:
 
 def compile_equivalence_manifest(
     op_id: str,
-    bindings: Iterable[Mapping[str, Any]],
+    bindings: Iterable[Any],
     *,
     schema_identity: str = "schema:v1",
     runtime_plan_identity: str = "runtime-plan:v1",
@@ -80,7 +80,7 @@ def equivalent_transport_results(*results: Mapping[str, Any]) -> bool:
     return all(normalized_transport_result(result) == first for result in results[1:])
 
 
-def equivalent_binding_group(op_id: str, bindings: Iterable[Mapping[str, Any]]) -> bool:
+def equivalent_binding_group(op_id: str, bindings: Iterable[Any]) -> bool:
     manifest = compile_equivalence_manifest(op_id, bindings)
     families = {binding["family"] for binding in manifest["bindings"]}
     return bool(families) and len({manifest["op_id"]}) == 1

tigrbl_kernel/protocol_anchors.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from typing import Any
-import warnings
 
 
 def canonical_protocol_anchor_order(
@@ -32,18 +31,7 @@ def python_protocol_anchor_trace(case: dict[str, Any]) -> tuple[str, ...]:
     )
 
 
-def rust_protocol_anchor_trace(case: dict[str, Any]) -> tuple[str, ...]:
-    del case
-    warnings.warn(
-        "rust_protocol_anchor_trace is deprecated; protocol anchors are Python-only.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    raise RuntimeError("rust_protocol_anchor_trace is unavailable.")
-
-
 __all__ = [
     "canonical_protocol_anchor_order",
     "python_protocol_anchor_trace",
-    "rust_protocol_anchor_trace",
 ]

tigrbl_kernel/protocol_bindings.py

@@ -4,6 +4,16 @@ from collections.abc import Mapping
 from typing import Any
 
 from tigrbl_core._spec.binding_spec import (
+    BytesFramingSpec,
+    derive_websocket_subprotocol_for_framing,
+    framing_spec_name,
+    framing_kind as framing_spec_kind,
+    framing_spec_from_kind,
+    JsonFramingSpec,
+    JsonRpcFramingSpec,
+    normalize_framing_spec,
+    SseFramingSpec,
+    TextFramingSpec,
     validate_app_framing_for_binding,
     validate_binding_profile_exchange,
     validate_webtransport_inner_framing,
@@ -18,30 +28,61 @@ def _unsupported(message: str) -> ValueError:
     return ValueError(f"binding protocol unsupported before runtime: {message}")
 
 
-def compile_binding_protocol_plan(op_id: str, binding: Mapping[str, Any]) -> dict[str, object]:
-    kind = binding.get("kind") or binding.get("proto")
+def _binding_get(binding: Any, key: str, default: Any = None) -> Any:
+    if isinstance(binding, Mapping):
+        return binding.get(key, default)
+    return getattr(binding, key, default)
+
+
+def _lane_mapping(value: Any, *, lane_kind: str | None = None) -> dict[str, Any]:
+    if isinstance(value, Mapping):
+        return dict(value)
+    row: dict[str, Any] = {}
+    for key in ("name", "kind", "opens", "purpose", "framing"):
+        item = getattr(value, key, None)
+        if item is not None:
+            row[key] = item
+    if lane_kind is not None:
+        row.setdefault("kind", lane_kind)
+    return row
+
+
+def compile_binding_protocol_plan(op_id: str, binding: Any) -> dict[str, object]:
+    kind = _binding_get(binding, "kind") or _binding_get(binding, "proto")
     if not kind:
         raise ValueError(
             "BindingSpec binding source is required; transport guessing is ambiguous"
         )
 
     kind = str(kind)
-    profile = binding.get("profile")
+    profile = _binding_get(binding, "profile")
     if kind in {"http", "https"} and profile:
         kind = f"{kind}.{profile}"
     elif kind == "websocket":
-        kind = str(binding.get("proto") or "ws")
-    framing = binding.get("framing")
+        kind = str(_binding_get(binding, "proto") or "ws")
+    framing = _binding_get(binding, "framing")
+    framing_kind = ""
+    framing_spec = ""
+    subprotocols: tuple[str, ...] = ()
+    inner_framing: str | None = None
     rows: tuple[dict[str, str], ...]
+    rpc_path: str | None = None
+    rpc_method: str | None = None
 
     if kind in {"http.rest", "https.rest"}:
         validate_binding_profile_exchange(
             binding_kind=kind,
-            exchange=str(binding.get("exchange") or "request_response"),
+            exchange=str(_binding_get(binding, "exchange") or "request_response"),
         )
-        validate_app_framing_for_binding(binding_kind=kind, framing=str(framing or "json"))
+        framing_spec_obj = normalize_framing_spec(
+            framing_spec_from_kind(framing),
+            default=JsonFramingSpec(),
+        )
+        validate_app_framing_for_binding(binding_kind=kind, framing=framing_spec_obj)
         family = "request"
-        framing = "json"
+        framing = framing_spec_obj.kind
+        framing_kind = framing
+        framing_spec = framing_spec_obj.__class__.__name__
         anchors = (
             "ingress.receive",
             "dispatch.subevent.derive",
@@ -53,15 +94,27 @@ def compile_binding_protocol_plan(op_id: str, binding: Mapping[str, Any]) -> dic
             {"family": "request", "subevent": "response.emit"},
         )
     elif kind in {"http.jsonrpc", "https.jsonrpc"}:
-        if not binding.get("rpc_method"):
-            raise _unsupported("http.jsonrpc requires rpc_method")
+        rpc_method = _binding_get(binding, "method") or _binding_get(binding, "rpc_method")
+        if not rpc_method:
+            raise _unsupported("http.jsonrpc requires method")
+        rpc_method = str(rpc_method)
+        rpc_path = str(
+            _binding_get(binding, "path", _binding_get(binding, "endpoint", "/rpc"))
+            or "/rpc"
+        )
         validate_binding_profile_exchange(
             binding_kind=kind,
-            exchange=str(binding.get("exchange") or "request_response"),
+            exchange=str(_binding_get(binding, "exchange") or "request_response"),
+        )
+        framing_spec_obj = normalize_framing_spec(
+            framing_spec_from_kind(framing),
+            default=JsonRpcFramingSpec(),
         )
-        validate_app_framing_for_binding(binding_kind=kind, framing=str(framing or "jsonrpc"))
+        validate_app_framing_for_binding(binding_kind=kind, framing=framing_spec_obj)
         family = "request"
-        framing = "jsonrpc"
+        framing = framing_spec_obj.kind
+        framing_kind = framing
+        framing_spec = framing_spec_obj.__class__.__name__
         anchors = (
             "framing.decode",
             "dispatch.subevent.derive",
@@ -75,11 +128,17 @@ def compile_binding_protocol_plan(op_id: str, binding: Mapping[str, Any]) -> dic
     elif kind in {"http.stream", "https.stream"}:
         exchange = validate_binding_profile_exchange(
             binding_kind=kind,
-            exchange=str(binding.get("exchange") or "server_stream"),
+            exchange=str(_binding_get(binding, "exchange") or "server_stream"),
         )
-        validate_app_framing_for_binding(binding_kind=kind, framing=str(framing or "stream"))
+        framing_spec_obj = normalize_framing_spec(
+            framing_spec_from_kind(framing),
+            default=BytesFramingSpec(),
+        )
+        validate_app_framing_for_binding(binding_kind=kind, framing=framing_spec_obj)
         family = "stream"
-        framing = str(framing or "stream")
+        framing = framing_spec_obj.kind
+        framing_kind = framing
+        framing_spec = framing_spec_obj.__class__.__name__
         if exchange == "client_stream":
             anchors = (
                 "transport.receive",
@@ -100,11 +159,17 @@ def compile_binding_protocol_plan(op_id: str, binding: Mapping[str, Any]) -> dic
     elif kind in {"http.sse", "https.sse"}:
         validate_binding_profile_exchange(
             binding_kind=kind,
-            exchange=str(binding.get("exchange") or "server_stream"),
+            exchange=str(_binding_get(binding, "exchange") or "server_stream"),
+        )
+        framing_spec_obj = normalize_framing_spec(
+            framing_spec_from_kind(framing),
+            default=SseFramingSpec(),
         )
-        validate_app_framing_for_binding(binding_kind=kind, framing=str(framing or "sse"))
+        validate_app_framing_for_binding(binding_kind=kind, framing=framing_spec_obj)
         family = "stream"
-        framing = "sse"
+        framing = framing_spec_obj.kind
+        framing_kind = framing
+        framing_spec = framing_spec_obj.__class__.__name__
         anchors = (
             "framing.encode",
             "handler.invoke",
@@ -117,18 +182,25 @@ def compile_binding_protocol_plan(op_id: str, binding: Mapping[str, Any]) -> dic
             {"family": "stream", "subevent": "stream.close"},
         )
     elif kind in {"ws", "wss", "websocket"}:
-        if binding.get("methods"):
+        if _binding_get(binding, "methods"):
             raise _unsupported("websocket bindings do not accept HTTP methods")
         family = "message"
-        framing = str(framing or "text")
-        subprotocols = tuple(str(item).lower() for item in binding.get("subprotocols", ()))
+        framing_spec_obj = normalize_framing_spec(
+            framing_spec_from_kind(framing),
+            default=TextFramingSpec(),
+        )
+        framing = framing_spec_obj.kind
+        framing_kind = framing
+        framing_spec = framing_spec_obj.__class__.__name__
+        subprotocols = tuple(str(item).lower() for item in (_binding_get(binding, "subprotocols", ()) or ()))
+        websocket_subprotocol = derive_websocket_subprotocol_for_framing(framing_spec_obj)
         validate_binding_profile_exchange(
             binding_kind="wss" if kind == "wss" else "ws",
-            exchange=str(binding.get("exchange") or "bidirectional_stream"),
+            exchange=str(_binding_get(binding, "exchange") or "bidirectional_stream"),
         )
         validate_app_framing_for_binding(
             binding_kind="wss" if kind == "wss" else "ws",
-            framing=framing,
+            framing=framing_spec_obj,
             subprotocols=subprotocols,
         )
         anchors = (
@@ -144,31 +216,65 @@ def compile_binding_protocol_plan(op_id: str, binding: Mapping[str, Any]) -> dic
             {"family": "session", "subevent": "session.close"},
         )
     elif kind == "webtransport":
-        if binding.get("exchange") == "request_response":
+        if _binding_get(binding, "exchange") == "request_response":
             raise _unsupported("webtransport request_response exchange")
-        validate_app_framing_for_binding(binding_kind=kind, framing=str(framing or "webtransport"))
-        if framing and str(framing) != "webtransport":
-            raise _unsupported("webtransport outer framing must remain webtransport")
-        lane = webtransport_lane_for_profile(
-            binding.get("lane") or binding.get("profile") or "webtransport"
-        )
-        validate_webtransport_lane_exchange(
-            lane=lane,
-            exchange=str(binding.get("exchange") or {
-                "session": "bidirectional_stream",
-                "bidi_stream": "bidirectional_stream",
-                "unidi_client_stream": "client_stream",
-                "unidi_server_stream": "server_stream",
-                "datagram": "bidirectional_stream",
-            }[lane]),
-        )
-        inner_framing = validate_webtransport_inner_framing(
-            lane=lane,
-            inner_framing=binding.get("inner_framing"),
-        )
-        family = webtransport_runtime_family(lane)
-        framing = "webtransport"
-        if lane == "session":
+        if framing is not None:
+            raise _unsupported("webtransport bindings do not accept top-level app framing")
+        framing_kind = ""
+        framing_spec = ""
+        control_stream = _binding_get(binding, "control_stream")
+        streams = tuple(_binding_get(binding, "streams", ()) or ())
+        datagrams = tuple(_binding_get(binding, "datagrams", ()) or ())
+        if control_stream is not None or streams or datagrams:
+            control = None
+            if control_stream is not None:
+                control = _lane_mapping(control_stream, lane_kind="bidi_stream")
+                if control.get("kind") != "bidi_stream":
+                    raise _unsupported("webtransport control_stream must use bidi_stream")
+                if control.get("opens") != "first":
+                    raise _unsupported("webtransport control_stream must open first")
+                control_framing = validate_webtransport_inner_framing(
+                    lane="bidi_stream",
+                    inner_framing=framing_spec_from_kind(control.get("framing")),
+                )
+                control["framing"] = framing_spec_kind(control_framing)
+                control["framing_spec"] = framing_spec_name(control_framing)
+            stream_rows = []
+            datagram_rows = []
+            names: list[str] = []
+            for stream in streams:
+                row = _lane_mapping(stream)
+                name = str(row.get("name") or "")
+                if not name:
+                    raise _unsupported("webtransport streams require name")
+                names.append(name)
+                lane_kind = str(row.get("kind") or "")
+                stream_framing = validate_webtransport_inner_framing(
+                    lane=lane_kind,
+                    inner_framing=framing_spec_from_kind(row.get("framing")),
+                )
+                row["framing"] = framing_spec_kind(stream_framing)
+                row["framing_spec"] = framing_spec_name(stream_framing)
+                stream_rows.append(row)
+            for datagram in datagrams:
+                row = _lane_mapping(datagram)
+                name = str(row.get("name") or "")
+                if not name:
+                    raise _unsupported("webtransport datagrams require name")
+                names.append(name)
+                datagram_framing = validate_webtransport_inner_framing(
+                    lane="datagram",
+                    inner_framing=framing_spec_from_kind(row.get("framing")),
+                )
+                row["framing"] = framing_spec_kind(datagram_framing)
+                row["framing_spec"] = framing_spec_name(datagram_framing)
+                datagram_rows.append(row)
+            if len(set(names)) != len(names):
+                raise _unsupported("webtransport lane names must be unique")
+            family = "session"
+            lane = "session"
+            inner_framing = None
+            framing = ""
             anchors = (
                 "transport.accept",
                 "dispatch.subevent.derive",
@@ -179,68 +285,107 @@ def compile_binding_protocol_plan(op_id: str, binding: Mapping[str, Any]) -> dic
                 {"family": "session", "subevent": "session.open"},
                 {"family": "session", "subevent": "session.close"},
             )
-        elif lane == "bidi_stream":
-            anchors = (
-                "transport.accept",
-                "transport.receive",
-                "framing.decode",
-                "dispatch.subevent.derive",
-                "handler.invoke",
-                "framing.encode",
-                "transport.emit",
-                "transport.close",
-            )
-            rows = (
-                {"family": "stream", "subevent": "stream.open"},
-                {"family": "stream", "subevent": "stream.chunk.received"},
-                {"family": "stream", "subevent": "stream.chunk.emit"},
-                {"family": "stream", "subevent": "stream.close"},
-            )
-        elif lane == "unidi_client_stream":
-            anchors = (
-                "transport.accept",
-                "transport.receive",
-                "framing.decode",
-                "dispatch.subevent.derive",
-                "handler.invoke",
-                "transport.close",
-            )
-            rows = (
-                {"family": "stream", "subevent": "stream.open"},
-                {"family": "stream", "subevent": "stream.chunk.received"},
-                {"family": "stream", "subevent": "stream.close"},
-            )
-        elif lane == "unidi_server_stream":
-            anchors = (
-                "transport.accept",
-                "handler.invoke",
-                "framing.encode",
-                "transport.emit",
-                "transport.close",
-            )
-            rows = (
-                {"family": "stream", "subevent": "stream.open"},
-                {"family": "stream", "subevent": "stream.chunk.emit"},
-                {"family": "stream", "subevent": "stream.emit_complete"},
-                {"family": "stream", "subevent": "stream.close"},
+            lane_catalog = {
+                "control_stream": control,
+                "streams": tuple(stream_rows),
+                "datagrams": tuple(datagram_rows),
+            }
+        else:
+            lane_catalog = None
+            lane = webtransport_lane_for_profile(
+                _binding_get(binding, "lane") or _binding_get(binding, "profile") or "webtransport"
             )
-        elif lane == "datagram":
-            anchors = (
-                "transport.accept",
-                "transport.receive",
-                "framing.decode",
-                "dispatch.subevent.derive",
-                "handler.invoke",
-                "framing.encode",
-                "transport.emit",
+            validate_webtransport_lane_exchange(
+                lane=lane,
+                exchange=str(_binding_get(binding, "exchange") or {
+                    "session": "bidirectional_stream",
+                    "bidi_stream": "bidirectional_stream",
+                    "unidi_client_stream": "client_stream",
+                    "unidi_server_stream": "server_stream",
+                    "datagram": "bidirectional_stream",
+                }[lane]),
             )
-            rows = (
-                {"family": "datagram", "subevent": "datagram.received"},
-                {"family": "datagram", "subevent": "datagram.emit"},
-                {"family": "datagram", "subevent": "datagram.emit_complete"},
+            inner_framing = validate_webtransport_inner_framing(
+                lane=lane,
+                inner_framing=framing_spec_from_kind(_binding_get(binding, "inner_framing")),
             )
-        else:  # pragma: no cover - guarded by webtransport_lane_for_profile
-            raise _unsupported(f"webtransport lane {lane}")
+            family = webtransport_runtime_family(lane)
+            framing = framing_spec_kind(inner_framing)
+            framing_kind = framing
+            framing_spec = framing_spec_name(inner_framing)
+            if lane == "session":
+                anchors = (
+                    "transport.accept",
+                    "dispatch.subevent.derive",
+                    "handler.invoke",
+                    "transport.close",
+                )
+                rows = (
+                    {"family": "session", "subevent": "session.open"},
+                    {"family": "session", "subevent": "session.close"},
+                )
+            elif lane == "bidi_stream":
+                anchors = (
+                    "transport.accept",
+                    "transport.receive",
+                    "framing.decode",
+                    "dispatch.subevent.derive",
+                    "handler.invoke",
+                    "framing.encode",
+                    "transport.emit",
+                    "transport.close",
+                )
+                rows = (
+                    {"family": "stream", "subevent": "stream.open"},
+                    {"family": "stream", "subevent": "stream.chunk.received"},
+                    {"family": "stream", "subevent": "stream.chunk.emit"},
+                    {"family": "stream", "subevent": "stream.close"},
+                )
+            elif lane == "unidi_client_stream":
+                anchors = (
+                    "transport.accept",
+                    "transport.receive",
+                    "framing.decode",
+                    "dispatch.subevent.derive",
+                    "handler.invoke",
+                    "transport.close",
+                )
+                rows = (
+                    {"family": "stream", "subevent": "stream.open"},
+                    {"family": "stream", "subevent": "stream.chunk.received"},
+                    {"family": "stream", "subevent": "stream.close"},
+                )
+            elif lane == "unidi_server_stream":
+                anchors = (
+                    "transport.accept",
+                    "handler.invoke",
+                    "framing.encode",
+                    "transport.emit",
+                    "transport.close",
+                )
+                rows = (
+                    {"family": "stream", "subevent": "stream.open"},
+                    {"family": "stream", "subevent": "stream.chunk.emit"},
+                    {"family": "stream", "subevent": "stream.emit_complete"},
+                    {"family": "stream", "subevent": "stream.close"},
+                )
+            elif lane == "datagram":
+                anchors = (
+                    "transport.accept",
+                    "transport.receive",
+                    "framing.decode",
+                    "dispatch.subevent.derive",
+                    "handler.invoke",
+                    "framing.encode",
+                    "transport.emit",
+                )
+                rows = (
+                    {"family": "datagram", "subevent": "datagram.received"},
+                    {"family": "datagram", "subevent": "datagram.emit"},
+                    {"family": "datagram", "subevent": "datagram.emit_complete"},
+                )
+            else:  # pragma: no cover - guarded by webtransport_lane_for_profile
+                raise _unsupported(f"webtransport lane {lane}")
     else:
         raise _unsupported(kind)
 
@@ -249,10 +394,21 @@ def compile_binding_protocol_plan(op_id: str, binding: Mapping[str, Any]) -> dic
         "binding": kind,
         "framing": framing,
     }
+    if subprotocols:
+        event_key_inputs["subprotocols"] = subprotocols
+    if kind in {"http.jsonrpc", "https.jsonrpc"}:
+        event_key_inputs["path"] = rpc_path
+        event_key_inputs["method"] = rpc_method
+    if kind in {"ws", "wss", "websocket"} and websocket_subprotocol is not None:
+        event_key_inputs["websocket_subprotocol"] = websocket_subprotocol
     if kind == "webtransport":
         event_key_inputs["lane"] = lane
-        event_key_inputs["inner_framing"] = inner_framing
-    resume_policy = compile_resume_policy(kind, binding)
+        if lane_catalog is not None:
+            event_key_inputs["lane_catalog"] = lane_catalog
+        else:
+            event_key_inputs["inner_framing"] = framing_spec_kind(inner_framing)
+            event_key_inputs["inner_framing_spec"] = framing_spec_name(inner_framing)
+    resume_policy = compile_resume_policy(kind, binding if isinstance(binding, Mapping) else {})
     if resume_policy.enabled:
         event_key_inputs["resume_mode"] = resume_policy.mode
 
@@ -261,6 +417,8 @@ def compile_binding_protocol_plan(op_id: str, binding: Mapping[str, Any]) -> dic
         "binding_kind": kind,
         "family": family,
         "framing": framing,
+        "framing_kind": framing_kind or str(framing),
+        "framing_spec": framing_spec,
         "atom_anchors": anchors,
         "event_key_inputs": event_key_inputs,
         "capability_requirements": {
@@ -268,6 +426,20 @@ def compile_binding_protocol_plan(op_id: str, binding: Mapping[str, Any]) -> dic
         },
         "lifecycle_rows": rows,
     }
+    if subprotocols:
+        plan["subprotocols"] = subprotocols
+    if kind in {"http.jsonrpc", "https.jsonrpc"}:
+        plan["path"] = rpc_path
+        plan["method"] = rpc_method
+    if kind in {"ws", "wss", "websocket"} and websocket_subprotocol is not None:
+        plan["websocket_subprotocol"] = websocket_subprotocol
+    if kind == "webtransport":
+        if lane_catalog is not None:
+            plan["lane_catalog"] = lane_catalog
+        else:
+            plan["inner_framing"] = framing_spec_kind(inner_framing)
+            plan["inner_framing_kind"] = framing_spec_kind(inner_framing)
+            plan["inner_framing_spec"] = framing_spec_name(inner_framing)
     if resume_policy.enabled:
         plan["resume_policy"] = resume_policy.as_dict()
     return plan

tigrbl_kernel/types.py

@@ -41,6 +41,10 @@ EFFECT_BY_ATOM_NAME = {
     "sys.handler_append_chunk": EFFECT_WIRE,
     "sys.handler_send_datagram": EFFECT_WIRE,
     "sys.handler_checkpoint": EFFECT_WIRE,
+    "sys.handler_open_bidi_stream": EFFECT_WIRE,
+    "sys.handler_open_unidi_stream": EFFECT_WIRE,
+    "sys.handler_close_stream": EFFECT_WIRE,
+    "sys.handler_close_session": EFFECT_WIRE,
     "egress.to_transport_response": EFFECT_WIRE,
     "egress.asgi_send": EFFECT_WIRE,
 }

tigrbl_kernel/utils.py

@@ -161,8 +161,8 @@ def _route_payload_template() -> dict[str, Any]:
     return {
         "http.rest": {"exact": {}, "templated": []},
         "https.rest": {"exact": {}, "templated": []},
-        "http.jsonrpc": {"endpoints": {}},
-        "https.jsonrpc": {"endpoints": {}},
+        "http.jsonrpc": {"paths": {}, "endpoints": {}},
+        "https.jsonrpc": {"paths": {}, "endpoints": {}},
         "ws": {"exact": {}, "templated": []},
         "wss": {"exact": {}, "templated": []},
     }

tigrbl_kernel/webtransport_events.py

@@ -3,7 +3,10 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import Any
 
-from tigrbl_core._spec.binding_spec import validate_webtransport_inner_framing
+from tigrbl_core._spec.binding_spec import (
+    framing_spec_from_kind,
+    validate_webtransport_inner_framing,
+)
 
 
 def _event(subevent: str, atom: str, family: str) -> dict[str, str]:
@@ -194,7 +197,7 @@ def _validate_stream_payload(
         raise ValueError("client_to_server unidirectional streams cannot be send events")
     validate_webtransport_inner_framing(
         lane=lane,
-        inner_framing=payload.get("framing"),
+        inner_framing=framing_spec_from_kind(payload.get("framing")),
     )
     projection = {
         "family": "stream",
@@ -228,7 +231,7 @@ def _validate_datagram_payload(
     _forbid(payload, "stream_id", "stream_direction", "stream_initiator", "lane_id")
     validate_webtransport_inner_framing(
         lane="datagram",
-        inner_framing=payload.get("framing"),
+        inner_framing=framing_spec_from_kind(payload.get("framing")),
     )
     return {"family": "datagram", "lane": "datagram", "exchange": "bidirectional_stream"}
 

{tigrbl_kernel-0.4.4.dev1.dist-info → tigrbl_kernel-0.4.4.dev8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl-kernel
-Version: 0.4.4.dev1
+Version: 0.4.4.dev8
 Summary: Kernel orchestration for composing Tigrbl runtime plans, bindings, operation dispatch, and optimized ASGI execution.
 License: Apache License
                                     Version 2.0, January 2004
@@ -318,7 +318,6 @@ Package catalog:
 - `tigrbl_kernel/protocol_bindings.py`, `tigrbl_kernel/protocol_phase_tree.py`, `tigrbl_kernel/protocol_chains/`, `tigrbl_kernel/protocol_completion.py`, `tigrbl_kernel/protocol_fusion.py`, and `tigrbl_kernel/protocol_legality_matrix.py`: transport-specific plan compilation, phase tree construction, chain definitions, completion semantics, fusion, and legality checks.
 - `tigrbl_kernel/eventkey.py`, `tigrbl_kernel/events.py`, `tigrbl_kernel/transport_events.py`, `tigrbl_kernel/webtransport_events.py`, `tigrbl_kernel/subevent_taxonomy.py`, and `tigrbl_kernel/subevent_handlers.py`: event-key construction, subevent taxonomy, and protocol subevent handler mapping.
 - `tigrbl_kernel/opchannel_capabilities.py`, `tigrbl_kernel/loop_modes.py`, `tigrbl_kernel/loop_regions.py`, `tigrbl_kernel/segment_fusion.py`, and `tigrbl_kernel/contract_classification.py`: channel capability checks, loop planning, segment grouping, and contract classification.
-- `tigrbl_kernel/rust_plan.py`, `tigrbl_kernel/rust_compile.py`, and `tigrbl_kernel/rust_spec.py`: deprecated compatibility shims; kernel planning is Python-only.
 
 ## Public API and Import Surface
 
@@ -354,9 +353,9 @@ Protocol planning keeps binding kind, family, framing, exchange, lane, subevent
 | `http.stream` / `https.stream` | stream | stream | handler invoke, transport emit, stream close. |
 | `http.sse` / `https.sse` | stream | SSE | encode event, emit event, close stream. |
 | `ws` / `wss` / `websocket` | message | text or negotiated JSON-RPC | accept, decode, dispatch, handler, emit/close. |
-| `webtransport` | session, stream, or datagram | WebTransport outer framing | lane-specific session, stream, or datagram rows with inner-framing validation. |
+| `webtransport` | session, stream, or datagram | no top-level app framing | lane-specific session, stream, or datagram rows with lane-local framing validation. |
 
-Unsupported or ambiguous bindings raise planning errors. For example, WebSocket bindings do not accept HTTP methods, HTTP JSON-RPC requires an RPC method, WebTransport request/response exchange is unsupported, and WebTransport outer framing must remain `webtransport`.
+Unsupported or ambiguous bindings raise planning errors. For example, WebSocket bindings do not accept HTTP methods, HTTP JSON-RPC requires an RPC method, WebTransport request/response exchange is unsupported, and WebTransport app framing must be declared on the relevant control stream, stream, or datagram lane.
 
 ## Hook Ordering and Labels
 

{tigrbl_kernel-0.4.4.dev1.dist-info → tigrbl_kernel-0.4.4.dev8.dist-info}/RECORD

@@ -1,13 +1,13 @@
 tigrbl_kernel/__init__.py,sha256=fE63Iyq2XrWqFTsvSC28iomE5nW6HsDUOEoQQtPNZ0I,2233
 tigrbl_kernel/_build.py,sha256=kHaS9k4cD5hg1eRj8aQnbPbUkTbOM8npE_yeOsiwUK8,50397
-tigrbl_kernel/_compile.py,sha256=D8Vohdh3ryhdC9--yBIeKNxbkqpqzJZlmW2dbbkbmyE,11054
+tigrbl_kernel/_compile.py,sha256=g1_TP-wMp-O2qLjWkBupXHJ_cAFjeoldXl9L2hDF_gw,15248
 tigrbl_kernel/atoms.py,sha256=ZNGj2PBUMu1BvPjNYlz4_vu4vhx4gD20C7zNE_GKfe8,12253
 tigrbl_kernel/cache.py,sha256=NxuqvH03xYwcQoY86ie1hmtDeA36XdiLmNyx2ImLQ6k,2596
 tigrbl_kernel/callbacks.py,sha256=r_ZI19nbAoDM-uf-FMUmWWAF9WaEKJK3Fpg-58ui8a4,772
 tigrbl_kernel/channel_taxonomy.py,sha256=x_cZHXz_Bw6NGaTK3YdZGUrzH1nBVAMlzViGKiv2K6s,4330
-tigrbl_kernel/contract_classification.py,sha256=5ZbhtJr88VtIPAtPWD5eL4BKKQU734kZeMEvEqh9cvU,6009
-tigrbl_kernel/core.py,sha256=3lR3VrlHOFiP-POLluEpBKWeGDdaqX8tJYHQ0eRluP0,6667
-tigrbl_kernel/cross_transport.py,sha256=Dk01IRjQ6LVvPeRRxB5r6UXwqzOsSl_mJh1gjoh61jk,5396
+tigrbl_kernel/contract_classification.py,sha256=Qfrn_aDPlCKvJGmAgdu0CuL-bZINW553TqD411rew4E,6132
+tigrbl_kernel/core.py,sha256=7xa4zhMxth7MGzgXnxxnHumchVKcyYHBf5mWNfMk4_M,6518
+tigrbl_kernel/cross_transport.py,sha256=24A4Hm-E6czX7o09EgwqL3WzGQtvifwnXMPB-ztZZzs,5354
 tigrbl_kernel/dispatch_taxonomy.py,sha256=lj-_4hVKzrlPkavAlNqu7eImhjJn-7QoyccquQylCn0,1658
 tigrbl_kernel/eventkey.py,sha256=aTwzBkAjeC-kaEUItL1Mcfcq_Ur1fUbZDY6XxKdwWdg,1980
 tigrbl_kernel/eventkey_hooks.py,sha256=Cbkev0GXgSH27dlFoVeaKC7XuQ9yJq4bI1Mlc3qB4Qs,2480
@@ -26,8 +26,8 @@ tigrbl_kernel/ordering.py,sha256=C6fHkAwQA_1AY7sEAUy_FC5U3eFmsyqcls1li1qG5MA,135
 tigrbl_kernel/packed_access.py,sha256=KhvAt-X4_bsowYVQ47tWEIfQhpcvTmPG7BqzuEWF87U,3587
 tigrbl_kernel/packed_selectors.py,sha256=ZgPvOTUsTSF_ZIpQHM3acQhdIbM0-c6lBW7WjdAROI4,8609
 tigrbl_kernel/payload.py,sha256=eyHo-cAUXLWQQ9-xZVOl_rjFudA-djMZji9hoK-v9IE,2167
-tigrbl_kernel/protocol_anchors.py,sha256=4yGS_66x-VEdoq6aFg6UM2qBP7Lz7cLfjLq2O_NdysI,1232
-tigrbl_kernel/protocol_bindings.py,sha256=mRf4X-9jKcnAPm__IsE3LdNiHxYeWLDtaJViVq8lIXs,10784
+tigrbl_kernel/protocol_anchors.py,sha256=0jAXmSQ-OD3AGv7MM-2vF7hQmZtHG2bXwFM1ooi0Geg,863
+tigrbl_kernel/protocol_bindings.py,sha256=oE50T0YIEDAPXqxpXnmSAmJWX_SbSPdXBL8FtFF7OgI,18760
 tigrbl_kernel/protocol_chains/__init__.py,sha256=iSnOw5R4ahGypm59bQgPpsBwFXbPcnKPozjSfc9N6GQ,151
 tigrbl_kernel/protocol_chains/http_stream.py,sha256=nop3qMn-zpS5yK9QjqrFA68e1lO-uOb0dWAZf5fPrBg,2427
 tigrbl_kernel/protocol_chains/http_unary.py,sha256=7EABv0bUAJ5UI3TWP-S-8LtgwZJLj5pw-ZnZ_8qiD4g,1776
@@ -42,9 +42,6 @@ tigrbl_kernel/protocol_phase_tree.py,sha256=LhJdoKfQivKHSDu75KYoq1VoYYkbXaekuN32
 tigrbl_kernel/protocol_streams.py,sha256=UUCNn3L5n9PkgSydI4LGzJXFAKT1D9GPPnq6-xbMnBI,17141
 tigrbl_kernel/resume_policy.py,sha256=rHBySvRJKfJ4J2NCb1D49FAXUsSp9rpzg4ev7ewXrSk,2931
 tigrbl_kernel/runtime_contracts.py,sha256=I13L8mWQyYeojll9U2IbPFqZlvcv3MpCU376iNO4RbA,8243
-tigrbl_kernel/rust_compile.py,sha256=dB36g6w1PCh1sOubd7XKUaJlGyrFC4hr__4PfJfnZiE,608
-tigrbl_kernel/rust_plan.py,sha256=N-YZ6oGRtIJKuxS5f7HwhTldrTnozLXWgfpOD2XDGjI,502
-tigrbl_kernel/rust_spec.py,sha256=cMzlYsUwVcJLcIJAbX5gcCnRzhqrJZyeYb5whn_gIBU,853
 tigrbl_kernel/segment_fusion.py,sha256=zbPNGd1eFJGFZHJxrfanaNMyrJjJw1aPRsl_jJfN4sM,1607
 tigrbl_kernel/subevent_handlers.py,sha256=4j4780QjQiqY4qpRsyxrPh_znRK3SkLAFDN_x6eidwU,1779
 tigrbl_kernel/subevent_taxonomy.py,sha256=67RJ7ZkfJMLfa7evzVfTlFqtdWSnhp65zwA4qhNwSG8,2274
@@ -52,11 +49,11 @@ tigrbl_kernel/trace.py,sha256=dWILtq9seOj-WwCx__Pk_VZAbFIN1tqTbs0gIndYkU8,9816
 tigrbl_kernel/transaction_units.py,sha256=_NeQHycjjDoLG1kmD74o10wDQpdA5qjs-Sd_fxPb0_E,863
 tigrbl_kernel/transport_atoms.py,sha256=enfNCMuLgLMKi8zraMm-QOk7ys5d9kcP-WPr0-wK6KE,2136
 tigrbl_kernel/transport_events.py,sha256=CyPhs69H7mnKU7gNgt4XtH-eRJcihSaXxQDzC0iD4w4,3903
-tigrbl_kernel/types.py,sha256=p5AU0BGfvhDQxNHn8T5TY62V4iBCL8PKKjL4iy908w0,2241
-tigrbl_kernel/utils.py,sha256=iCcm0flQfAi4w4cbVEaq6yiPR-kAoXx2owiRpbBf-0o,6953
-tigrbl_kernel/webtransport_events.py,sha256=iLWkM0sef48osaIAJ34KfV9ZEkDkUWWR5DwowyA5XFI,10735
-tigrbl_kernel-0.4.4.dev1.dist-info/METADATA,sha256=q3uqIOQ9sVgK3eLA8pZFT6LviXPCwIqPjT27B96rmIM,28075
-tigrbl_kernel-0.4.4.dev1.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
-tigrbl_kernel-0.4.4.dev1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-tigrbl_kernel-0.4.4.dev1.dist-info/licenses/NOTICE,sha256=EvJMTshzsWz43LiK-DeN2ZuLtrP49cxvlrFlJ8F_buc,221
-tigrbl_kernel-0.4.4.dev1.dist-info/RECORD,,
+tigrbl_kernel/types.py,sha256=Pf2e6xvZAcxD_uJZ7inMETpmhNyz4YGT27YuWdSHZ-I,2431
+tigrbl_kernel/utils.py,sha256=xf4lZAIH64DhpdHHyzPJ0LSAiUKWSaC5wIL1NJkHVro,6979
+tigrbl_kernel/webtransport_events.py,sha256=SWADw4m2JsCHHvMfH7QcVPtjOZ0kfjiCwwoiLhCokmk,10820
+tigrbl_kernel-0.4.4.dev8.dist-info/METADATA,sha256=dpEAt_8EUxxhZj_2Y1zIB4XoWkpWsxSV0zIUHoTFbwM,27960
+tigrbl_kernel-0.4.4.dev8.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+tigrbl_kernel-0.4.4.dev8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tigrbl_kernel-0.4.4.dev8.dist-info/licenses/NOTICE,sha256=EvJMTshzsWz43LiK-DeN2ZuLtrP49cxvlrFlJ8F_buc,221
+tigrbl_kernel-0.4.4.dev8.dist-info/RECORD,,

tigrbl_kernel/rust_compile.py

@@ -1,24 +0,0 @@
-from __future__ import annotations
-from typing import Any
-
-from .rust_plan import RustPlan
-import warnings
-
-
-def _raise_deprecated(action: str) -> None:
-    warnings.warn(
-        "tigrbl_kernel Rust planning is deprecated; kernel planning is Python-only.",
-        DeprecationWarning,
-        stacklevel=3,
-    )
-    raise RuntimeError(f"{action} is unavailable; Tigrbl kernel planning is Python-only.")
-
-
-def build_rust_kernel(app: Any) -> RustPlan:
-    del app
-    _raise_deprecated("build_rust_kernel")
-
-
-def normalize_rust_spec(app: Any) -> str:
-    del app
-    _raise_deprecated("normalize_rust_spec")

tigrbl_kernel/rust_plan.py

@@ -1,20 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any
-import warnings
-
-
-@dataclass(slots=True)
-class RustPlan:
-    description: str
-    compiled_plan: dict[str, Any] | None = None
-    backend: str = "deprecated-rust"
-    normalized_spec: str | None = None
-
-    def __post_init__(self) -> None:
-        warnings.warn(
-            "RustPlan is deprecated; Tigrbl kernel planning is Python-only.",
-            DeprecationWarning,
-            stacklevel=2,
-        )

tigrbl_kernel/rust_spec.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-import warnings
-from typing import Any, NoReturn
-
-
-def _raise_deprecated(action: str) -> NoReturn:
-    warnings.warn(
-        "tigrbl_kernel Rust spec serialization is deprecated; "
-        "Tigrbl runtime execution is Python-only.",
-        DeprecationWarning,
-        stacklevel=3,
-    )
-    raise RuntimeError(f"{action} is unavailable; Tigrbl runtime execution is Python-only.")
-
-
-def build_rust_app_spec(app: Any) -> dict[str, Any]:
-    del app
-    _raise_deprecated("build_rust_app_spec")
-
-
-def coerce_rust_spec_dict(app: Any) -> dict[str, Any]:
-    del app
-    _raise_deprecated("coerce_rust_spec_dict")
-
-
-def coerce_rust_spec_json(app: Any) -> str:
-    del app
-    _raise_deprecated("coerce_rust_spec_json")
-
-
-__all__ = [
-    "build_rust_app_spec",
-    "coerce_rust_spec_dict",
-    "coerce_rust_spec_json",
-]