tigrbl 0.0.1.dev1__py3-none-any.whl → 0.3.0__py3-none-any.whl

tigrbl/runtime/atoms/refresh/demand.py

@@ -0,0 +1,130 @@
+# tigrbl/v3/runtime/atoms/refresh/demand.py
+from __future__ import annotations
+
+from typing import Any, Iterable, Optional
+import logging
+
+from ... import events as _ev
+from ...opview import opview_from_ctx, _ensure_temp
+
+# After the handler flushes changes; decide whether to hydrate DB-generated values.
+ANCHOR = _ev.POST_FLUSH  # "post:flush"
+
+logger = logging.getLogger("uvicorn")
+
+
+def run(obj: Optional[object], ctx: Any) -> None:
+    """
+    refresh:demand@post:flush
+
+    Purpose
+    -------
+    Decide whether to hydrate refreshed values from the DB after a write (INSERT/UPDATE).
+    We do NOT perform the refresh here; we only mark intent on the context so the
+    executor (or handler) can perform the vendor-specific action (RETURNING/refresh()).
+
+    Inputs (conventions)
+    --------------------
+    - ctx.persist : bool               → write op? (anchor is persist-tied but we guard)
+    - ctx.temp["used_returning"] : bool              → a prior step already satisfied hydration
+    - ctx.temp["hydrated_values"] : Mapping[str, Any]→ values captured from RETURNING
+    - ctx.cfg.refresh_after_write : Optional[bool]   → policy override (true/false)
+      (also checks ctx.cfg.refresh_policy.{always,never,auto})
+    - ctx.bulk    : Optional[bool]    → bulk write; executor may choose a different strategy
+
+    Effects
+    -------
+    - ctx.temp["refresh_demand"] : bool
+    - ctx.temp["refresh_fields"] : tuple[str, ...] (hint: which fields likely changed in DB)
+    - ctx.temp["refresh_reason"] : str (diagnostic only)
+    """
+    logger.debug("Running refresh:demand")
+    if getattr(ctx, "persist", True) is False:
+        logger.debug("Skipping refresh:demand; ctx.persist is False")
+        return
+
+    temp = _ensure_temp(ctx)
+    ov = opview_from_ctx(ctx)
+    refresh_hints = tuple(ov.refresh_hints)
+
+    # If RETURNING already produced hydrated values, skip unless policy forces refresh.
+    returning_satisfied = bool(temp.get("used_returning")) or bool(
+        temp.get("hydrated_values")
+    )
+    logger.debug("Returning satisfied: %s", returning_satisfied)
+
+    # Policy: cfg.refresh_after_write wins if explicitly set; otherwise "auto".
+    policy = _get_refresh_policy(ctx)
+    logger.debug("Refresh policy: %s", policy)
+    # auto → infer from specs (db-generated signals) OR absence of returning values
+    needs_by_specs = bool(refresh_hints)
+    logger.debug("Refresh hints: %s; fields=%s", needs_by_specs, refresh_hints)
+    need_refresh = _decide(policy, returning_satisfied, needs_by_specs)
+    logger.debug("Refresh decision: %s", need_refresh)
+
+    temp["refresh_demand"] = bool(need_refresh)
+    temp["refresh_fields"] = refresh_hints
+
+    if need_refresh:
+        temp["refresh_reason"] = _reason(
+            policy, returning_satisfied, needs_by_specs, refresh_hints
+        )
+        logger.debug("Refresh scheduled: %s", temp["refresh_reason"])
+    else:
+        temp["refresh_reason"] = "skipped: returning_satisfied or policy=false"
+        logger.debug("Refresh skipped: %s", temp["refresh_reason"])
+
+    # Executor/handler will look at ctx.temp["refresh_demand"] and act accordingly.
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Internals
+# ──────────────────────────────────────────────────────────────────────────────
+
+
+def _get_refresh_policy(ctx: Any) -> str:
+    """
+    Return 'always' | 'never' | 'auto'.
+    Accepts any of the following on ctx.cfg (first hit wins):
+      - cfg.refresh_after_write: bool → True:'always' / False:'never'
+      - cfg.refresh_policy: str in {'always','never','auto'}
+    Defaults to 'auto'.
+    """
+    cfg = getattr(ctx, "cfg", None)
+    if cfg is not None:
+        val = getattr(cfg, "refresh_after_write", None)
+        if isinstance(val, bool):
+            return "always" if val else "never"
+        pol = getattr(getattr(cfg, "refresh_policy", None), "value", None) or getattr(
+            cfg, "refresh_policy", None
+        )
+        if isinstance(pol, str) and pol in {"always", "never", "auto"}:
+            return pol
+    return "auto"
+
+
+def _decide(policy: str, returning_satisfied: bool, needs_by_specs: bool) -> bool:
+    if policy == "always":
+        return True
+    if policy == "never":
+        return False
+    # auto
+    if returning_satisfied:
+        # RETURNING already hydrated values; only refresh if specs strongly indicate more work.
+        return bool(needs_by_specs)
+    # No returning: default to refresh to honor "hydrate after flush" decision.
+    return True
+
+
+def _reason(
+    policy: str, returning_satisfied: bool, needs_by_specs: bool, fields: Iterable[str]
+) -> str:
+    parts = [f"policy={policy}"]
+    parts.append(f"returning_satisfied={bool(returning_satisfied)}")
+    parts.append(f"specs_need={bool(needs_by_specs)}")
+    if fields:
+        parts.append(f"fields={','.join(fields)}")
+    return "; ".join(parts)
+
+
+__all__ = ["ANCHOR", "run"]

tigrbl/runtime/atoms/resolve/__init__.py

@@ -0,0 +1,40 @@
+# tigrbl/v3/runtime/atoms/resolve/__init__.py
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional, Tuple
+import logging
+
+# Atom implementations (model-scoped)
+from . import assemble as _assemble
+from . import paired_gen as _paired_gen
+
+# Runner signature: (obj|None, ctx) -> None
+RunFn = Callable[[Optional[object], Any], None]
+
+#: Domain-scoped registry consumed by the kernel plan (and aggregated at atoms/__init__.py).
+#: Keys are (domain, subject); values are (anchor, runner).
+REGISTRY: Dict[Tuple[str, str], Tuple[str, RunFn]] = {
+    ("resolve", "assemble"): (_assemble.ANCHOR, _assemble.run),
+    ("resolve", "paired_gen"): (_paired_gen.ANCHOR, _paired_gen.run),
+}
+
+logger = logging.getLogger("uvicorn")
+
+
+def subjects() -> Tuple[str, ...]:
+    """Return the subject names exported by this domain."""
+    subjects = tuple(s for (_, s) in REGISTRY.keys())
+    logger.debug("Listing 'resolve' subjects: %s", subjects)
+    return subjects
+
+
+def get(subject: str) -> Tuple[str, RunFn]:
+    """Return (anchor, runner) for a subject in the 'resolve' domain."""
+    key = ("resolve", subject)
+    if key not in REGISTRY:
+        raise KeyError(f"Unknown resolve atom subject: {subject!r}")
+    logger.debug("Retrieving 'resolve' subject %s", subject)
+    return REGISTRY[key]
+
+
+__all__ = ["REGISTRY", "RunFn", "subjects", "get"]

tigrbl/runtime/atoms/resolve/assemble.py

@@ -0,0 +1,167 @@
+# tigrbl/v3/runtime/atoms/resolve/assemble.py
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional, Dict, Tuple
+import logging
+
+from ... import events as _ev
+from ...opview import opview_from_ctx, ensure_schema_in, _ensure_temp
+
+# Runs in HANDLER phase, before pre:flush and any storage transforms.
+ANCHOR = _ev.RESOLVE_VALUES  # "resolve:values"
+
+logger = logging.getLogger("uvicorn")
+
+
+def run(obj: Optional[object], ctx: Any) -> None:
+    """
+    resolve:assemble@resolve:values
+
+    Purpose
+    -------
+    Build a normalized dict of inbound values to apply on the model (assembled_values).
+    - Prefer client-provided, validated values (from wire:build_in/validate).
+    - For fields that are **ABSENT** (not present in inbound), apply ColumnSpec.default_factory(ctx)
+      for simple server-side defaults (non-paired path).
+    - Virtual columns (storage=None) are never persisted; if present in inbound, stash them
+      under temp["virtual_in"] for downstream wire/out logic.
+
+    Inputs (conventions)
+    --------------------
+    - ctx.temp["in_values"] OR ctx.in_data / ctx.payload / ctx.data / ctx.body :
+        dict-like or Pydantic model; used as inbound source
+    - ctx.persist : bool  (writes only; non-persist ops typically prune this anchor)
+    - ctx.op      : str   (verb name; optional, only for diagnostics)
+
+    Effects
+    -------
+    - ctx.temp["assembled_values"] : dict[field -> value] (only persisted fields)
+    - ctx.temp["virtual_in"]       : dict[field -> value] (for storage=None)
+    - ctx.temp["absent_fields"]    : tuple[str, ...]      (those not in inbound)
+    - ctx.temp["used_default_factory"] : tuple[str, ...]  (fields defaulted here)
+    """
+    # Non-persisting ops should have pruned this anchor; retain guard for safety.
+    if getattr(ctx, "persist", True) is False:
+        logger.debug("Skipping resolve:assemble; ctx.persist is False")
+        return
+
+    logger.debug("Running resolve:assemble")
+    ov = opview_from_ctx(ctx)
+    schema_in = ensure_schema_in(ctx, ov)
+    inbound = _coerce_inbound(getattr(ctx, "temp", {}).get("in_values", None), ctx)
+
+    temp = _ensure_temp(ctx)
+    assembled: Dict[str, Any] = {}
+    virtual_in: Dict[str, Any] = {}
+    absent: list[str] = []
+    used_default: list[str] = []
+
+    # Iterate fields in a stable order
+    for field in sorted(schema_in["fields"]):
+        meta = schema_in["by_field"].get(field, {})
+        in_enabled = meta.get("in_enabled", True)
+        is_virtual = meta.get("virtual", False)
+
+        present, value = _try_read_inbound(inbound, field)
+        if present:
+            if is_virtual:
+                virtual_in[field] = value
+                logger.debug("Captured virtual inbound %s=%s", field, value)
+            elif in_enabled:
+                assembled[field] = value
+                logger.debug("Assembled inbound %s=%s", field, value)
+            continue
+
+        absent.append(field)
+        logger.debug("Field %s absent from inbound", field)
+
+        default_fn = meta.get("default_factory")
+        if callable(default_fn) and in_enabled and not is_virtual:
+            try:
+                default_val = default_fn(_ctx_view(ctx))
+                assembled[field] = default_val
+                used_default.append(field)
+                logger.debug("Applied default for field %s", field)
+            except Exception:
+                logger.debug("Default factory failed for field %s", field)
+
+    # Stash results on ctx.temp
+    temp["assembled_values"] = assembled
+    temp["virtual_in"] = virtual_in
+    temp["absent_fields"] = tuple(absent)
+    temp["used_default_factory"] = tuple(used_default)
+    logger.debug(
+        "Assembled values: %s, virtual_in: %s, absent: %s, defaults: %s",
+        assembled,
+        virtual_in,
+        absent,
+        used_default,
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Internals
+# ──────────────────────────────────────────────────────────────────────────────
+
+
+def _coerce_inbound(candidate: Any, ctx: Any) -> Mapping[str, Any]:
+    """
+    Return a dict-like for inbound values.
+    Priority: ctx.temp["in_values"] → ctx.in_data → ctx.payload → ctx.data → ctx.body.
+    Accepts Pydantic v1/v2 models (model_dump()/dict()).
+    """
+    for name in ("in_values",):
+        if isinstance(candidate, Mapping):
+            return candidate
+    # fallbacks on ctx
+    for attr in ("in_data", "payload", "data", "body"):
+        val = getattr(ctx, attr, None)
+        if isinstance(val, Mapping):
+            return val
+        # Pydantic v2
+        if hasattr(val, "model_dump") and callable(getattr(val, "model_dump")):
+            try:
+                return dict(val.model_dump())
+            except Exception:
+                pass
+        # Pydantic v1
+        if hasattr(val, "dict") and callable(getattr(val, "dict")):
+            try:
+                return dict(val.dict())
+            except Exception:
+                pass
+    # default empty
+    return {}
+
+
+def _try_read_inbound(inbound: Mapping[str, Any], field: str) -> Tuple[bool, Any]:
+    """
+    Distinguish ABSENT vs present(None).
+    """
+    if field in inbound:
+        return True, inbound.get(field, None)
+    # Be tolerant to alias-style inputs (if present)
+    for alt in (field.lower(), field.upper()):
+        if alt in inbound:
+            return True, inbound.get(alt)
+    return False, None
+
+
+def _ctx_view(ctx: Any) -> Dict[str, Any]:
+    """
+    Provide a small read-only view for default_factory functions
+    without exposing the entire executor context.
+    """
+    view = {
+        "op": getattr(ctx, "op", None),
+        "persist": getattr(ctx, "persist", True),
+        "temp": getattr(ctx, "temp", None),
+        # optional hints the executor might set
+        "tenant": getattr(ctx, "tenant", None),
+        "user": getattr(ctx, "user", None),
+        "now": getattr(ctx, "now", None),
+    }
+    return view
+
+
+__all__ = ["ANCHOR", "run"]

tigrbl/runtime/atoms/resolve/paired_gen.py

@@ -0,0 +1,147 @@
+# tigrbl/v3/runtime/atoms/resolve/paired_gen.py
+from __future__ import annotations
+
+import secrets
+import logging
+from typing import Any, Dict, MutableMapping, Optional
+
+from ... import events as _ev
+from ...opview import opview_from_ctx, _ensure_temp
+
+# Runs in HANDLER phase, before pre:flush (and before storage transforms).
+ANCHOR = _ev.RESOLVE_VALUES  # "resolve:values"
+
+logger = logging.getLogger("uvicorn")
+
+
+def run(obj: Optional[object], ctx: Any) -> None:
+    """
+    resolve:paired_gen@resolve:values
+
+    Purpose
+    -------
+    Prepare *paired* raw values for columns marked as secret-once/paired.
+    The raw value is:
+      - taken from inbound virtual input (if provided), or
+      - generated securely (e.g., URL-safe token) when inbound is ABSENT.
+
+    Contracts / Conventions
+    -----------------------
+    - ctx.temp:
+        - "virtual_in"         : dict of inbound virtual values (from resolve:assemble)
+        - "paired_values"      : dict[field -> {"raw": <str>, "alias": <str>, "meta": {...}}]
+        - "persist_from_paired": dict[field -> {"source": ("paired_values", field, "raw")}]
+        - "assembled_values"   : dict used for persistence (we DO NOT put raw into it)
+        - "generated_paired"   : tuple of fields generated here (diagnostics)
+    - Secret-once guarantee is enforced later by emit atoms (post-refresh + readtime).
+
+    Policy
+    ------
+    - We treat a column as "paired" if any of these flags exist (ColumnSpec or FieldSpec):
+        secret_once=True | paired=True | paired_input=True | generate_on_absent=True
+      OR if a generator callable is present on the spec (generator/paired_generator/secret_generator).
+    - If inbound virtual value for the alias exists, we adopt it as the raw.
+    - Otherwise we call the generator if provided, else generate a token.
+    - We place a *pointer* into ctx.temp["persist_from_paired"] for storage:to_stored
+      to derive the persisted representation right before flush.
+    """
+    # Non-persisting ops should have pruned this anchor; keep guard for safety.
+    if getattr(ctx, "persist", True) is False:
+        logger.debug("Skipping resolve:paired_gen; ctx.persist is False")
+        return
+
+    logger.debug("Running resolve:paired_gen")
+    ov = opview_from_ctx(ctx)
+    temp = _ensure_temp(ctx)
+    assembled = _ensure_dict(temp, "assembled_values")
+    virtual_in = _ensure_dict(temp, "virtual_in")
+    paired_values = _ensure_dict(temp, "paired_values")
+    persist_from_paired = _ensure_dict(temp, "persist_from_paired")
+
+    generated: list[str] = []
+
+    for field, desc in ov.paired_index.items():
+        if field in assembled:
+            logger.debug(
+                "Field %s already has assembled value; skipping generation", field
+            )
+            continue
+
+        alias_name = desc.get("alias") or field
+        raw = None
+        if alias_name in virtual_in:
+            raw = virtual_in.get(alias_name)
+            logger.debug(
+                "Using client-provided raw for field %s via alias %s", field, alias_name
+            )
+
+        if raw is None:
+            logger.debug("Generating raw value for field %s", field)
+            gen = desc.get("gen")
+            if callable(gen):
+                try:
+                    raw = gen(_ctx_view(ctx))
+                except Exception:
+                    logger.debug("Generator failed for field %s", field)
+                    raw = None
+            if raw is None:
+                raw = _secure_token(desc.get("max_length", 0) or 0)
+
+        if raw is None:
+            raise RuntimeError(f"paired_raw_missing:{field}")
+
+        meta = {}
+        if "mask_last" in desc:
+            meta["mask_last"] = desc["mask_last"]
+
+        paired_values[field] = {"raw": raw, "alias": alias_name, "meta": meta}
+        logger.debug("Recorded paired raw for field %s", field)
+
+        persist_from_paired[field] = {"source": ("paired_values", field, "raw")}
+
+        generated.append(field)
+
+    if generated:
+        temp["generated_paired"] = tuple(generated)
+        logger.debug("Generated paired fields: %s", generated)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Internals
+# ──────────────────────────────────────────────────────────────────────────────
+
+
+def _ensure_dict(temp: MutableMapping[str, Any], key: str) -> Dict[str, Any]:
+    d = temp.get(key)
+    if not isinstance(d, dict):
+        d = {}
+        temp[key] = d
+    return d  # type: ignore[return-value]
+
+
+def _ctx_view(ctx: Any) -> Dict[str, Any]:
+    """Small read-only view for generator callables."""
+    return {
+        "op": getattr(ctx, "op", None),
+        "persist": getattr(ctx, "persist", True),
+        "temp": getattr(ctx, "temp", None),
+        "tenant": getattr(ctx, "tenant", None),
+        "user": getattr(ctx, "user", None),
+        "now": getattr(ctx, "now", None),
+    }
+
+
+def _secure_token(max_len: int) -> str:
+    """
+    Generate a URL-safe token. If max_len > 0, keep within that bound.
+    We aim for ~32 bytes entropy by default.
+    """
+    # 32 bytes → ~43 chars base64-url
+    token = secrets.token_urlsafe(32)
+    if max_len and max_len > 0 and len(token) > max_len:
+        # Trim conservatively; if extremely small, ensure we still return something.
+        token = token[: max(8, max_len)]
+    return token
+
+
+__all__ = ["ANCHOR", "run"]

tigrbl/runtime/atoms/response/__init__.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from typing import Any, Callable, Dict, Optional, Tuple
+
+from ... import events as _ev
+from .template import run as _template
+from .negotiate import run as _negotiate
+from .render import run as _render
+from . import headers_from_payload as _hdr_payload
+
+RunFn = Callable[[Optional[object], Any], Any]
+
+REGISTRY: Dict[Tuple[str, str], Tuple[str, RunFn]] = {
+    ("response", "template"): (_ev.OUT_DUMP, _template),
+    ("response", "negotiate"): (_ev.OUT_DUMP, _negotiate),
+    ("response", "headers_from_payload"): (_hdr_payload.ANCHOR, _hdr_payload.run),
+    ("response", "render"): (_ev.OUT_DUMP, _render),
+}
+
+__all__ = ["REGISTRY", "RunFn"]

tigrbl/runtime/atoms/response/headers_from_payload.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from ... import events as _ev
+from typing import Mapping
+
+ANCHOR = _ev.OUT_BUILD  # run after payload is prepared, before render
+
+
+def run(_, ctx) -> None:
+    """Mirror fields configured with ``io.header_out`` into HTTP response headers.
+
+    - Does NOT remove fields from the response body (no header-only behavior).
+    - Honors op-specific exposure via ``io.out_verbs``.
+    Complexity: O(#fields in opview).
+    """
+    from tigrbl.response import ResponseHints
+
+    resp = getattr(ctx, "response", None)
+    if resp is None:
+        return
+
+    hints = getattr(resp, "hints", None)
+    if hints is None:
+        hints = ResponseHints()
+        resp.hints = hints
+
+    payload = getattr(resp, "result", None)
+    if payload is None:
+        temp = getattr(ctx, "temp", None)
+        if isinstance(temp, Mapping):
+            payload = temp.get("response_payload")
+    if not isinstance(payload, dict):
+        return
+
+    specs = getattr(ctx, "specs", None)
+    if not isinstance(specs, Mapping):
+        model = getattr(ctx, "model", None)
+        specs = getattr(model, "__tigrbl_cols__", {}) if model is not None else {}
+
+    op = getattr(ctx, "op", None)
+    for field_name, spec in specs.items():
+        io = getattr(spec, "io", None)
+        if not io:
+            continue
+
+        header_name = getattr(io, "header_out", None)
+        if not header_name:
+            continue
+
+        out_verbs = set(getattr(io, "out_verbs", ()) or ())
+        if op not in out_verbs:
+            continue
+
+        if field_name in payload:
+            value = payload[field_name]
+            if value is not None:
+                hints.headers[header_name] = str(value)

tigrbl/runtime/atoms/response/negotiate.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from typing import Any, Optional
+
+from ... import events as _ev
+from .negotiation import negotiate_media_type
+from .renderer import ResponseHints
+
+ANCHOR = _ev.OUT_DUMP  # "out:dump"
+
+
+def run(obj: Optional[object], ctx: Any) -> None:
+    """response:negotiate@out:dump
+
+    Determine the response media type if not already set.
+    """
+    resp_ns = getattr(ctx, "response", None)
+    req = getattr(ctx, "request", None)
+    if resp_ns is None or req is None:
+        return
+    hints = getattr(resp_ns, "hints", None)
+    if hints is None:
+        hints = ResponseHints()
+        resp_ns.hints = hints
+    if not hints.media_type:
+        accept = getattr(req, "headers", {}).get("accept", "*/*")
+        default_media = getattr(resp_ns, "default_media", "application/json")
+        hints.media_type = negotiate_media_type(accept, default_media)
+
+
+__all__ = ["ANCHOR", "run"]

tigrbl/runtime/atoms/response/negotiation.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+from typing import List
+import logging
+
+
+def _parse(accept: str) -> List[str]:
+    parts = [p.strip() for p in accept.split(",") if p.strip()]
+
+    def q(p: str) -> float:
+        for seg in p.split(";"):
+            seg = seg.strip()
+            if seg.startswith("q="):
+                try:
+                    return float(seg[2:])
+                except Exception:
+                    return 1.0
+        return 1.0
+
+    return sorted(parts, key=q, reverse=True)
+
+
+logger = logging.getLogger("uvicorn")
+
+
+def negotiate_media_type(accept: str, default_media: str) -> str:
+    logger.debug("Negotiating media type from Accept header %s", accept)
+    if not accept or accept == "*/*":
+        return default_media
+    for cand in _parse(accept):
+        mt = cand.split(";")[0].strip()
+        if mt in (
+            "application/json",
+            "text/html",
+            "text/plain",
+            "application/octet-stream",
+        ):
+            return mt
+        if mt.startswith("text/"):
+            return "text/plain"
+    return default_media
+
+
+__all__ = ["negotiate_media_type"]

tigrbl/runtime/atoms/response/render.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+from typing import Any, Optional
+
+from ... import events as _ev
+from .renderer import render
+
+ANCHOR = _ev.OUT_DUMP  # "out:dump"
+
+
+def run(obj: Optional[object], ctx: Any) -> Any:
+    """response:render@out:dump
+
+    Render ``ctx.response.result`` into a concrete Response object.
+    """
+    resp_ns = getattr(ctx, "response", None)
+    req = getattr(ctx, "request", None)
+    if resp_ns is None or req is None:
+        return None
+    result = getattr(resp_ns, "result", None)
+    if result is None:
+        return None
+    hints = getattr(resp_ns, "hints", None)
+    default_media = getattr(resp_ns, "default_media", "application/json")
+    envelope_default = getattr(resp_ns, "envelope_default", False)
+    resp = render(
+        req,
+        result,
+        hints=hints,
+        default_media=default_media,
+        envelope_default=envelope_default,
+    )
+    resp_ns.result = resp
+    return resp
+
+
+__all__ = ["ANCHOR", "run"]