tigrbl-kernel 0.4.5.dev4__py3-none-any.whl → 0.4.5.dev8__py3-none-any.whl

tigrbl_kernel/__init__.py

@@ -18,6 +18,7 @@ _LAZY_EXPORTS = {
     "PackedKernel": "models",
     "SchemaIn": "models",
     "SchemaOut": "models",
+    "SchemaStored": "models",
 }
 
 _default_kernel = None
@@ -73,6 +74,7 @@ __all__ = [
     "PackedKernel",
     "SchemaIn",
     "SchemaOut",
+    "SchemaStored",
     "build_kernel_plan",
     "build_packed_kernel",
     "build_packed_kernel_measurement_view",

tigrbl_kernel/_build.py

@@ -91,6 +91,12 @@ _DECODER_TIME = 9
 _WS_FAST_PATH_BYPASS_ATOM_NAMES = frozenset(
     {
         "ingress.ctx_init",
+        "ingress.transport_extract",
+        "transport.sink_bind",
+        "ingress.input_prepare",
+        "dispatch.binding_match",
+        "dispatch.binding_parse",
+        "dispatch.input_normalize",
         "dispatch.op_resolve",
         "schema.collect_in",
         "handler.custom",
@@ -213,6 +219,8 @@ def _is_batch_domain_run(run: Any) -> bool:
     except ValueError:
         return False
     domain = parts[index + 1] if index + 1 < len(parts) else None
+    if domain == "transport" and parts[-1] == "sink_bind":
+        return False
     return domain in {"transport", "intent", "batch", "fanout"}
 
 
@@ -1156,8 +1164,18 @@ def _pack_kernel_plan(
         )
         alias_name = str(getattr(meta, "alias", "") or "")
         target_name = str(getattr(meta, "target", "") or "")
+        opview = opviews[program_id] if program_id < len(opviews) else None
         compiled_param_eligible = not (
-            alias_name.startswith("bulk_") or target_name.startswith("bulk_")
+            alias_name.startswith("bulk_")
+            or target_name.startswith("bulk_")
+            # Selector aliases and URL precedence are validated by wire.validate_in.
+            # The scalar compiled decoder does not implement that contract yet.
+            or any(
+                entry.get("selector")
+                for entry in (
+                    getattr(getattr(opview, "schema_in", None), "by_field", {}) or {}
+                ).values()
+            )
         )
         compiled_param_phase_steps = (
             program_compiled_param_phase_steps[program_id]

tigrbl_kernel/_compile.py

@@ -95,6 +95,7 @@ def _route_metadata_for_binding(binding: Any) -> dict[str, Any]:
         metadata["lane"] = lane
         metadata["inner_framing"] = framing_kind(inner_framing)
         metadata["inner_framing_spec"] = framing_spec_name(inner_framing)
+        metadata["rpc_method"] = getattr(binding, "rpc_method", None)
         if inner_framing is not None:
             metadata["inner_framing_kind"] = str(inner_framing)
             metadata["inner_framing_spec"] = framing_spec_name(inner_framing)
@@ -206,8 +207,6 @@ def _compile_plan(self: Any, app: Any) -> KernelPlan:
     from tigrbl_core._spec.binding_spec import (
         HttpJsonRpcBindingSpec,
         HttpRestBindingSpec,
-        HttpJsonRpcProtocolBindingSpec,
-        HttpRestProtocolBindingSpec,
         HttpStreamBindingSpec,
         SseBindingSpec,
         WebSocketProtocolBindingSpec,
@@ -281,7 +280,9 @@ def _compile_plan(self: Any, app: Any) -> KernelPlan:
                                     meta_index
                                 )
 
-                elif isinstance(binding, (HttpJsonRpcBindingSpec, HttpJsonRpcProtocolBindingSpec)):
+                elif isinstance(
+                    binding, (HttpJsonRpcBindingSpec, HttpJsonRpcProtocolBindingSpec)
+                ):
                     rpc_path = str(
                         getattr(
                             binding,
@@ -302,8 +303,12 @@ def _compile_plan(self: Any, app: Any) -> KernelPlan:
                     proto_bucket = route_data.setdefault(
                         binding.proto, {"paths": {}, "endpoints": {}}
                     )
-                    path_bucket = proto_bucket.setdefault("paths", {}).setdefault(rpc_path, {})
-                    endpoint_bucket = proto_bucket.setdefault("endpoints", {}).setdefault(rpc_path, {})
+                    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,
@@ -326,6 +331,17 @@ def _compile_plan(self: Any, app: Any) -> KernelPlan:
                     bucket = route_data.setdefault(
                         binding.proto, {"exact": {}, "templated": []}
                     )
+                    if (
+                        isinstance(
+                            binding, (WsBindingSpec, WebSocketProtocolBindingSpec)
+                        )
+                        and framing_kind(getattr(binding, "framing", None)) == "jsonrpc"
+                        and bool(getattr(sp, "expose_method", True))
+                    ):
+                        # JSON-RPC method operations are dispatched inside the
+                        # framework-owned WebSocket session. Only the hidden
+                        # transport operation may own the socket path itself.
+                        continue
                     selector = binding.path
                     route_metadata = _route_metadata_for_binding(binding)
                     opkey_to_meta[OpKey(proto=binding.proto, selector=selector)] = (
@@ -345,13 +361,25 @@ def _compile_plan(self: Any, app: Any) -> KernelPlan:
                             }
                         )
                     else:
-                        bucket["exact"][selector] = meta_index
-                        bucket.setdefault("exact_metadata", {})[selector] = {
+                        route_row = {
                             "path": binding.path,
                             "meta_index": meta_index,
                             "selector": selector,
                             **route_metadata,
                         }
+                        if binding.proto == "webtransport":
+                            bucket["exact"].setdefault(selector, meta_index)
+                            bucket.setdefault("routes", {}).setdefault(
+                                selector, []
+                            ).append(route_row)
+                            bucket.setdefault("exact_metadata", {}).setdefault(
+                                selector, route_row
+                            )
+                        else:
+                            bucket["exact"][selector] = meta_index
+                            bucket.setdefault("exact_metadata", {})[selector] = (
+                                route_row
+                            )
 
     semantic = KernelPlan(
         proto_indices=route_data,

tigrbl_kernel/models.py

@@ -51,6 +51,13 @@ class SchemaOut:
     expose: Tuple[str, ...]
 
 
+@dataclass(frozen=True)
+class SchemaStored:
+    fields: Tuple[str, ...]
+    by_field: Dict[str, Dict[str, object]]
+    required_from_client: Tuple[str, ...] = ()
+
+
 @dataclass(frozen=True)
 class OpView:
     schema_in: SchemaIn
@@ -59,6 +66,7 @@ class OpView:
     virtual_producers: Dict[str, Callable[[object, dict], object]]
     to_stored_transforms: Dict[str, Callable[[object, dict], object]]
     refresh_hints: Tuple[str, ...]
+    schema_stored: SchemaStored | None = None
 
 
 @dataclass(frozen=True, slots=True)

tigrbl_kernel/opview_compiler.py

@@ -2,7 +2,41 @@ from __future__ import annotations
 
 from typing import Any, Dict, Mapping
 
-from .models import OpView, SchemaIn, SchemaOut
+from tigrbl_core.schema.builder.helpers import (
+    _normalize_py_type,
+    _storage_python_type,
+    _spec_python_type,
+    _input_selector_entries,
+    _input_filter_entries,
+)
+
+from .models import OpView, SchemaIn, SchemaOut, SchemaStored
+
+_READ_ONLY_TARGETS = frozenset(
+    {
+        "read",
+        "list",
+        "count",
+        "exists",
+        "aggregate",
+        "group_by",
+        "subscribe",
+        "tail",
+        "download",
+    }
+)
+_NON_PERSISTING_TARGETS = frozenset(
+    {
+        "delete",
+        "clear",
+        "bulk_delete",
+        "close_stream",
+        "close_session",
+    }
+)
+_CREATE_LIKE_TARGETS = frozenset({"create", "bulk_create"})
+_UPDATE_LIKE_TARGETS = frozenset({"update", "merge", "bulk_update", "bulk_merge"})
+_REPLACE_LIKE_TARGETS = frozenset({"replace", "bulk_replace"})
 
 
 def _storage_requires_input(storage: Any, alias: str) -> bool:
@@ -22,22 +56,87 @@ def _storage_requires_input(storage: Any, alias: str) -> bool:
     return not bool(getattr(storage, "nullable", True)) and not has_default
 
 
+def _storage_has_server_default(spec: Any, storage: Any) -> bool:
+    return bool(
+        getattr(storage, "default", None) is not None
+        or getattr(storage, "server_default", None) is not None
+        or callable(getattr(storage, "default_factory", None))
+        or callable(getattr(spec, "default_factory", None))
+    )
+
+
+def _supports_stored_shape(target: str) -> bool:
+    lowered = str(target or "").lower()
+    return lowered not in _READ_ONLY_TARGETS and lowered not in _NON_PERSISTING_TARGETS
+
+
+def _is_input_enabled(io: Any, semantic_verbs: tuple[str, ...]) -> bool:
+    in_verbs = set(getattr(io, "in_verbs", ()) or ())
+    return any(name in in_verbs for name in semantic_verbs)
+
+
+def _is_paired_enabled(io: Any, semantic_verbs: tuple[str, ...]) -> bool:
+    cfg = getattr(io, "_paired", None)
+    if cfg is None:
+        return False
+    paired_verbs = set(getattr(cfg, "verbs", ()) or ())
+    return any(name in paired_verbs for name in semantic_verbs)
+
+
+def _include_in_stored_schema(
+    *,
+    spec: Any,
+    io: Any,
+    storage: Any,
+    semantic_verbs: tuple[str, ...],
+    target: str,
+) -> bool:
+    lowered = str(target or "").lower()
+    if storage is None or not _supports_stored_shape(lowered):
+        return False
+    if _is_input_enabled(io, semantic_verbs) or _is_paired_enabled(io, semantic_verbs):
+        return True
+    if lowered in _CREATE_LIKE_TARGETS or lowered in _UPDATE_LIKE_TARGETS:
+        return True
+    if lowered in _REPLACE_LIKE_TARGETS:
+        return True
+    return False
+
+
+def _stored_required(storage: Any, spec: Any, target: str, *, derived: bool) -> bool:
+    lowered = str(target or "").lower()
+    if lowered in _UPDATE_LIKE_TARGETS:
+        return False
+    if lowered in _NON_PERSISTING_TARGETS or lowered in _READ_ONLY_TARGETS:
+        return False
+    if derived:
+        return True
+    return not bool(
+        getattr(storage, "nullable", True)
+    ) and not _storage_has_server_default(
+        spec,
+        storage,
+    )
+
+
 def compile_opview_from_specs(specs: Mapping[str, Any], sp: Any) -> OpView:
     """Build a basic OpView from collected specs when no app/model is present."""
     alias = str(getattr(sp, "alias", "") or "")
     target = str(getattr(sp, "target", alias) or alias)
     semantic_verbs = tuple(
         dict.fromkeys(
-            name
-            for name in (alias, target)
-            if isinstance(name, str) and name
+            name for name in (alias, target) if isinstance(name, str) and name
         )
     )
 
     in_fields: list[str] = []
     out_fields: list[str] = []
+    stored_fields: list[str] = []
     by_field_in: Dict[str, Dict[str, object]] = {}
     by_field_out: Dict[str, Dict[str, object]] = {}
+    by_field_stored: Dict[str, Dict[str, object]] = {}
+    required_from_client: list[str] = []
+    to_stored_transforms: Dict[str, Any] = {}
 
     for name, spec in specs.items():
         io = getattr(spec, "io", None)
@@ -51,7 +150,7 @@ def compile_opview_from_specs(specs: Mapping[str, Any], sp: Any) -> OpView:
             meta: Dict[str, object] = {"in_enabled": True}
             if storage is None:
                 meta["virtual"] = True
-            py_type = getattr(fs, "py_type", None)
+            py_type = _spec_python_type(spec)
             if py_type is not None and py_type is not Any:
                 meta["py_type"] = py_type
             constraints = getattr(fs, "constraints", {}) or {}
@@ -72,7 +171,13 @@ def compile_opview_from_specs(specs: Mapping[str, Any], sp: Any) -> OpView:
                     getattr(io, "header_required_in", False)
                 )
             required = bool(
-                (fs and any(name in getattr(fs, "required_in", ()) for name in semantic_verbs))
+                (
+                    fs
+                    and any(
+                        name in getattr(fs, "required_in", ())
+                        for name in semantic_verbs
+                    )
+                )
                 or _storage_requires_input(storage, target)
             )
             meta["required"] = required
@@ -96,6 +201,64 @@ def compile_opview_from_specs(specs: Mapping[str, Any], sp: Any) -> OpView:
                 meta_out["py_type"] = py_type
             by_field_out[name] = meta_out
 
+        if _include_in_stored_schema(
+            spec=spec,
+            io=io,
+            storage=storage,
+            semantic_verbs=semantic_verbs,
+            target=target,
+        ):
+            stored_fields.append(name)
+            input_enabled = _is_input_enabled(io, semantic_verbs)
+            paired_enabled = _is_paired_enabled(io, semantic_verbs)
+            server_default = _storage_has_server_default(spec, storage)
+            py_type = getattr(fs, "py_type", None)
+            if py_type is None or py_type is Any:
+                py_type = _storage_python_type(getattr(storage, "type_", None))
+            else:
+                py_type = _normalize_py_type(py_type)
+            stored_meta: Dict[str, object] = {
+                "nullable": bool(getattr(storage, "nullable", True)),
+                "from_client": input_enabled,
+                "required_from_client": bool(
+                    input_enabled and _storage_requires_input(storage, target)
+                ),
+                "server_default": server_default,
+            }
+            if py_type is not Any:
+                stored_meta["py_type"] = py_type
+            constraints = getattr(fs, "constraints", {}) or {}
+            if isinstance(constraints, Mapping):
+                max_length = constraints.get("max_length")
+                if isinstance(max_length, int) and max_length > 0:
+                    stored_meta["max_length"] = max_length
+
+            transform = getattr(getattr(storage, "transform", None), "to_stored", None)
+            if callable(transform):
+                to_stored_transforms[name] = transform
+
+            derived = paired_enabled or callable(transform)
+            stored_meta["derived"] = derived
+            stored_meta["required"] = _stored_required(
+                storage,
+                spec,
+                target,
+                derived=derived,
+            )
+            if stored_meta["required_from_client"]:
+                required_from_client.append(name)
+            by_field_stored[name] = stored_meta
+
+    for name, meta in {
+        **_input_filter_entries(specs, target),
+        **_input_selector_entries(specs, target),
+    }.items():
+        if name not in by_field_in:
+            in_fields.append(name)
+            by_field_in[name] = meta
+        elif meta.get("selector"):
+            by_field_in[name] = {**meta, **by_field_in[name], "selector": True}
+
     schema_in = SchemaIn(
         fields=tuple(sorted(in_fields)),
         by_field={field: by_field_in.get(field, {}) for field in sorted(in_fields)},
@@ -105,6 +268,18 @@ def compile_opview_from_specs(specs: Mapping[str, Any], sp: Any) -> OpView:
         by_field={field: by_field_out.get(field, {}) for field in sorted(out_fields)},
         expose=tuple(sorted(out_fields)),
     )
+    stored_fields_sorted = tuple(sorted(stored_fields))
+    schema_stored = (
+        SchemaStored(
+            fields=stored_fields_sorted,
+            by_field={
+                field: by_field_stored.get(field, {}) for field in stored_fields_sorted
+            },
+            required_from_client=tuple(sorted(required_from_client)),
+        )
+        if stored_fields_sorted
+        else None
+    )
     paired_index: Dict[str, Dict[str, object]] = {}
     for field, col in specs.items():
         io = getattr(col, "io", None)
@@ -131,6 +306,7 @@ def compile_opview_from_specs(specs: Mapping[str, Any], sp: Any) -> OpView:
         schema_out=schema_out,
         paired_index=paired_index,
         virtual_producers={},
-        to_stored_transforms={},
+        to_stored_transforms=to_stored_transforms,
         refresh_hints=(),
+        schema_stored=schema_stored,
     )

tigrbl_kernel/packed_selectors.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
 from collections.abc import Mapping, MutableMapping
+from dataclasses import dataclass
+import json
+from typing import Any
 
 from .models import KernelPlan, PackedKernel
 from .packed_access import (
@@ -15,7 +18,9 @@ ExactRouteVerifyCache = MutableMapping[
     int, Mapping[int, Mapping[int, tuple[tuple[str, int], ...]]]
 ]
 ExactWebSocketCache = MutableMapping[int, Mapping[tuple[str, str], int]]
-ExactJsonRpcCache = MutableMapping[int, Mapping[str, Mapping[str, tuple[int, str, str]]]]
+ExactJsonRpcCache = MutableMapping[
+    int, Mapping[str, Mapping[str, tuple[int, str, str]]]
+]
 
 
 def resolve_hot_exact_route_slices(
@@ -32,9 +37,7 @@ def resolve_hot_exact_route_slices(
     if method_ids is None or path_hashes is None or program_ids is None:
         cache[packed_id] = {}
         return {}
-    if not (
-        int(method_ids.count) == int(path_hashes.count) == int(program_ids.count)
-    ):
+    if not (int(method_ids.count) == int(path_hashes.count) == int(program_ids.count)):
         cache[packed_id] = {}
         return {}
     directory: dict[int, tuple[int, int]] = {}
@@ -229,11 +232,148 @@ def resolve_hot_exact_jsonrpc_routes(
                     selector = str(entry.get("selector") or f"{endpoint}:{rpc_method}")
                     method_map[rpc_method] = (meta_index, str(proto), selector)
 
-    frozen = {endpoint: dict(method_map) for endpoint, method_map in exact_routes.items()}
+    frozen = {
+        endpoint: dict(method_map) for endpoint, method_map in exact_routes.items()
+    }
     cache[plan_id] = frozen
     return frozen
 
 
+@dataclass(frozen=True, slots=True)
+class WebTransportProgramSelection:
+    program_id: int = -1
+    path_params: Mapping[str, str] | None = None
+    lane: str | None = None
+    rpc_envelope: Mapping[str, Any] | None = None
+    disposition: str = "no_match"
+
+
+def _webtransport_route_rows(
+    plan: KernelPlan,
+    path: str,
+) -> tuple[tuple[Mapping[str, Any], Mapping[str, str]], ...]:
+    bucket = plan.proto_indices.get("webtransport")
+    if not isinstance(bucket, Mapping):
+        return ()
+
+    rows: list[tuple[Mapping[str, Any], Mapping[str, str]]] = []
+    exact_routes = bucket.get("routes")
+    if isinstance(exact_routes, Mapping):
+        exact = exact_routes.get(path)
+        if isinstance(exact, list):
+            rows.extend((row, {}) for row in exact if isinstance(row, Mapping))
+
+    templated = bucket.get("templated")
+    if isinstance(templated, list):
+        for row in templated:
+            if not isinstance(row, Mapping):
+                continue
+            pattern = row.get("pattern")
+            if pattern is None or not hasattr(pattern, "match"):
+                continue
+            matched = pattern.match(path)
+            if matched is not None:
+                rows.append((row, matched.groupdict()))
+    return tuple(rows)
+
+
+def _webtransport_rpc_envelope(message: Mapping[str, Any]) -> Mapping[str, Any] | None:
+    payload = message.get("data")
+    if payload is None:
+        payload = message.get("bytes")
+    if isinstance(payload, (bytes, bytearray, memoryview)):
+        try:
+            payload = json.loads(bytes(payload).decode("utf-8"))
+        except (UnicodeDecodeError, json.JSONDecodeError):
+            return None
+    elif isinstance(payload, str):
+        try:
+            payload = json.loads(payload)
+        except json.JSONDecodeError:
+            return None
+    return payload if isinstance(payload, Mapping) else None
+
+
+def resolve_webtransport_program(
+    plan: KernelPlan,
+    *,
+    path: str,
+    message: Mapping[str, Any],
+) -> WebTransportProgramSelection:
+    event_type = str(message.get("type") or "")
+    rows = _webtransport_route_rows(plan, path)
+    if event_type in {
+        "webtransport.connect",
+        "webtransport.disconnect",
+        "transport.emit.complete",
+        "transport.emit.failed",
+    }:
+        return WebTransportProgramSelection(disposition="lifecycle")
+
+    lane: str | None = None
+    rpc_envelope: Mapping[str, Any] | None = None
+    rpc_method: str | None = None
+    if event_type == "webtransport.stream.receive":
+        direction = str(message.get("stream_direction") or "bidi")
+        lane = (
+            "unidi_client_stream" if direction == "client_to_server" else "bidi_stream"
+        )
+        if lane == "bidi_stream":
+            rpc_envelope = _webtransport_rpc_envelope(message)
+            method = rpc_envelope.get("method") if rpc_envelope is not None else None
+            rpc_method = method if isinstance(method, str) and method else None
+    elif event_type == "webtransport.datagram.receive":
+        lane = "datagram"
+    else:
+        return WebTransportProgramSelection(disposition="unsupported_event")
+
+    candidates = [
+        (row, params)
+        for row, params in rows
+        if str(row.get("lane") or row.get("profile") or "") == lane
+    ]
+    if lane == "bidi_stream":
+        if rpc_method is None:
+            return WebTransportProgramSelection(
+                lane=lane,
+                rpc_envelope=rpc_envelope,
+                disposition="invalid_jsonrpc",
+            )
+        candidates = [
+            (row, params)
+            for row, params in candidates
+            if row.get("rpc_method") == rpc_method
+        ]
+        if not candidates:
+            return WebTransportProgramSelection(
+                lane=lane,
+                rpc_envelope=rpc_envelope,
+                disposition="method_not_found",
+            )
+
+    if len(candidates) != 1:
+        return WebTransportProgramSelection(
+            lane=lane,
+            rpc_envelope=rpc_envelope,
+            disposition="ambiguous" if candidates else "no_match",
+        )
+    row, path_params = candidates[0]
+    program_id = row.get("meta_index")
+    if not isinstance(program_id, int):
+        return WebTransportProgramSelection(
+            lane=lane,
+            rpc_envelope=rpc_envelope,
+            disposition="invalid_plan",
+        )
+    return WebTransportProgramSelection(
+        program_id=program_id,
+        path_params=dict(path_params),
+        lane=lane,
+        rpc_envelope=rpc_envelope,
+        disposition="dispatch",
+    )
+
+
 def normalize_jsonrpc_mount_path(path: str) -> str:
     normalized = str(path or "").rstrip("/")
     return normalized or "/"

tigrbl_kernel/protocol_chains/websocket.py

@@ -1,8 +1,13 @@
 from __future__ import annotations
 
-from collections.abc import Mapping
+from collections.abc import Iterable, Mapping
 from typing import Any
 
+from tigrbl_atoms.atoms.framing import websocket_jsonrpc as _jsonrpc_framing
+from tigrbl_atoms.atoms.transport import websocket as _websocket_transport
+from tigrbl_typing.status.converters import http_exc_to_rpc
+from tigrbl_typing.status.exceptions import HTTPException
+
 ANCHORS: tuple[str, ...] = (
     "transport.accept",
     "transport.receive",
@@ -13,22 +18,243 @@ ANCHORS: tuple[str, ...] = (
     "transport.close",
 )
 
+SESSION_LIFECYCLE_PHASES: tuple[str, ...] = (
+    "SESSION_OPEN",
+    "POST_SESSION_OPEN",
+    "MESSAGE_RECEIVE",
+    "INGRESS_PARSE",
+    "INGRESS_DISPATCH",
+    "PRE_TX_BEGIN",
+    "START_TX",
+    "PRE_HANDLER",
+    "HANDLER",
+    "POST_HANDLER",
+    "PRE_COMMIT",
+    "TX_COMMIT",
+    "POST_COMMIT",
+    "EGRESS_SHAPE",
+    "EGRESS_FINALIZE",
+    "POST_RESPONSE",
+    "PRE_SESSION_CLOSE",
+    "SESSION_CLOSE",
+    "POST_SESSION_CLOSE",
+)
+
+SESSION_STRUCTURAL_PHASES: tuple[str, ...] = (
+    "SESSION_OPEN",
+    "MESSAGE_RECEIVE",
+    "SESSION_CLOSE",
+)
+
+SESSION_HOOK_PHASES: tuple[str, ...] = (
+    "POST_SESSION_OPEN",
+    "PRE_SESSION_CLOSE",
+    "POST_SESSION_CLOSE",
+)
+
+CORE_REALTIME_ATOMS: tuple[str, ...] = (
+    "transport.accept",
+    "transport.receive",
+    "transport.emit",
+    "transport.close",
+    "framing.decode",
+    "framing.encode",
+    "dispatch.binding.match",
+    "dispatch.binding.parse",
+    "subscription.register",
+    "subscription.unregister",
+    "publish.prepare",
+    "publish.enqueue",
+    "publish.fanout",
+)
+
+ATOM_PHASE_PLACEMENT: dict[str, str] = {
+    "transport.accept": "SESSION_OPEN",
+    "transport.receive": "MESSAGE_RECEIVE",
+    "dispatch.binding.match": "INGRESS_DISPATCH",
+    "dispatch.binding.parse": "INGRESS_DISPATCH",
+    "framing.decode": "INGRESS_PARSE",
+    "subscription.register": "POST_COMMIT",
+    "subscription.unregister": "PRE_SESSION_CLOSE",
+    "publish.prepare": "POST_COMMIT",
+    "publish.enqueue": "POST_COMMIT",
+    "publish.fanout": "EGRESS_FINALIZE",
+    "framing.encode": "EGRESS_FINALIZE",
+    "transport.emit": "EGRESS_FINALIZE",
+    "transport.close": "SESSION_CLOSE",
+}
+
+PUBLISH_POLICY: dict[str, object] = {
+    "automatic_for_oltp": False,
+    "publish_only_op": True,
+    "create_only_publishes": False,
+    "create_and_publish_requires_effect": True,
+    "rollback_suppresses_publish": True,
+    "placement": {
+        "HANDLER": ("publish.intent",),
+        "POST_COMMIT": ("publish.prepare", "publish.enqueue"),
+        "EGRESS_FINALIZE": ("publish.fanout", "framing.encode", "transport.emit"),
+        "POST_RESPONSE": ("cleanup.metrics",),
+    },
+}
+
+SUBSCRIBE_POLICY: dict[str, object] = {
+    "operation_shape": "finite_request_response",
+    "ack_framing": "jsonrpc",
+    "owns_receive_loop": False,
+    "registration": {"atom": "subscription.register", "phase": "POST_COMMIT"},
+    "cleanup": {"atom": "subscription.unregister", "phase": "PRE_SESSION_CLOSE"},
+}
+
+
+def _binding_framing(binding: Mapping[str, Any]) -> str:
+    framing = (
+        binding.get("framing", "text")
+        if isinstance(binding, Mapping)
+        else getattr(binding, "framing", "text")
+    )
+    if isinstance(framing, str):
+        return framing.lower()
+    name = type(framing).__name__.lower()
+    if "jsonrpc" in name:
+        return "jsonrpc"
+    if "ndjson" in name:
+        return "ndjson"
+    if "text" in name:
+        return "text"
+    return name
+
+
+def _binding_path(binding: Mapping[str, Any]) -> str | None:
+    if isinstance(binding, Mapping):
+        path = binding.get("path") or binding.get("connect_path")
+    else:
+        path = getattr(binding, "path", None) or getattr(
+            binding,
+            "connect_path",
+            None,
+        )
+    return str(path) if path is not None else None
+
+
+def _op_bindings(op: Any) -> tuple[Any, ...]:
+    bindings = (
+        op.get("bindings", ())
+        if isinstance(op, Mapping)
+        else getattr(op, "bindings", ())
+    )
+    return tuple(bindings or ())
+
+
+def _op_alias(op: Any) -> str:
+    alias = op.get("alias") if isinstance(op, Mapping) else getattr(op, "alias", None)
+    if not isinstance(alias, str) or not alias:
+        raise ValueError("websocket jsonrpc op requires alias")
+    return alias
+
+
+def _op_method(op: Any) -> str:
+    if isinstance(op, Mapping):
+        method = (
+            op.get("op_method")
+            or op.get("op_id")
+            or op.get("identity")
+            or op.get("canonical_identity")
+            or op.get("name")
+        )
+    else:
+        method = (
+            getattr(op, "op_method", None)
+            or getattr(op, "op_id", None)
+            or getattr(op, "identity", None)
+            or getattr(op, "canonical_identity", None)
+            or getattr(op, "name", None)
+        )
+        if method is None:
+            table = getattr(op, "table", None)
+            table_name = getattr(table, "__name__", None)
+            alias = getattr(op, "alias", None)
+            if table_name and alias:
+                method = f"{table_name}.{alias}"
+            elif alias:
+                method = str(alias)
+    if not isinstance(method, str) or not method:
+        raise ValueError("websocket jsonrpc op requires canonical op identity")
+    return method
+
+
+def _table_identity(table: Any) -> str:
+    name = getattr(table, "name", None)
+    if isinstance(name, str) and name:
+        return name
+    model = getattr(table, "model", None)
+    model_name = getattr(model, "__name__", None)
+    if isinstance(model_name, str) and model_name:
+        return model_name
+    model_ref = getattr(table, "model_ref", None)
+    if isinstance(model_ref, str) and model_ref:
+        return model_ref.rsplit(":", 1)[-1].rsplit(".", 1)[-1]
+    resource = getattr(table, "resource", None)
+    if isinstance(resource, str) and resource:
+        return resource
+    raise ValueError("websocket jsonrpc table requires name, model, or model_ref")
+
+
+def _binding_proto(binding: Any) -> str:
+    if isinstance(binding, Mapping):
+        proto = binding.get("proto") or binding.get("protocol") or "ws"
+    else:
+        proto = getattr(binding, "proto", None) or getattr(binding, "protocol", None)
+    return str(proto or "ws").lower()
+
+
+def _register_jsonrpc_op(
+    endpoint: dict[str, Any],
+    *,
+    path: str,
+    method: str,
+    op: Any,
+) -> None:
+    for binding in _op_bindings(op):
+        if _binding_path(binding) != path:
+            continue
+        if _binding_proto(binding) not in {"ws", "wss", "websocket"}:
+            continue
+        if _binding_framing(binding) != "jsonrpc":
+            continue
+        if method in endpoint:
+            raise ValueError(
+                f"duplicate websocket jsonrpc registration for {path} {method}"
+            )
+        endpoint[method] = op
+
 
 def compile_websocket_chain(binding: Mapping[str, Any]) -> dict[str, object]:
     scheme = binding.get("scheme", "ws")
     if scheme not in {"ws", "wss"}:
         raise ValueError("websocket scheme must be ws or wss")
+    framing = _binding_framing(binding)
     tls = dict((binding.get("extensions") or {}).get("tls") or {})
     return {
         "binding": "wss" if scheme == "wss" else "websocket",
         "exchange": "bidirectional_stream",
         "family": "message",
         "path": binding.get("path"),
+        "framing": framing,
         "anchors": ANCHORS,
+        "lifecycle_phases": SESSION_LIFECYCLE_PHASES,
+        "structural_phases": SESSION_STRUCTURAL_PHASES,
+        "hook_phases": SESSION_HOOK_PHASES,
+        "realtime_atoms": CORE_REALTIME_ATOMS,
+        "atom_phase_placement": ATOM_PHASE_PLACEMENT,
+        "subscribe_policy": SUBSCRIBE_POLICY,
+        "publish_policy": PUBLISH_POLICY,
         "loop_region": {
             "loop_id": "websocket.receive",
             "role": "message",
             "break_conditions": ("websocket.disconnect",),
+            "enter_phase": "MESSAGE_RECEIVE",
+            "exit_target": "PRE_SESSION_CLOSE",
         },
         "close": {"code": 1000, "reason": ""},
         "scope_metadata": {
@@ -38,4 +264,270 @@ def compile_websocket_chain(binding: Mapping[str, Any]) -> dict[str, object]:
     }
 
 
-__all__ = ["compile_websocket_chain"]
+def compile_websocket_jsonrpc_dispatch_index(
+    *,
+    path: str,
+    ops: Iterable[Any] = (),
+    tables: Iterable[Any] = (),
+) -> dict[str, object]:
+    endpoint: dict[str, Any] = {}
+    for table in tables:
+        table_name = _table_identity(table)
+        for op in tuple(getattr(table, "ops", ()) or ()):
+            _register_jsonrpc_op(
+                endpoint,
+                path=path,
+                method=f"{table_name}.{_op_alias(op)}",
+                op=op,
+            )
+    for op in ops:
+        _register_jsonrpc_op(
+            endpoint,
+            path=path,
+            method=_op_method(op),
+            op=op,
+        )
+    return {
+        "ws": {"exact": {path: "session_program"}},
+        "ws.jsonrpc": {"endpoints": {path: endpoint}},
+    }
+
+
+def _jsonrpc_error(
+    code: int,
+    message: str,
+    request_id: Any,
+    *,
+    data: Any | None = None,
+) -> dict[str, Any]:
+    error: dict[str, Any] = {"code": code, "message": message}
+    if data is not None:
+        error["data"] = data
+    return {"jsonrpc": "2.0", "error": error, "id": request_id}
+
+
+def _jsonrpc_result(result: Any, request_id: Any) -> dict[str, Any]:
+    return {"jsonrpc": "2.0", "result": result, "id": request_id}
+
+
+def _ctx_get(ctx: Any, key: str, default: Any = None) -> Any:
+    getter = getattr(ctx, "get", None)
+    if callable(getter):
+        try:
+            return getter(key, default)
+        except Exception:
+            pass
+    return getattr(ctx, key, default)
+
+
+def _session_rpc_context(
+    payload: Mapping[str, Any],
+    request_id: Any,
+    session_ctx: Any,
+) -> dict[str, Any]:
+    rpc_ctx: dict[str, Any] = {
+        "jsonrpc": dict(payload),
+        "jsonrpc_request_id": request_id,
+    }
+    if session_ctx is None:
+        return rpc_ctx
+    temp = _ctx_get(session_ctx, "temp", {})
+    if isinstance(temp, Mapping):
+        realtime = temp.get("realtime")
+        websocket = temp.get("websocket")
+        if isinstance(realtime, Mapping):
+            rpc_ctx["realtime"] = realtime
+        if isinstance(websocket, Mapping):
+            rpc_ctx["websocket"] = websocket
+    channel = _ctx_get(session_ctx, "channel")
+    if channel is not None:
+        rpc_ctx["channel"] = channel
+    return rpc_ctx
+
+
+async def _maybe_await(value: Any) -> Any:
+    if hasattr(value, "__await__"):
+        return await value
+    return value
+
+
+async def _cleanup_realtime_session(ctx: Any) -> None:
+    temp = _ctx_get(ctx, "temp", {})
+    if not isinstance(temp, Mapping):
+        return
+    realtime = temp.get("realtime")
+    if not isinstance(realtime, Mapping):
+        return
+    broker = realtime.get("broker")
+    session_id = realtime.get("session_id")
+    unregister = getattr(broker, "unsubscribe_session", None)
+    if callable(unregister) and session_id is not None:
+        await _maybe_await(unregister(str(session_id)))
+
+
+def _resolve_rpc_target(router: Any, method: str) -> tuple[Any, str] | None:
+    table_name, sep, alias = method.partition(".")
+    if not sep or not table_name or not alias:
+        return None
+    tables = getattr(router, "tables", None)
+    if isinstance(tables, Mapping):
+        model = tables.get(table_name)
+        if isinstance(model, type):
+            return model, alias
+        for candidate in tables.values():
+            if (
+                isinstance(candidate, type)
+                and getattr(candidate, "__name__", None) == table_name
+            ):
+                return candidate, alias
+    return table_name, alias
+
+
+def _op_tx_scope(model: Any, alias: str) -> str:
+    ops = getattr(getattr(model, "ops", None), "all", ())
+    for spec in tuple(ops or ()):
+        if getattr(spec, "alias", None) == alias:
+            return str(getattr(spec, "tx_scope", "inherit") or "inherit")
+    return "inherit"
+
+
+async def _dispatch_jsonrpc_payload(
+    router: Any,
+    payload: Any,
+    *,
+    session_ctx: Any = None,
+) -> Any:
+    if not isinstance(payload, Mapping) or payload.get("jsonrpc") != "2.0":
+        return _jsonrpc_error(-32600, "Invalid Request", None)
+    request_id = payload.get("id")
+    method = payload.get("method")
+    if not isinstance(method, str) or not method:
+        return _jsonrpc_error(-32601, "Method not found", request_id)
+    target = _resolve_rpc_target(router, method)
+    if target is None:
+        return _jsonrpc_error(-32601, "Method not found", request_id)
+    params = payload.get("params", {})
+    if params is None:
+        params = {}
+    if not isinstance(params, (dict, list, tuple)):
+        return _jsonrpc_error(-32602, "Invalid params", request_id)
+    model, alias = target
+    rpc_call = getattr(router, "rpc_call", None)
+    if not callable(rpc_call):
+        return _jsonrpc_error(-32603, "Internal error", request_id)
+    kwargs: dict[str, Any] = {
+        "ctx": _session_rpc_context(payload, request_id, session_ctx)
+    }
+    if _op_tx_scope(model, alias) == "none":
+        kwargs["db"] = {}
+    try:
+        result = await rpc_call(model, alias, params, **kwargs)
+    except AttributeError:
+        return _jsonrpc_error(-32601, "Method not found", request_id)
+    except HTTPException as exc:
+        code, message, data = http_exc_to_rpc(exc)
+        return _jsonrpc_error(code, message, request_id, data=data)
+    except Exception as exc:
+        return _jsonrpc_error(
+            -32603,
+            "Internal error",
+            request_id,
+            data={"detail": str(exc)},
+        )
+    if "id" not in payload:
+        return None
+    return _jsonrpc_result(result, request_id)
+
+
+async def _dispatch_jsonrpc_decoded(
+    router: Any,
+    payload: Any,
+    *,
+    session_ctx: Any = None,
+) -> Any:
+    if isinstance(payload, list):
+        responses = []
+        for item in payload:
+            response = await _dispatch_jsonrpc_payload(
+                router,
+                item,
+                session_ctx=session_ctx,
+            )
+            if response is not None:
+                responses.append(response)
+        return responses or None
+    return await _dispatch_jsonrpc_payload(router, payload, session_ctx=session_ctx)
+
+
+def build_websocket_jsonrpc_session_handler(
+    router: Any,
+    *,
+    subprotocol: str = "jsonrpc",
+    realtime_broker: Any = None,
+) -> Any:
+    """Build a kernel-owned WebSocket JSON-RPC session handler step."""
+
+    async def _websocket_jsonrpc_session(ctx: Any) -> None:
+        await _websocket_transport.accept(ctx, subprotocol=subprotocol)
+        channel = ctx.get("channel")
+        channel_state = getattr(channel, "state", None)
+        if isinstance(channel_state, dict):
+            channel_state["transport_sent"] = True
+        temp = ctx.get("temp", {})
+        if isinstance(temp, dict):
+            ws_state = temp.setdefault("websocket", {})
+            realtime_state = temp.setdefault("realtime", {})
+            session_id = ws_state.setdefault("session_id", f"ws:{id(ctx)}")
+            realtime_state.setdefault("session_id", session_id)
+            realtime_state.setdefault("sink", ctx.get("channel"))
+            if realtime_broker is not None:
+                realtime_state.setdefault("broker", realtime_broker)
+        try:
+            while True:
+                await _websocket_transport.receive(ctx)
+                ws_state = ctx.get("temp", {}).setdefault("websocket", {})
+                if isinstance(ws_state, dict) and ws_state.get("disconnected"):
+                    break
+                try:
+                    decoded = await _jsonrpc_framing.decode(ctx)
+                    response = await _dispatch_jsonrpc_decoded(
+                        router,
+                        decoded,
+                        session_ctx=ctx,
+                    )
+                except ValueError:
+                    response = _jsonrpc_error(-32700, "Parse error", None)
+                if response is None:
+                    continue
+                ws_state["response"] = response
+                await _jsonrpc_framing.encode(ctx)
+                await _websocket_transport.emit(ctx)
+        finally:
+            await _cleanup_realtime_session(ctx)
+            await _websocket_transport.close(ctx)
+
+    setattr(
+        _websocket_jsonrpc_session,
+        "__tigrbl_label",
+        "kernel:websocket:jsonrpc:session",
+    )
+    setattr(
+        _websocket_jsonrpc_session,
+        "__tigrbl_atom_name__",
+        "websocket.jsonrpc.session",
+    )
+    return _websocket_jsonrpc_session
+
+
+__all__ = [
+    "ATOM_PHASE_PLACEMENT",
+    "CORE_REALTIME_ATOMS",
+    "PUBLISH_POLICY",
+    "SESSION_HOOK_PHASES",
+    "SESSION_LIFECYCLE_PHASES",
+    "SESSION_STRUCTURAL_PHASES",
+    "SUBSCRIBE_POLICY",
+    "build_websocket_jsonrpc_session_handler",
+    "compile_websocket_chain",
+    "compile_websocket_jsonrpc_dispatch_index",
+]

tigrbl_kernel/webtransport_session_plan.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Any
+import struct
+import json
+import inspect
+
+from tigrbl_atoms.atoms.framing import WebTransportRecordDecoder
+
+
+@dataclass(slots=True)
+class WebTransportSessionPlan:
+    """Session-scoped carrier plan for framed control records.
+
+    The plan owns record decoder state across ASGI receive calls. One inbound
+    carrier chunk may yield zero, one, or several operation-dispatch events;
+    completing any one operation does not complete the bidirectional stream.
+    """
+
+    pending: deque[dict[str, Any]] = field(default_factory=deque)
+    control_decoders: dict[str, WebTransportRecordDecoder] = field(
+        default_factory=dict
+    )
+
+    def has_pending(self) -> bool:
+        return bool(self.pending)
+
+    def pop_pending(self) -> dict[str, Any]:
+        return self.pending.popleft()
+
+    def project_receive(self, message: Mapping[str, Any]) -> None:
+        event = dict(message)
+        if (
+            event.get("type") != "webtransport.stream.receive"
+            or str(event.get("stream_direction") or "bidi") != "bidi"
+        ):
+            self.pending.append(event)
+            return
+        data = event.get("data")
+        if data is None:
+            data = event.get("bytes")
+        if not isinstance(data, (bytes, bytearray, memoryview)):
+            self.pending.append(event)
+            return
+        raw = bytes(data)
+        stream_id = str(event.get("stream_id"))
+        decoder = self.control_decoders.get(stream_id)
+        if decoder is None and raw.lstrip().startswith((b"{", b"[")):
+            # Compatibility for unframed peers while declared framed bindings
+            # migrate. New peers must use uint32 big-endian record boundaries.
+            self.pending.append(event)
+            return
+        if decoder is None and len(raw) >= 4:
+            declared_size = struct.unpack_from("!I", raw, 0)[0]
+            if declared_size > 3 * 1024 * 1024:
+                self.pending.append(event)
+                return
+        if decoder is None:
+            decoder = WebTransportRecordDecoder()
+            self.control_decoders[stream_id] = decoder
+        more = event.get("more")
+        records = decoder.feed(raw, final=more is False)
+        if more is False:
+            self.control_decoders.pop(stream_id, None)
+        for record in records:
+            projected = dict(event)
+            projected.pop("bytes", None)
+            projected["data"] = json.dumps(
+                record, separators=(",", ":")
+            ).encode("utf-8")
+            projected["framing"] = "jsonrpc"
+            projected["jsonrpc_complete"] = True
+            self.pending.append(projected)
+
+    def close(self) -> None:
+        self.pending.clear()
+        self.control_decoders.clear()
+
+    async def cleanup(self, *callbacks: Any) -> None:
+        self.close()
+        for callback in callbacks:
+            if not callable(callback):
+                continue
+            result = callback()
+            if inspect.isawaitable(result):
+                await result
+
+
+__all__ = ["WebTransportSessionPlan"]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl-kernel
-Version: 0.4.5.dev4
+Version: 0.4.5.dev8
 Summary: Kernel orchestration for composing Tigrbl runtime plans, bindings, operation dispatch, and optimized ASGI execution.
 License: Apache License
                                     Version 2.0, January 2004
@@ -225,14 +225,14 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: tigrbl-atoms
-Requires-Dist: tigrbl-core
+Requires-Dist: tigrbl-atoms (>=0.4.5.dev5)
+Requires-Dist: tigrbl-core (>=0.4.5.dev6)
 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_kernel
+Project-URL: Repository, https://github.com/tigrbl/tigrbl/tree/master/pkgs/45_kernel/tigrbl_kernel
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -242,7 +242,7 @@ Description-Content-Type: text/markdown
 <a href="https://pypi.org/project/tigrbl-kernel/"><img src="https://img.shields.io/pypi/v/tigrbl-kernel?label=PyPI" alt="PyPI version for tigrbl-kernel"/></a>
 <a href="https://pypi.org/project/tigrbl-kernel/"><img src="https://static.pepy.tech/badge/tigrbl-kernel" alt="Downloads for tigrbl-kernel"/></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-kernel"/></a>
-<a href="https://github.com/tigrbl/tigrbl/blob/master/pkgs/core/tigrbl_kernel/README.md"><img src="https://hits.sh/github.com/tigrbl/tigrbl/blob/master/pkgs/core/tigrbl_kernel/README.md.svg?label=hits" alt="Repository hits for tigrbl-kernel README"/></a>
+<a href="https://github.com/tigrbl/tigrbl/blob/master/pkgs/45_kernel/tigrbl_kernel/README.md"><img src="https://hits.sh/github.com/tigrbl/tigrbl/blob/master/pkgs/45_kernel/tigrbl_kernel/README.md.svg?label=hits" alt="Repository hits for tigrbl-kernel 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%2C%203.11%2C%203.12%2C%203.13%2C%203.14-3776ab" alt="Python versions 3.10 | 3.11 | 3.12 | 3.13 | 3.14 for tigrbl-kernel"/></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-kernel"/></a>
@@ -266,7 +266,7 @@ Framework maintainers, extension authors, and advanced users composing Tigrbl fr
 
 ## Where does tigrbl-kernel fit?
 
-`tigrbl-kernel` lives at `pkgs/core/tigrbl_kernel` and serves a focused layer in the split Tigrbl framework.
+`tigrbl-kernel` lives at `pkgs/45_kernel/tigrbl_kernel` and serves a focused layer in the split Tigrbl framework.
 
 ## How does tigrbl-kernel work?
 
@@ -288,7 +288,7 @@ pip install tigrbl-kernel
 | Surface | Value |
 |---|---|
 | PyPI package | [`tigrbl-kernel`](https://pypi.org/project/tigrbl-kernel/) |
-| Repository path | [`pkgs/core/tigrbl_kernel`](https://github.com/tigrbl/tigrbl/tree/master/pkgs/core/tigrbl_kernel) |
+| Repository path | [`pkgs/45_kernel/tigrbl_kernel`](https://github.com/tigrbl/tigrbl/tree/master/pkgs/45_kernel/tigrbl_kernel) |
 | Python import root | `tigrbl_kernel` |
 | Console scripts | none declared |
 | Entry points | none declared |
@@ -444,7 +444,7 @@ Choose `tigrbl-kernel` when the quick-answer table matches your use case. Choose
 
 - Community: [Discord](https://discord.gg/K4YTAPapjR).
 - Issues: [GitHub Issues](https://github.com/tigrbl/tigrbl/issues).
-- Repository: [pkgs/core/tigrbl_kernel](https://github.com/tigrbl/tigrbl/tree/master/pkgs/core/tigrbl_kernel).
+- Repository: [pkgs/45_kernel/tigrbl_kernel](https://github.com/tigrbl/tigrbl/tree/master/pkgs/45_kernel/tigrbl_kernel).
 
 ## Package-local Boundary
 
@@ -455,7 +455,7 @@ This file is a package-local distribution entry point. This README is the packag
 - 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

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

@@ -1,6 +1,6 @@
-tigrbl_kernel/__init__.py,sha256=fE63Iyq2XrWqFTsvSC28iomE5nW6HsDUOEoQQtPNZ0I,2233
-tigrbl_kernel/_build.py,sha256=kHaS9k4cD5hg1eRj8aQnbPbUkTbOM8npE_yeOsiwUK8,50397
-tigrbl_kernel/_compile.py,sha256=g1_TP-wMp-O2qLjWkBupXHJ_cAFjeoldXl9L2hDF_gw,15248
+tigrbl_kernel/__init__.py,sha256=61zqMAzNVSEJKPyYNpiUfoJkkTVYJ-XSYUI3hyOTY7g,2283
+tigrbl_kernel/_build.py,sha256=h2-bpRVXRoHzbhyAAuFM4D_Mq6N75sTHb4kjwxXIgTc,51151
+tigrbl_kernel/_compile.py,sha256=i-p_DB__Fem-f0G4CX_K1s3gSRYmXl3ewEKp4FWF6FU,16601
 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
@@ -19,12 +19,12 @@ tigrbl_kernel/lifecycle_matrix.py,sha256=SCpcCY8csYyepNGmElYzretQcdM9Yud-XYPcYH8
 tigrbl_kernel/loop_modes.py,sha256=HnT3upEUK75R_sf92TrmOyszic0Kt-rDCDU93NhPL9M,1636
 tigrbl_kernel/loop_regions.py,sha256=M4GbV5hujPA6vTGDoW_r-ElGlwPgorB8xNjP-22Xpy0,2224
 tigrbl_kernel/measure.py,sha256=eK_ceLmF_Waao3v2KHjiaZQmbvRaji9GLrvnjXo9pmw,52310
-tigrbl_kernel/models.py,sha256=fcOQGRlilZaWWromScYYyc42zqX4O83jSt1MzXBgf4M,14493
+tigrbl_kernel/models.py,sha256=Uau8gfwl5U2mctWyApyrnSYlPPYpS8nBcJd4Wxl5PAo,14703
 tigrbl_kernel/opchannel_capabilities.py,sha256=5zM9-1fc-W8BXyXF4VVWrIsmdwCH5xLraGyO_AJwRrs,1541
-tigrbl_kernel/opview_compiler.py,sha256=DbZ3E0GYl_JEgExELjaNE7v2W4hl9LqvAB-CE5TwP7o,5370
+tigrbl_kernel/opview_compiler.py,sha256=jR2Oe8chSGpYI_-IFFDtip9TZkDrDEkW03UWGdgPJn4,11284
 tigrbl_kernel/ordering.py,sha256=C6fHkAwQA_1AY7sEAUy_FC5U3eFmsyqcls1li1qG5MA,13576
 tigrbl_kernel/packed_access.py,sha256=KhvAt-X4_bsowYVQ47tWEIfQhpcvTmPG7BqzuEWF87U,3587
-tigrbl_kernel/packed_selectors.py,sha256=ZgPvOTUsTSF_ZIpQHM3acQhdIbM0-c6lBW7WjdAROI4,8609
+tigrbl_kernel/packed_selectors.py,sha256=-ZOydklrxMdjITHjM05HlqKCl1hj0oqw3WOS-fQXvz4,13268
 tigrbl_kernel/payload.py,sha256=eyHo-cAUXLWQQ9-xZVOl_rjFudA-djMZji9hoK-v9IE,2167
 tigrbl_kernel/protocol_anchors.py,sha256=0jAXmSQ-OD3AGv7MM-2vF7hQmZtHG2bXwFM1ooi0Geg,863
 tigrbl_kernel/protocol_bindings.py,sha256=oE50T0YIEDAPXqxpXnmSAmJWX_SbSPdXBL8FtFF7OgI,18760
@@ -34,7 +34,7 @@ tigrbl_kernel/protocol_chains/http_unary.py,sha256=7EABv0bUAJ5UI3TWP-S-8LtgwZJLj
 tigrbl_kernel/protocol_chains/lifespan.py,sha256=kJdUuD-Yy4rJr5VeLv0Qs9WjDI_EcYlaJEKovc_LS7Y,609
 tigrbl_kernel/protocol_chains/sse.py,sha256=GASXjoFSxLHQmP85z2BscEkOlc-uSojr5JMjv2XZN8M,1149
 tigrbl_kernel/protocol_chains/static_files.py,sha256=KxtD5_7MOpl400oLutkVFawwgZsyPEh6gNtWy7Q34pc,807
-tigrbl_kernel/protocol_chains/websocket.py,sha256=FkXJU7h005Mrry9twcq1qIUNxmz_DEoPULCV2vDAxZs,1150
+tigrbl_kernel/protocol_chains/websocket.py,sha256=_pSAHPc9ZGIhtINpeqJkM_X7GfsBFN0u9rqiQyGg1ZE,16948
 tigrbl_kernel/protocol_completion.py,sha256=VqQN54ZYZGbwxotZaLRj6Ai2r_HJFBdl2mCl1_LCICs,1075
 tigrbl_kernel/protocol_fusion.py,sha256=uaj_CM3z68NohnV0qE872jrd-pTEgL8oPQkdHKsaz8k,2407
 tigrbl_kernel/protocol_legality_matrix.py,sha256=71VbwQU4sR0MnB3Netwu7ooij6HSLLV6lzkRG5b-YjM,4128
@@ -52,8 +52,9 @@ tigrbl_kernel/transport_events.py,sha256=CyPhs69H7mnKU7gNgt4XtH-eRJcihSaXxQDzC0i
 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.5.dev4.dist-info/METADATA,sha256=bnh551RyvGwYYvucG97P8mzTdpuBb5MwQBmPqIxT6Yk,27961
-tigrbl_kernel-0.4.5.dev4.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
-tigrbl_kernel-0.4.5.dev4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-tigrbl_kernel-0.4.5.dev4.dist-info/licenses/NOTICE,sha256=EvJMTshzsWz43LiK-DeN2ZuLtrP49cxvlrFlJ8F_buc,221
-tigrbl_kernel-0.4.5.dev4.dist-info/RECORD,,
+tigrbl_kernel/webtransport_session_plan.py,sha256=9IeJMNqhnorv6L5EIA6Rc2nq21lBQv3DWQMO-GrTiZk,3213
+tigrbl_kernel-0.4.5.dev8.dist-info/METADATA,sha256=GAUe1aS0NSTiUrbaphtpWt-rLYVLtOQQyZwCggdOi_4,28035
+tigrbl_kernel-0.4.5.dev8.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
+tigrbl_kernel-0.4.5.dev8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tigrbl_kernel-0.4.5.dev8.dist-info/licenses/NOTICE,sha256=EvJMTshzsWz43LiK-DeN2ZuLtrP49cxvlrFlJ8F_buc,221
+tigrbl_kernel-0.4.5.dev8.dist-info/RECORD,,

{tigrbl_kernel-0.4.5.dev4.dist-info → tigrbl_kernel-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