tigrbl 0.4.2.dev4__py3-none-any.whl → 0.4.3.dev4__py3-none-any.whl

tigrbl/__init__.py

@@ -61,6 +61,18 @@ def _install_alias(alias: str, target: str) -> None:
 for alias, target in _ALIAS_MODULES.items():
     _install_alias(alias, target)
 
+for alias, target in {
+    "runtime.events": "tigrbl_kernel.events",
+    "runtime.labels": "tigrbl_kernel.labels",
+    "runtime.status": "tigrbl_typing.status",
+}.items():
+    _install_alias(alias, target)
+    parent_alias, attr_name = alias.rsplit(".", 1)
+    parent_module = sys.modules.get(f"{__name__}.{parent_alias}")
+    target_module = sys.modules.get(target) or _optional_import(target)
+    if parent_module is not None and target_module is not None:
+        setattr(parent_module, attr_name, target_module)
+
 
 _spec = import_module("tigrbl_core._spec")
 _base = import_module("tigrbl_base._base")
@@ -84,8 +96,11 @@ from tigrbl_concrete._concrete import (  # noqa: E402
     BackgroundTask,
     Binding,
     BindingRegistry,
+    BulkCrudTable,
     Column,
     CORSMiddleware,
+    CrudTable,
+    EventStreamTable,
     EventStreamResponse,
     FileResponse,
     ForeignKey,
@@ -93,23 +108,44 @@ from tigrbl_concrete._concrete import (  # noqa: E402
     HTMLResponse,
     HTTPBasic,
     HTTPBearer,
+    JsonRpcOlapTable,
+    JsonRpcOltpTable,
+    JsonRpcTable,
     JSONResponse,
     MutualTLS,
     OAuth2,
+    OlapTable,
+    OltpTable,
     OpenIdConnect,
     Op,
     PlainTextResponse,
+    RealtimeTable,
+    RestJsonRpcOlapTable,
+    RestJsonRpcOltpTable,
+    RestJsonRpcTable,
+    RestOlapTable,
+    RestOltpTable,
     RedirectResponse,
     Request,
     TransportResponse,
     UploadedFile,
     WebSocket,
+    WebSocketJsonRpcTable,
+    WebSocketTable,
+    WebTransportBidiTable,
+    WebTransportClientStreamTable,
+    WebTransportDatagramTable,
+    WebTransportServerStreamTable,
+    WebTransportTable,
     Response,
     Route,
     Router,
     Schema,
     StorageTransform,
     Middleware,
+    RestTable,
+    SseTable,
+    StreamTable,
     StreamingResponse,
     Table,
     TableRegistry,
@@ -117,7 +153,7 @@ from tigrbl_concrete._concrete import (  # noqa: E402
     TigrblRouter,
 )
 from tigrbl_concrete._concrete.dependencies import Depends  # noqa: E402
-from tigrbl_runtime.runtime.status.exceptions import HTTPException  # noqa: E402
+from tigrbl_typing.status.exceptions import HTTPException  # noqa: E402
 from tigrbl.engine import resolver  # noqa: E402
 from tigrbl.system import mount_diagnostics  # noqa: E402
 from tigrbl_core.config.constants import DEFAULT_HTTP_METHODS, HOOK_DECLS_ATTR  # noqa: E402
@@ -143,16 +179,22 @@ from tigrbl.decorators import (  # noqa: E402
     websocket_ctx,
     webtransport_ctx,
 )
+from tigrbl_concrete._decorators.middlewares import (  # noqa: E402
+    middleware as middleware,
+    middlewares as middlewares,
+)
 from tigrbl.factories.op import op  # noqa: E402
 from tigrbl.schema import _build_list_params, _build_schema, get_schema  # noqa: E402
 from tigrbl.ddl import bootstrap_dbschema, ensure_schemas, register_sqlite_attach  # noqa: E402
 
 from tigrbl_base._base import (  # noqa: E402
     AppBase,
+    CrudTableBase,
     EngineBase,
     EngineProviderBase,
     ForeignKeyBase,
     HookBase,
+    RealtimeTableBase,
     RouterBase,
     TableBase,
     TableRegistryBase,
@@ -196,21 +238,18 @@ from tigrbl_core._spec import (  # noqa: E402
     SchemaRef,
     SchemaSpec,
     SessionSpec,
-    readonly,
-    session_spec,
     StorageSpec,
     StorageTransformSpec,
     StorageTypeRef,
+    TableProfileSpec,
     TableRegistrySpec,
     TableSpec,
     TargetOp,
     TemplateSpec,
-    tx_read_committed,
-    tx_repeatable_read,
-    tx_serializable,
     TxScope,
     WebSocketBindingSpec,
     WebTransportBindingSpec,
+    WellKnownResourceSpec,
     WsBindingSpec,
     canonical_binding_kind,
     normalize_binding_spec,
@@ -218,7 +257,7 @@ from tigrbl_core._spec import (  # noqa: E402
     validate_app_framing_for_binding,
     validate_binding_profile_exchange,
 )
-from tigrbl_runtime.runtime.executor import _invoke  # noqa: E402
+from tigrbl_runtime.executors.invoke import _invoke  # noqa: E402
 
 
 def bind(*args, **kwargs):
@@ -332,6 +371,8 @@ __all__ = [
     "Depends",
     "HTTPException",
     "TableBase",
+    "CrudTableBase",
+    "RealtimeTableBase",
     "RouterBase",
     "Op",
     "op",
@@ -357,6 +398,7 @@ __all__ = [
     "PathKind",
     "PathSpec",
     "path_for_binding",
+    "WellKnownResourceSpec",
     "DocsPayloadKind",
     "DocsPayloadSpec",
     "DocsProjectionSelection",
@@ -428,6 +470,7 @@ __all__ = [
     "BindingRegistrySpec",
     "RouterSpec",
     "TableSpec",
+    "TableProfileSpec",
     "TableRegistrySpec",
     "ColumnSpec",
     "FieldSpec",
@@ -457,6 +500,30 @@ __all__ = [
     "AppBase",
     "App",
     "Table",
+    "CrudTable",
+    "RealtimeTable",
+    "RestTable",
+    "RestJsonRpcTable",
+    "JsonRpcTable",
+    "BulkCrudTable",
+    "RestOltpTable",
+    "JsonRpcOltpTable",
+    "RestJsonRpcOltpTable",
+    "OltpTable",
+    "RestOlapTable",
+    "JsonRpcOlapTable",
+    "RestJsonRpcOlapTable",
+    "OlapTable",
+    "StreamTable",
+    "SseTable",
+    "EventStreamTable",
+    "WebSocketTable",
+    "WebSocketJsonRpcTable",
+    "WebTransportTable",
+    "WebTransportBidiTable",
+    "WebTransportClientStreamTable",
+    "WebTransportServerStreamTable",
+    "WebTransportDatagramTable",
     "Column",
     "CORSMiddleware",
     "Route",

tigrbl/cli.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import argparse
 import asyncio
+import hashlib
 import importlib
 import importlib.util
 import inspect
@@ -193,7 +194,9 @@ def _resolve_target(args: argparse.Namespace) -> str | None:
 
 
 def _load_module_from_path(path: Path) -> Any:
-    module_name = f"_tigrbl_cli_{path.stem}_{abs(hash(str(path.resolve())))}"
+    resolved = str(path.resolve())
+    digest = hashlib.sha256(resolved.encode("utf-8")).hexdigest()[:16]
+    module_name = f"_tigrbl_cli_{path.stem}_{digest}"
     spec = importlib.util.spec_from_file_location(module_name, path)
     if spec is None or spec.loader is None:
         raise CLIError(f"Could not load Python module from '{path}'")
@@ -208,7 +211,13 @@ def _load_target_object(target: str) -> Any:
     if not raw:
         raise CLIError("An app target is required. Use <module:attr> or <path.py:attr>.")
 
-    source, attr = (raw.rsplit(":", 1) + ["app"])[:2] if ":" in raw else (raw, "app")
+    raw_path = Path(raw)
+    if raw.endswith(".py") or raw_path.exists():
+        source, attr = raw, "app"
+    elif ":" in raw:
+        source, attr = raw.rsplit(":", 1)
+    else:
+        source, attr = raw, "app"
     source_path = Path(source)
     if source.endswith(".py") or source_path.exists():
         if not source_path.exists():

tigrbl/hook/exceptions.py

@@ -1,3 +1,3 @@
-"""Compatibility shim for runtime-owned exceptions."""
+"""Compatibility shim for hook declaration exceptions."""
 
-from ..runtime.exceptions import *  # noqa: F403, F401
+from tigrbl_core._spec.exceptions import *  # noqa: F403, F401

tigrbl/middlewares/__init__.py

@@ -1,11 +1,13 @@
-"""Hook type definitions exposed without importing runtime package internals."""
+"""Middleware declaration and composition helpers."""
 
 from __future__ import annotations
 
-from tigrbl_atoms import HookPhase, HookPhases, HookPredicate, StepFn
+from tigrbl_concrete._decorators.middlewares import (
+    MiddlewareConfig,
+    middleware,
+    middlewares,
+)
 
-PHASE = HookPhase
-PHASES = tuple(h.value for h in HookPhases)
-
-__all__ = ["HookPhase", "HookPhases", "PHASE", "PHASES", "StepFn", "HookPredicate"]
+from .compose import apply_middlewares
 
+__all__ = ["MiddlewareConfig", "apply_middlewares", "middleware", "middlewares"]

tigrbl/schema/jsonrpc.py

@@ -0,0 +1 @@
+from tigrbl_concrete.schema.jsonrpc import *  # noqa: F401,F403

tigrbl/system/diagnostics/__init__.py

@@ -1,19 +1,27 @@
-from ...runtime.kernel import _default_kernel, build_phase_chains
-from .router import mount_diagnostics
-from .healthz import build_healthz_endpoint, build_healthz_html, mount_healthz_uix
-from .methodz import build_methodz_endpoint
-from .hookz import build_hookz_endpoint
+from tigrbl_concrete.system.diagnostics import (
+    build_healthz_endpoint,
+    build_healthz_html,
+    build_hookz_endpoint,
+    build_methodz_endpoint,
+    mount_diagnostics,
+    mount_healthz_uix,
+)
 from .kernelz import build_kernelz_endpoint
-from .methodz import build_methodz_endpoint as _build_methodz_endpoint
-from .hookz import build_hookz_endpoint as _build_hookz_endpoint
+from tigrbl_concrete.system.diagnostics import (
+    build_hookz_endpoint as _build_hookz_endpoint,
+)
 from .kernelz import build_kernelz_endpoint as _build_kernelz_endpoint
-from .utils import (
-    table_iter as _table_iter,
-    model_iter as _model_iter,
-    opspecs as _opspecs,
+from tigrbl_concrete.system.diagnostics import (
+    build_methodz_endpoint as _build_methodz_endpoint,
+)
+from tigrbl_concrete.system.diagnostics.utils import (
     label_callable as _label_callable,
     label_hook as _label_hook,
+    model_iter as _model_iter,
+    opspecs as _opspecs,
+    table_iter as _table_iter,
 )
+from tigrbl_kernel import _default_kernel
 
 __all__ = [
     "mount_diagnostics",
@@ -31,6 +39,5 @@ __all__ = [
     "_opspecs",
     "_label_callable",
     "_label_hook",
-    "build_phase_chains",
     "_default_kernel",
 ]

tigrbl/system/diagnostics/kernelz.py

@@ -1,57 +1,15 @@
-"""Diagnostic endpoint exposing kernel phase plans."""
-
 from __future__ import annotations
 
 from typing import Any
 
-from ...runtime.kernel import _default_kernel as K
+from tigrbl_concrete.system.diagnostics.kernelz import (
+    build_kernelz_endpoint as _build_kernelz_endpoint,
+)
+from tigrbl_kernel import _default_kernel
 
 
 def build_kernelz_endpoint(router: Any):
-    """Return an async handler that serves the Kernel's cached plan."""
-
-    async def _kernelz():
-        K.ensure_primed(router)
-        payload = K.kernelz_payload(router)
-        models = getattr(router, "models", {}) or {}
-        if not models:
-            return payload
-
-        out = payload
-        for model_name, model in models.items():
-            specs = getattr(getattr(model, "opspecs", None), "all", ()) or ()
-            if specs:
-                continue
-
-            model_map = payload.get(model_name)
-            if not isinstance(model_map, dict):
-                continue
-
-            if out is payload:
-                out = {
-                    name: {alias: list(seq) for alias, seq in ops.items()}
-                    for name, ops in payload.items()
-                }
-
-            enriched = out.get(model_name)
-            if not isinstance(enriched, dict):
-                continue
-
-            for alias, seq in list(enriched.items()):
-                extras: list[str] = []
-                seen = set(seq)
-                for label in seq:
-                    if not isinstance(label, str) or ":" not in label:
-                        continue
-                    raw = label.split(":", 1)[1]
-                    if raw not in seen:
-                        extras.append(raw)
-                        seen.add(raw)
-                if extras:
-                    enriched[alias] = [*seq, *extras]
-        return out
-
-    return _kernelz
+    return _build_kernelz_endpoint(router, kernel=_default_kernel)
 
 
 __all__ = ["build_kernelz_endpoint"]

tigrbl/system/diagnostics/methodz.py

@@ -37,6 +37,8 @@ def build_methodz_endpoint(router: Any):
                 methods.append(entry)
                 per_model.setdefault(mname, []).append(entry)
         methods.sort(key=lambda x: (x["model"], x["alias"]))
+        for entries in per_model.values():
+            entries.sort(key=lambda x: x["alias"])
         cache = {"methods": methods, **per_model}
         return cache
 

tigrbl/system/diagnostics/utils.py

@@ -1,63 +1,17 @@
-from __future__ import annotations
-
-import inspect
-import warnings
-from types import SimpleNamespace
-from typing import Any, Iterable
-
-from sqlalchemy import text
-
-from ...runtime.labels import (
-    label_callable as _kernel_label_callable,
-    label_hook as _kernel_label_hook,
+from tigrbl_concrete.system.diagnostics.utils import (
+    label_callable,
+    label_hook,
+    maybe_execute,
+    model_iter,
+    opspecs,
+    table_iter,
 )
 
-
-def table_iter(router: Any) -> Iterable[type]:
-    tables = getattr(router, "tables", None)
-    if isinstance(tables, dict) and tables:
-        return tables.values()
-
-    return ()
-
-
-def model_iter(router: Any) -> Iterable[type]:
-    warnings.warn(
-        "model_iter is deprecated; use table_iter instead.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    return table_iter(router)
-
-
-def opspecs(model: type):
-    ops = getattr(getattr(model, "opspecs", SimpleNamespace()), "all", ()) or ()
-    if ops:
-        return ops
-    try:
-        from tigrbl_core._spec.op_spec import _mro_collect_decorated_ops
-
-        return tuple(_mro_collect_decorated_ops(model))
-    except Exception:
-        return ()
-
-
-async def maybe_execute(db: Any, stmt: str):
-    try:
-        rv = db.execute(text(stmt))  # type: ignore[attr-defined]
-        if inspect.isawaitable(rv):
-            return await rv
-        return rv
-    except Exception:
-        rv = db.execute(text("select 1"))  # type: ignore[attr-defined]
-        if inspect.isawaitable(rv):
-            return await rv
-        return rv
-
-
-def label_callable(fn: Any) -> str:
-    return _kernel_label_callable(fn)
-
-
-def label_hook(fn: Any, phase: str) -> str:
-    return _kernel_label_hook(fn, phase)
+__all__ = [
+    "label_callable",
+    "label_hook",
+    "maybe_execute",
+    "model_iter",
+    "opspecs",
+    "table_iter",
+]

tigrbl/transport/jsonrpc/helpers.py

@@ -1 +1,7 @@
+from tigrbl_concrete.transport._deprecation import (
+    JSONRPC_HELPERS_WARNING,
+    warn_deprecated_transport_module,
+)
 from tigrbl_concrete.transport.jsonrpc.helpers import *  # noqa: F401,F403
+
+warn_deprecated_transport_module(JSONRPC_HELPERS_WARNING, __name__)

tigrbl/transport/jsonrpc/models.py

@@ -1 +1,7 @@
+from tigrbl_concrete.transport._deprecation import (
+    JSONRPC_MODELS_WARNING,
+    warn_deprecated_transport_module,
+)
 from tigrbl_concrete.transport.jsonrpc.models import *  # noqa: F401,F403
+
+warn_deprecated_transport_module(JSONRPC_MODELS_WARNING, __name__)

tigrbl/transport/rest/aggregator.py

@@ -1 +1,7 @@
+from tigrbl_concrete.transport._deprecation import (
+    REST_WARNING,
+    warn_deprecated_transport_module,
+)
 from tigrbl_concrete.transport.rest.aggregator import *  # noqa: F401,F403
+
+warn_deprecated_transport_module(REST_WARNING, __name__)

{tigrbl-0.4.2.dev4.dist-info → tigrbl-0.4.3.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl
-Version: 0.4.2.dev4
+Version: 0.4.3.dev4
 Summary: Schema-first ASGI framework for REST and JSON-RPC APIs with OpenAPI, OpenRPC, SQLAlchemy, typed validation, hooks, and engine plugins.
 License: Apache License
                                     Version 2.0, January 2004
@@ -271,7 +271,7 @@ Description-Content-Type: text/markdown
 <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"/></a>
 <a href="https://github.com/tigrbl/tigrbl/blob/master/pkgs/core/tigrbl/README.md"><img src="https://hits.sh/github.com/tigrbl/tigrbl/blob/master/pkgs/core/tigrbl/README.md.svg?label=hits" alt="Repository hits for tigrbl README"/></a>
 <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-525252" alt="Apache 2.0 license"/></a>
-<a href="pyproject.toml"><img src="https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-3776ab" alt="Python versions 3.10 | 3.11 | 3.12 | 3.13 | 3.14 for tigrbl"/></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"/></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"/></a>
 </div>
 
@@ -334,7 +334,7 @@ pip install "tigrbl[postgres,servers,templates,tests]"
 | Entry points | none declared |
 | Optional extras | `postgres`, `servers`, `templates`, `tests` |
 | Legal files | `LICENSE`, `NOTICE` |
-| Supported Python | `3.10 | 3.11 | 3.12 | 3.13 | 3.14` |
+| Supported Python | `3.10, 3.11, 3.12, 3.13, 3.14` |
 
 ## What It Owns
 
@@ -343,6 +343,12 @@ pip install "tigrbl[postgres,servers,templates,tests]"
 Implementation orientation:
 - `tigrbl`: __main__, canonical_json, cli, config/, ddl/, decorators/, engine/, factories/, hook/, middlewares/, op/, orm/
 
+Facade orientation:
+- Authoring API: app/router factories, table helpers, column helpers, schema helpers, operation decorators, hook decorators, response decorators, and engine decorators.
+- Compatibility imports: facade modules such as `tigrbl.op`, `tigrbl.config`, `tigrbl.schema`, `tigrbl.ddl`, `tigrbl.security`, and `tigrbl.system` forward into the split packages that now own the implementation.
+- Runtime projection: model operations are compiled into REST bindings, JSON-RPC methods, OpenAPI, OpenRPC, diagnostics, schemas, and engine-backed handlers.
+- Operational boundary: this package is the application-facing install target; lower-level packages own specs, atoms, kernel planning, runtime execution, base abstractions, concrete adapters, ORM helpers, and engine plugins.
+
 ## Public API and Import Surface
 
 - Import roots: `tigrbl`.
@@ -393,6 +399,270 @@ tigrbl --help
 python -m tigrbl --help
 ```
 
+## Framework Catalog
+
+Tigrbl is organized as a split framework behind this facade:
+
+| Layer | Package | Responsibility |
+|---|---|---|
+| Facade | `tigrbl` | Public authoring imports, shortcuts, compatibility modules, CLI entry point, and application-facing docs. |
+| Core specs | `tigrbl-core` | App, router, table, column, op, hook, schema, response, binding, engine, storage, path, docs, session, and middleware specs. |
+| Base contracts | `tigrbl-base` | Abstract app/router/table/session/request/response/binding/security/middleware/storage interfaces and mapping helpers. |
+| Concrete adapters | `tigrbl-concrete` | Concrete app/router/table/response/request/security/decorator/engine/system/transport implementations. |
+| Atoms | `tigrbl-atoms` | Phase names, stage transitions, typed contexts, ingress/dispatch/wire/storage/handler/egress/error atoms, transaction atoms, batch atoms, and transport atoms. |
+| Kernel | `tigrbl-kernel` | Operation-view compilation, hook ordering, labels, packed plans, protocol chains, lifecycle rows, event keys, capability masks, and dispatch plans. |
+| Runtime | `tigrbl-runtime` | Runtime-owned routing, request execution, framing atoms, transport channels, and default kernel integration. |
+| Operation packs | `tigrbl-ops-oltp`, `tigrbl-ops-olap`, `tigrbl-ops-realtime` | Canonical operation definitions for CRUD, analytics, and realtime/streaming workloads. |
+| ORM | `tigrbl-orm` | SQLAlchemy-facing table and mixin helpers used by application models. |
+| Engines | `tigrbl-engine-*` | Persistence, cache, queue, rate, bloom, dedupe, dataframe, warehouse, and database engine integrations. |
+
+Use the facade for application code unless you are maintaining a framework layer, testing a boundary in isolation, or writing a package that intentionally plugs into one of the lower layers.
+
+## Authoring BCP
+
+The facade is the normal application authoring surface. Use `docs/developer/AUTHORING_BCP.md` for the full policy; this package README keeps the public-package guidance explicit because it is the README most application developers see first.
+
+Do:
+
+- Do import application-facing classes, decorators, helpers, and shortcuts from `tigrbl` unless you are intentionally maintaining a lower-level package.
+- Do create services with `TigrblApp`, `TigrblRouter`, facade route/operation decorators, table helpers, column helpers, hook decorators, response decorators, schema helpers, and engine decorators.
+- Do model domain actions as Tigrbl operations, including canonical CRUD operations, operation-pack verbs, or explicit custom operation specs.
+- Do use operation handlers through Tigrbl specs and kernel/runtime dispatch so REST, JSON-RPC, OpenAPI, OpenRPC, diagnostics, schemas, hooks, and tests stay aligned.
+- Do express field behavior through Tigrbl table, column, datatype, storage, IO, request, response, and operation specs.
+- Do use `get_schema(...)` or schema helpers for operation request/response payloads.
+- Do bind engines declaratively at app, router, table, or operation scope.
+- Do use lifecycle hooks for policy, validation, enrichment, audit, response shaping, and post-response work.
+- Do use `/system/methodz`, `/system/hookz`, `/system/kernelz`, OpenAPI, and OpenRPC to inspect the registered framework state.
+
+Do not:
+
+- Do not author application endpoints with FastAPI `FastAPI`, `APIRouter`, dependency wiring, route decorators, middleware registration, docs generation, or lifecycle hooks.
+- Do not author application endpoints with Starlette route, request, response, middleware, background-task, or lifecycle classes.
+- Do not use raw SQLAlchemy `mapped_column(...)` or `Column(...)` as the primary application authoring surface when Tigrbl column helpers or specs can represent the field behavior.
+- Do not build ad-hoc SQLAlchemy engines, sessions, or sessionmakers inside request handlers.
+- Do not call direct database/session methods such as `flush()` or `commit()` from application hooks or handlers unless you are implementing a framework-level atom with the correct lifecycle guard contract.
+- Do not wrap model behavior in one-off route handlers when an operation spec can represent the behavior.
+- Do not bypass kernel/runtime plans when wiring REST, JSON-RPC, stream, SSE, WebSocket, or WebTransport behavior.
+
+Avoid:
+
+- Avoid treating ASGI, FastAPI, Starlette, SQLAlchemy ORM materialization, or direct DB methods as the user-facing application contract. Tigrbl owns the authoring contract; lower-level libraries are implementation substrates behind Tigrbl-owned adapters, engines, tests, or benchmarks.
+- Avoid duplicating field behavior in SQLAlchemy, Pydantic, docs, and route handlers. Put reusable behavior in Tigrbl specs so storage, schema, docs, runtime, hooks, and diagnostics read the same source.
+- Avoid hand-written Pydantic envelopes for payloads that belong to a Tigrbl operation.
+- Avoid transport-specific wrappers for authentication, authorization, validation, or dispatch when security dependencies, hooks, operation specs, or lifecycle phases can express the rule once.
+- Avoid teaching lower-level internals in application README examples unless the example is clearly marked as a test, benchmark, migration, engine adapter, or framework-internal compatibility surface.
+
+## Default CRUD and Operation Semantics
+
+The canonical default operation set is `create`, `read`, `update`, `replace`, `delete`, `list`, and `clear`. Tables can opt out, opt into a subset, or add explicit operation specs. Additional operation packs provide bulk, analytical, and realtime verbs such as `bulk_create`, `bulk_update`, `bulk_replace`, `bulk_merge`, `bulk_delete`, `count`, `exists`, `aggregate`, `group_by`, `tail`, `subscribe`, `publish`, `upload`, `download`, `append_chunk`, `checkpoint`, and transport-oriented handlers.
+
+| Operation | REST shape | JSON-RPC shape | Arity | Semantics |
+|---|---|---|---|---|
+| `create` | `POST /{resource}` | `Model.create` | collection | Validate input, apply defaults/policies, persist one record, return the output schema. |
+| `read` | `GET /{resource}/{id}` | `Model.read` | member | Fetch one record by identity and serialize through the output schema. |
+| `update` | `PATCH /{resource}/{id}` | `Model.update` | member | Apply partial update semantics; omitted fields remain unchanged. |
+| `replace` | `PUT /{resource}/{id}` | `Model.replace` | member | Apply replacement semantics; the submitted representation is the desired record shape. |
+| `delete` | `DELETE /{resource}/{id}` | `Model.delete` | member | Remove or policy-delete one record and return the configured result envelope. |
+| `list` | `GET /{resource}` | `Model.list` | collection | Resolve filters, pagination, ordering, visibility policy, and output collection shape. |
+| `clear` | `DELETE /{resource}` | `Model.clear` | collection | Delete a collection according to policy and filter configuration. |
+| `bulk_create` | `POST /{resource}` | `Model.bulk_create` | collection | Create many records from an array of row objects and return the created row outputs. |
+| `bulk_update` | `PATCH /{resource}` | `Model.bulk_update` | collection | Patch many existing records by primary key and return the updated row outputs. |
+| `bulk_replace` | `PUT /{resource}` | `Model.bulk_replace` | collection | Replace many existing records by primary key and return the replaced row outputs. |
+| `bulk_merge` | `PATCH /{resource}` | `Model.bulk_merge` | collection | Upsert or merge many records by primary key and return the resulting row outputs. |
+| `bulk_delete` | `DELETE /{resource}` | `Model.bulk_delete` | collection | Delete many records by primary key and return a deleted-count envelope. |
+| `custom` | op-defined | op-defined | op-defined | Use explicit `op_ctx`/operation specs for domain-specific verbs while keeping schemas, hooks, and policies unified. |
+
+Route conflicts are intentional. A collection `POST` cannot simultaneously mean scalar `create` and `bulk_create` on the same REST path, and a collection `DELETE` cannot simultaneously mean `clear` and `bulk_delete`. JSON-RPC methods remain independently addressable by method name, so RPC is the right surface when both scalar and bulk forms must be exposed without path ambiguity.
+
+## Bulk Operation Shape Reference
+
+Bulk operations are collection-arity operations. REST binds them to the collection path, while JSON-RPC binds them to `Model.<bulk_op>`. The public wire shape is intentionally simple: row bulk operations take a JSON array of row objects, and `bulk_delete` takes a JSON array of primary-key values. Wrapper objects such as `{ "data": ... }`, `{ "payload": ... }`, `{ "body": ... }`, and `{ "item": ... }` are rejected unless those names are real schema fields for the operation.
+
+| Operation | REST request | JSON-RPC params | Success response | Required shape rules |
+|---|---|---|---|---|
+| `bulk_create` | `POST /{resource}` with `[{...row}, {...row}]` | `[{...row}, {...row}]` | `[{...created_row}, {...created_row}]` | Each item is a create input row. Primary keys may be supplied or generated according to the table schema. Empty input creates nothing and returns `[]`. |
+| `bulk_update` | `PATCH /{resource}` with `[{pk: value, ...patch}, ...]` | `[{pk: value, ...patch}, ...]` | `[{...updated_row}, ...]` | Each item must include the model primary-key field. Non-PK fields are patched; omitted mutable fields remain unchanged. Immutable columns for `update` are skipped. |
+| `bulk_replace` | `PUT /{resource}` with `[{pk: value, ...replacement}, ...]` | `[{pk: value, ...replacement}, ...]` | `[{...replaced_row}, ...]` | Each item must include the model primary-key field. Replacement semantics apply per row: missing mutable attributes are cleared according to replace behavior, while immutable columns for `replace` are skipped. |
+| `bulk_merge` | `PATCH /{resource}` with `[{pk: value, ...fields}, ...]` | `[{pk: value, ...fields}, ...]` | `[{...merged_or_created_row}, ...]` | Rows with an existing primary key are merged; rows with no key or a non-existing key are created/upserted. Existing-row merge follows the scalar `merge` semantics. |
+| `bulk_delete` | `DELETE /{resource}` with `[pk1, pk2]` | `[pk1, pk2]` | `{ "deleted": N }` | Input is a sequence of primary-key values. The schema/docs layer may expose an `ids` wrapper for component naming, but REST and JSON-RPC call paths normalize a bare ID list. Empty input returns `{ "deleted": 0 }`. |
+
+Example REST payloads:
+
+```json
+[
+  { "id": "w-1", "name": "first" },
+  { "id": "w-2", "name": "second" }
+]
+```
+
+```json
+["w-1", "w-2"]
+```
+
+Example JSON-RPC calls:
+
+```json
+{
+  "jsonrpc": "2.0",
+  "method": "Widget.bulk_update",
+  "params": [
+    { "id": "w-1", "name": "renamed" },
+    { "id": "w-2", "name": "retitled" }
+  ],
+  "id": 1
+}
+```
+
+```json
+{
+  "jsonrpc": "2.0",
+  "method": "Widget.bulk_delete",
+  "params": ["w-1", "w-2"],
+  "id": 2
+}
+```
+
+Bulk operations are not part of the minimal canonical default set. They are enabled by operation specs, mixins such as `BulkCapable`, `Replaceable`, and `Mergeable`, or explicit table configuration. `bulk_replace` depends on replacement support, and `bulk_merge` depends on merge support. When a bulk REST route claims the same collection method as a scalar route, the bulk route suppresses the conflicting scalar REST route; the scalar JSON-RPC method can still be exposed by name.
+
+## REST, JSON-RPC, and Transport Projection
+
+Tigrbl projects the same operation inventory across multiple protocol surfaces:
+
+| Surface | Binding family | Framing | Primary use |
+|---|---|---|---|
+| REST over HTTP/HTTPS | request | JSON | Resource-oriented CRUD and conventional HTTP clients. |
+| JSON-RPC over HTTP/HTTPS | request | JSON-RPC | Method-oriented clients, batch-capable RPC contracts, and OpenRPC generation. |
+| HTTP stream | stream | stream or configured stream framing | Server-streaming outputs and progressive responses. |
+| SSE | stream | SSE | Browser-friendly event streams. |
+| WebSocket/WSS | message | text or JSON-RPC when negotiated | Bidirectional message workflows. |
+| WebTransport | session, stream, or datagram | WebTransport outer framing plus lane-specific inner framing | Session, stream, and datagram transports with fail-closed lane validation. |
+
+The framework keeps protocol, exchange, and framing separate. For example, strict JSON-RPC document framing is `jsonrpc`; newline-delimited JSON-RPC should be modeled distinctly rather than collapsed into plain `ndjson`. Unsupported combinations fail closed during binding or runtime planning instead of being guessed.
+
+## Request Lifecycle and Hook Phases
+
+Runtime-owned routing flows through stable phases. Hooks attach to phases, atoms provide framework work, and the kernel records the plan used for each model operation.
+
+| Phase | Role |
+|---|---|
+| `INGRESS_BEGIN` | Start request or transport-unit handling and initialize context. |
+| `INGRESS_PARSE` | Parse transport payloads, request metadata, path variables, query data, or message bodies. |
+| `INGRESS_DISPATCH` | Resolve the target operation, binding, and protocol subevent. |
+| `PRE_TX_BEGIN` | Run pre-transaction checks before a database transaction exists. |
+| `START_TX` | Open or attach transaction/session state when the operation requires it. |
+| `PRE_HANDLER` | Resolve dependencies, validate inputs, enforce policy, and prepare handler state. |
+| `HANDLER` | Execute the operation handler or system handler. |
+| `POST_HANDLER` | Normalize handler output and run in-transaction post-processing. |
+| `PRE_COMMIT` | Run final in-transaction checks before commit. |
+| `TX_COMMIT` | Flush/commit when Tigrbl owns the transaction; also exposed historically as `END_TX`. |
+| `POST_COMMIT` | Run committed-side effects before response shaping. |
+| `EGRESS_SHAPE` | Build response envelopes, apply masks, negotiate output shape, and prepare transport response data. |
+| `EGRESS_FINALIZE` | Apply headers/status/renderers and finalize transport response. |
+| `POST_RESPONSE` | Run after-response work that should not affect the returned payload. |
+| `ON_*_ERROR` | Phase-specific error handling; falls back to `ON_ERROR` when no specific chain handles the failure. |
+| `TX_ROLLBACK` | Roll back transaction-owned work and perform cleanup; also exposed historically as `ON_ROLLBACK`. |
+
+Happy path:
+
+```text
+INGRESS_BEGIN
+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
+```
+
+Use hooks for policy, validation, enrichment, audit, response shaping, and post-response work. Keep core persistence and transport handling inside ops and atoms so REST, JSON-RPC, diagnostics, and schemas stay aligned.
+
+```python
+from tigrbl import hook_ctx
+
+@hook_ctx(ops="create", phase="PRE_HANDLER")
+async def validate_name(ctx):
+    payload = ctx["request"].payload
+    if payload.get("name") == "reserved":
+        raise ValueError("reserved name")
+```
+
+Hooks can also be registered imperatively on the model or composed by packages that build operation specs. Running apps can expose `/system/hookz` to inspect registered hook order and `/system/kernelz` to inspect the compiled phase plan.
+
+## Step Types and Kernel Labels
+
+Execution plans are composed from labeled steps:
+
+| Step type | Owner | Purpose |
+|---|---|---|
+| `secdep` | Application or security package | Authentication and authorization dependencies that run before ordinary dependencies. |
+| `dep` | Application or extension package | General dependency resolution and request context hydration. |
+| `hook:sys` | Tigrbl | Built-in system hooks for runtime behavior, transaction handling, schema work, and transport work. |
+| `hook:wire` | Application or extension package | User hooks registered through decorators or specs. |
+| `atom:<domain>:<subject>` | Tigrbl atoms/kernel | Small runtime units such as ingress parsing, dispatch, validation, handler invocation, response shaping, or transport emission. |
+
+Kernel labels make execution order reviewable, for example `PRE_HANDLER:hook:wire:myapp.audit@PRE_HANDLER` or `EGRESS_SHAPE:atom:wire:dump`. Treat labels as diagnostics, not as a stable replacement for the public decorator/spec APIs.
+
+## Engine and Session Semantics
+
+Engines are declared through specs, providers, decorators, or concrete engine instances. Resolution chooses the most specific binding:
+
+```text
+operation > table/model > router > app > defaults
+```
+
+Use engine specs and Tigrbl's engine decorators instead of creating ad-hoc SQLAlchemy engines inside handlers. This keeps transaction ownership, routing, diagnostics, engine plugins, and tests coherent.
+
+```python
+from tigrbl.decorators.engine import engine_ctx
+from tigrbl.engine.shortcuts import engine_spec
+
+db = engine_spec(kind="sqlite", mode="memory")
+
+@engine_ctx(db)
+class Item:
+    __tablename__ = "items"
+```
+
+Database sessions are guarded by lifecycle phase. Do not call `flush()` or `commit()` directly from application hooks or handlers unless you are implementing a framework-level atom with the correct guard contract. Let `START_TX`, `PRE_HANDLER`, `HANDLER`, `POST_HANDLER`, `PRE_COMMIT`, and `TX_COMMIT` own transaction progression.
+
+## Configuration and Schema Precedence
+
+Tigrbl resolves configuration by layering broad defaults first and specific intent last:
+
+```text
+per-request overrides > operation spec > column spec > table spec > router spec > app spec > framework defaults
+```
+
+Use that same mental model for schema, response, path, engine, and operation behavior. Put shared policy at app/router scope, model-specific behavior at table scope, field behavior at column scope, and exceptional behavior in operation specs or request overrides.
+
+Common table-level declarations include:
+
+- `__tigrbl_request_extras__` and `__tigrbl_response_extras__` for operation-scoped virtual fields.
+- `__tigrbl_register_hooks__` or hook decorators for lifecycle customization.
+- `__tigrbl_nested_paths__` for hierarchical REST paths.
+- `__tigrbl_allow_anon__` for anonymous operation access.
+- `__tigrbl_owner_policy__` and `__tigrbl_tenant_policy__` for ownership and tenancy injection.
+- `__tigrbl_verb_aliases__` and `__tigrbl_verb_alias_policy__` for operation naming and alias behavior.
+
+## Best Practices
+
+- Use `tigrbl` facade imports in application code; import split packages directly only for framework extension work.
+- Model domain actions as operations, not ad-hoc routes, so REST, JSON-RPC, schemas, hooks, OpenAPI, OpenRPC, and diagnostics stay in sync.
+- Use `get_schema(...)` or schema helpers for request/response envelopes instead of hand-rolled Pydantic classes when the payload belongs to a Tigrbl operation.
+- Keep `Table` first in model inheritance when using ORM table classes so table inspection and MRO-sensitive behavior stay deterministic.
+- Bind engines declaratively at app, router, table, or operation scope; do not create engines inside request handlers.
+- Let the lifecycle own transaction boundaries; avoid direct `flush()`, `commit()`, and SQLAlchemy session mutation from user hooks.
+- Put authentication/authorization in security dependencies or `PRE_HANDLER` hooks, not in transport-specific route wrappers.
+- Use `/system/hookz`, `/system/kernelz`, docs endpoints, OpenAPI, and OpenRPC outputs as operational inspection surfaces during debugging.
+- Treat unsupported transport/framing combinations as unsupported, not broken. Preserve fail-closed behavior unless the underlying binding and runtime packages are intentionally extended.
+
 ## How To Choose This Package
 
 Choose `tigrbl` when you want the full public facade: app composition, schema-first routing, REST and JSON-RPC projection, docs generation, engine integration, and CLI workflow. Choose a lower-level package such as [`tigrbl-core`](https://pypi.org/project/tigrbl-core/), [`tigrbl-base`](https://pypi.org/project/tigrbl-base/), or [`tigrbl-runtime`](https://pypi.org/project/tigrbl-runtime/) only when you are building framework extensions or testing a specific internal boundary.
@@ -416,6 +686,8 @@ Choose `tigrbl` when you want the full public facade: app composition, schema-fi
 - [Package layout](https://github.com/tigrbl/tigrbl/blob/master/docs/developer/PACKAGE_LAYOUT.md)
 - [Current target](https://github.com/tigrbl/tigrbl/blob/master/docs/conformance/CURRENT_TARGET.md)
 - [Current state](https://github.com/tigrbl/tigrbl/blob/master/docs/conformance/CURRENT_STATE.md)
+- [Next steps](https://github.com/tigrbl/tigrbl/blob/master/docs/conformance/NEXT_STEPS.md)
+- [Documentation pointers](https://github.com/tigrbl/tigrbl/blob/master/docs/governance/DOC_POINTERS.md)
 - [SSOT registry](https://github.com/tigrbl/tigrbl/blob/master/.ssot/registry.json)
 - [Release workflow](https://github.com/tigrbl/tigrbl/actions/workflows/publish.yml)
 
@@ -427,7 +699,7 @@ Choose `tigrbl` when you want the full public facade: app composition, schema-fi
 
 ## Package-local Boundary
 
-This README is the package-local distribution entry point for `tigrbl`. It answers install, usage, API, ownership, and certification-orientation questions for this package. Broader architectural decisions, release status, and cross-package proof chains remain in the repository-level docs and SSOT registry.
+This file is a package-local distribution entry point. This README is the package-local distribution entry point for `tigrbl`. It answers install, usage, API, ownership, and certification-orientation questions for this package. Broader architectural decisions, release status, and cross-package proof chains remain in the repository-level docs and SSOT registry.
 
 ## License
 

{tigrbl-0.4.2.dev4.dist-info → tigrbl-0.4.3.dev4.dist-info}/RECORD

@@ -1,7 +1,7 @@
-tigrbl/__init__.py,sha256=O7LQ7QRG6bStodtJXeVKp0KR-dFg9IuTAB6N_0C8wlg,10908
+tigrbl/__init__.py,sha256=YPfm-QVVRpNh6H2UYslMlFNeiB_S1Gd8Ut92u3qj0ZQ,12732
 tigrbl/__main__.py,sha256=un3tg4SmbC-Sts-Qy2pI200OZRhUONt5DAjijPunNas,78
 tigrbl/canonical_json.py,sha256=TgOOVnpTNarCj4VVm0mcnawgFD4ezZs86gF5Ea_UOt0,229
-tigrbl/cli.py,sha256=eDuct1vvTzpfO7XXhZcPgSXcgIOJ_ivtPISGFzvKMoM,32843
+tigrbl/cli.py,sha256=xkg2ajezzq_I9MQtxTvHnv5s1tn9GMuO56DGWspkivA,33069
 tigrbl/config/__init__.py,sha256=MF8LNEX-S3IMsPYe2n1Y8KXZL1YFBer2nBk54JhBwyY,102
 tigrbl/config/constants.py,sha256=pA35CGX3GComUcFTveP8dqv73XGXJfwE5TKycZJubeg,123
 tigrbl/config/defaults.py,sha256=m8CMgrizY12CpLPfFBC_4Ja86xamJuKPdXROAm9xSQg,113
@@ -34,9 +34,9 @@ tigrbl/factories/responses.py,sha256=0XUnCLEbm0_Jc9j4JK8O85DecUrw1N-X9-f8S0zglfo
 tigrbl/factories/router.py,sha256=suXgxM2WJk13Je8oanmT5Ffi1Pplc4OVkMl3w0NFkOg,1355
 tigrbl/factories/schema.py,sha256=KKoZcacMtnGJjpLnGPdSurRs8ayRhA83fcLfWw3tAz0,952
 tigrbl/factories/table.py,sha256=rGk2reMpEyBZhKHXyqVkdd2PnvjQLcaxzZqcXQk3KxQ,1734
-tigrbl/hook/exceptions.py,sha256=XFTiArveiajtZYBYuhB5iOMxPOuvx1TwYyHvp8wqXgI,111
+tigrbl/hook/exceptions.py,sha256=-pSRN8FC-FfjIOKHlIE_JkmlzxIzE1aVOvASr8J6uzA,122
 tigrbl/hook/types.py,sha256=5_7mwME1fMDuSSmKEGZgLxQegrvadvQ1RYiREFqL0mg,336
-tigrbl/middlewares/__init__.py,sha256=2azzU10Dp2kDMRYNbMAGq9eBTFxY29Wy0qH40Uu3eOA,340
+tigrbl/middlewares/__init__.py,sha256=V97hoVwcZA_QUlIMKlti0opvRNABm_CUErwRdZfYkUk,324
 tigrbl/middlewares/compose.py,sha256=SXf4lOhY8DsWGBKgkDzpVqegzVRiqj32a6p7TRFXd5w,416
 tigrbl/op/__init__.py,sha256=2eMY51Bx2tjwXpacpIVaK_yP7Glk9sEpXsiIUrivhgQ,511
 tigrbl/op/canonical.py,sha256=bApdl9atBkUpqzSUJNDpFso9ShuJGown9Vs5bjzlvwA,115
@@ -53,6 +53,7 @@ tigrbl/schema/builder/extras.py,sha256=SS5YVKYhgG8Stfoans3mRTNltteKU_yaUzWi1SU-A
 tigrbl/schema/builder/helpers.py,sha256=OiEj0iZuPma8HgLV8qUYNnNaOKd4WIdFm4vcXkEANzo,127
 tigrbl/schema/builder/list_params.py,sha256=EmkhBvxNw-5WGIhlrWVVsPGyTowc46LgTu3V-BQKVWU,131
 tigrbl/schema/builder/strip_parent_fields.py,sha256=i-wz43Tz18FPFiez9Ym-uDrvEVkYZ3RWhnG6CtJ2UvQ,139
+tigrbl/schema/jsonrpc.py,sha256=4ZYoFvImeRWyxFpUjcwUZrIGhnn3ZrFzaxLERMBzAK8,64
 tigrbl/schema/utils.py,sha256=BY1VM734AUlaFupIpGjvaJMwpK7gOJMPgiF2MNx_VTM,269
 tigrbl/security/__init__.py,sha256=0QVCDfEtYUTQN-Q5lp20EigwEyFyCygivsKlcFBgbz0,110
 tigrbl/security/dependencies.py,sha256=5_M-RKIkRzDKi0g65m9lUUbO6GT9Gm6T7Xa4uP5TVYQ,129
@@ -72,13 +73,13 @@ tigrbl/shortcuts/schema.py,sha256=J9IO6rZ8n8GGdmCcFCbykg8ueMELkWUUIwAHukjgm4Y,61
 tigrbl/shortcuts/table.py,sha256=6uROGTFNoQ05skg0YiABubUsZq-dr7RrFzA5Rfd9zJQ,60
 tigrbl/specs.py,sha256=hqNd1FOzymwBJO79D0e4JbvcNbFFPrJvIJYKixnVCA0,971
 tigrbl/system/__init__.py,sha256=53JG9pfmRtgg_exOOCmexAUSEmpLgOZYjkYPSiDckTg,106
-tigrbl/system/diagnostics/__init__.py,sha256=CE7Hn9DGoj_Xsxmy8t2NRjs3QhlwXY_uf9N1P8DvnoY,1147
+tigrbl/system/diagnostics/__init__.py,sha256=ZXU_YJX_poe-45KPriuV-lm8gY_i_4n5VlAEzUbzHYw,1201
 tigrbl/system/diagnostics/healthz.py,sha256=GNNF9YAJBanRE7mtP7bCCP7FYax5hezp2YB4w6rd3uo,8761
 tigrbl/system/diagnostics/hookz.py,sha256=Acy2buWOkC-su-5Y5zPFc1Mw7cD2d1hPuQFC_4PAuUM,1807
-tigrbl/system/diagnostics/kernelz.py,sha256=SCTFj6y11A3W3IudQB03OdktdZwarSgPcK_9-7agHME,1719
-tigrbl/system/diagnostics/methodz.py,sha256=cQUyg5bhXKX7LdtanNvethcfJF1jp8LjudzMfPDuYm4,1634
+tigrbl/system/diagnostics/kernelz.py,sha256=5M2N8xvVTlXpg2IE2UgNRvJQznAuRfhafYZIz0tPqGQ,365
+tigrbl/system/diagnostics/methodz.py,sha256=68VgXvu6DO9BTJ_HeqdVh11NjtQefxrSi3KaIjKGQzg,1728
 tigrbl/system/diagnostics/router.py,sha256=HzrVdm8XZLDc3IWPRDMoCHtUIkYA4WWTcGTyYqJSEMg,106
-tigrbl/system/diagnostics/utils.py,sha256=bnOnnQSFIoxIp5ev8SgdWu0SdZogyl0oLQ_p5FaoxsE,1543
+tigrbl/system/diagnostics/utils.py,sha256=mSWPhegRDccWY4l3b9aIFHIB2Xvma5U2h06-XKFouxU,284
 tigrbl/system/docs/__init__.py,sha256=BEosgnAkJyWGphoO_kbNx5NlwUhM_dtaCXHwYmfM0KQ,1510
 tigrbl/system/docs/lens.py,sha256=FEHSfVdNvNYT4gwf3uYQ4EpqDFc-SAkwP_rgtgZFNJA,3516
 tigrbl/system/docs/openapi/__init__.py,sha256=9aN4AuBuNoJsJ2Oz750NsJY2B_wg2KEQBOdJbwiTZGg,897
@@ -93,10 +94,10 @@ tigrbl/system/favicon/assets/favicon.svg,sha256=HsBFC1uF_Tb8dPqAId3CLEidRx0nQyrE
 tigrbl/system/uvicorn.py,sha256=ogvIqfv-1CxAPZ8BADucaNAy_ePsLA3IVIZxmhdfL3A,1526
 tigrbl/transport/__init__.py,sha256=h4-VBa7Ztft-z4nEYDiVRZm1NvPb3laRNUdcYEelmiI,59
 tigrbl/transport/jsonrpc/__init__.py,sha256=O6AuYTC0XlTWZc4j5aJFNKMqn3RfkHUh2bpg8kfj6s0,67
-tigrbl/transport/jsonrpc/helpers.py,sha256=BqtbdVQVTTwNhkOR15wfTv11jIhmx0mWFd9IhWMoRgI,75
-tigrbl/transport/jsonrpc/models.py,sha256=4Lsq2pbAf2zs0K9KrHu6UdIa3CsJfrCzeXsP3JwQk_w,74
+tigrbl/transport/jsonrpc/helpers.py,sha256=RBrAKez0vEvTP4U4kMB7NTOYu5em8LqM5CBP1RY1hJQ,266
+tigrbl/transport/jsonrpc/models.py,sha256=W3m3MGzzS6V6ifyg9TGqCSgfawaScBfQk07Otc8zJ4g,263
 tigrbl/transport/rest/__init__.py,sha256=VbK3ZEmI2U-74kkwFoLznC_pQGtci_jbuVJGhvJTqJ8,64
-tigrbl/transport/rest/aggregator.py,sha256=fd-2irmddowXzIe6ap71Nrx1UjFmPSmuC_VznacutIk,75
+tigrbl/transport/rest/aggregator.py,sha256=IeUOt9mHUBpIGvbOUgcVpbz__Fr2i86b8ZFdoZyMUwA,244
 tigrbl/types/__init__.py,sha256=ABWqAC7Vmq5X1k6CjzYpGWIX6LDzq6BdWtmrJ85Etsw,595
 tigrbl/utils/__init__.py,sha256=qiT3_Dx7Fp7ddLERh1e95i47viL920sFnT7qbK5FhT0,57
 tigrbl/utils/schema.py,sha256=vjQd1kr0Q0Kx3L3nX9U1QZKfMDsTnpUhR4TOiTkNCS4,2510
@@ -104,9 +105,9 @@ tigrbl/vendor/__init__.py,sha256=RQZ9SR6hxUveFhVN2jyM2CaAV23fXa832sxB16CeWjQ,645
 tigrbl/vendor/jinja.py,sha256=sFr9Bq2luWDJPNMNFF7hCQcUyJOIzSwHwHrJ_k0yIh4,787
 tigrbl/vendor/pydantic.py,sha256=cLReo5Gd3V7TDJ9L3sMOFD93FWMd5QnZZoCaOJ6ip14,497
 tigrbl/vendor/sqlalchemy.py,sha256=mzc1kHispjk2n6Ll9xSPO7ZQ3Uq_BYECzS1o2Krifls,2456
-tigrbl-0.4.2.dev4.dist-info/METADATA,sha256=qe6HX5dvouGXKMVMPPlYBZicw9kGYqIYiecQUyz08RQ,24329
-tigrbl-0.4.2.dev4.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
-tigrbl-0.4.2.dev4.dist-info/entry_points.txt,sha256=pXiN_KfMec0vJe-se_ATzXS7bEPFcQ-pGgmqS1_6j3E,50
-tigrbl-0.4.2.dev4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-tigrbl-0.4.2.dev4.dist-info/licenses/NOTICE,sha256=EvJMTshzsWz43LiK-DeN2ZuLtrP49cxvlrFlJ8F_buc,221
-tigrbl-0.4.2.dev4.dist-info/RECORD,,
+tigrbl-0.4.3.dev4.dist-info/METADATA,sha256=aXPDqkd_4hezxcZC3Pr3dDshOtetMgNYcsuN-scUx7M,44910
+tigrbl-0.4.3.dev4.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+tigrbl-0.4.3.dev4.dist-info/entry_points.txt,sha256=pXiN_KfMec0vJe-se_ATzXS7bEPFcQ-pGgmqS1_6j3E,50
+tigrbl-0.4.3.dev4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tigrbl-0.4.3.dev4.dist-info/licenses/NOTICE,sha256=EvJMTshzsWz43LiK-DeN2ZuLtrP49cxvlrFlJ8F_buc,221
+tigrbl-0.4.3.dev4.dist-info/RECORD,,