sourcecode 2.3.0__py3-none-any.whl → 2.5.0__py3-none-any.whl

sourcecode/retrieval/resolution.py

@@ -0,0 +1,135 @@
+"""IntentResolver — bind a request's raw anchors to STRUCTURED graph identities.
+
+Single responsibility (design §4.2): name/scope → structured identity. It plans
+nothing and executes nothing. Resolution uses structured indexes (`types_by_simple`,
+module ids, integration scheme vocabulary) — NEVER fuzzy text search. An anchor that
+cannot be bound is marked `unresolved`; the resolver never guesses.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Callable
+
+from sourcecode.retrieval.errors import UnknownIntentError
+from sourcecode.retrieval.request import RetrievalAnchor, RetrievalIntent, RetrievalRequest
+
+if TYPE_CHECKING:  # avoid importing the knowledge layer at module load
+    from sourcecode.retrieval.context import KnowledgeContext
+
+
+@dataclass(frozen=True)
+class ResolvedAnchor:
+    """A raw anchor bound to zero or more structured identities. Ambiguity is kept
+    (multiple identities), never silently collapsed."""
+
+    anchor: RetrievalAnchor
+    identities: tuple[str, ...]
+    unresolved_reason: str | None = None
+
+    @property
+    def resolved(self) -> bool:
+        return self.unresolved_reason is None and bool(self.identities)
+
+
+@dataclass(frozen=True)
+class ResolvedIntent:
+    """The intent plus its bound anchors, ready for planning."""
+
+    intent: RetrievalIntent
+    anchors: tuple[ResolvedAnchor, ...] = ()
+
+    @property
+    def fully_resolved(self) -> bool:
+        return all(a.resolved for a in self.anchors)
+
+
+class IntentResolver:
+    """Resolves a `RetrievalRequest` into a `ResolvedIntent`.
+
+    Per-intent strategies live in a registry so adding an intent adds a strategy
+    (often the trivial no-anchor one) without touching the resolver's core.
+    """
+
+    def __init__(self) -> None:
+        self._strategies: dict[
+            RetrievalIntent, Callable[[RetrievalRequest, "KnowledgeContext"], ResolvedIntent]
+        ] = {
+            # The archetype-dimension intents characterize the WHOLE repository — no
+            # anchor to bind. Both reuse the same (trivial) resolution strategy.
+            RetrievalIntent.ARCHITECTURAL_CORE: self._resolve_no_anchors,
+            RetrievalIntent.ARCHITECTURAL_STYLE: self._resolve_no_anchors,
+            RetrievalIntent.DEPLOYMENT_SHAPE: self._resolve_no_anchors,
+            RetrievalIntent.PRIMARY_INTERFACE: self._resolve_no_anchors,
+            # IMPACT pack: the blast engine does its own (legacy-identical) resolution of
+            # the target token, so anchors are passed through structurally (no text search,
+            # no premature ContextGraph build). ResolveTarget picks the target at runtime.
+            RetrievalIntent.BLAST_RADIUS: self._resolve_passthrough,
+            RetrievalIntent.AFFECTED_ENDPOINTS: self._resolve_passthrough,
+            RetrievalIntent.AFFECTED_INTEGRATIONS: self._resolve_passthrough,
+            RetrievalIntent.TRANSACTION_BOUNDARIES: self._resolve_passthrough,
+            RetrievalIntent.CROSS_MODULE_IMPACT: self._resolve_passthrough,
+            # TRANSACTIONS & SECURITY: whole-repo questions need no anchor; SECURITY_CHAIN
+            # scopes to a target symbol (passed through, resolved by the security engine).
+            RetrievalIntent.TRANSACTION_FLOW: self._resolve_no_anchors,
+            RetrievalIntent.TRANSACTION_ENTRYPOINTS: self._resolve_no_anchors,
+            RetrievalIntent.TRANSACTION_PROPAGATION: self._resolve_no_anchors,
+            RetrievalIntent.SECURITY_SURFACE: self._resolve_no_anchors,
+            RetrievalIntent.SECURITY_CHAIN: self._resolve_passthrough,
+            RetrievalIntent.VALIDATION_POINTS: self._resolve_no_anchors,
+            # INTERFACES & INTEGRATIONS: whole-repo inventories, no anchor to bind.
+            RetrievalIntent.ENDPOINT_INVENTORY: self._resolve_no_anchors,
+            RetrievalIntent.INTEGRATION_INVENTORY: self._resolve_no_anchors,
+            RetrievalIntent.EVENT_TOPOLOGY: self._resolve_no_anchors,
+            # SUBSYSTEMS & DEPENDENCIES: inventory is whole-repo; the scoped intents pass
+            # their subsystem/module/package anchor through (matched structurally by the
+            # projection step against the partition / graph node ids).
+            RetrievalIntent.SUBSYSTEM_INVENTORY: self._resolve_no_anchors,
+            RetrievalIntent.SUBSYSTEM_MEMBERS: self._resolve_passthrough,
+            RetrievalIntent.MODULE_DEPENDENTS: self._resolve_passthrough,
+            RetrievalIntent.MODULE_DEPENDENCIES: self._resolve_passthrough,
+            RetrievalIntent.TYPE_DEPENDENTS: self._resolve_passthrough,
+            # ENDPOINT & CALL deep-dive: all anchored (endpoint / path / symbol), passed
+            # through and matched structurally by the projection step.
+            RetrievalIntent.ENDPOINT_CONTRACT: self._resolve_passthrough,
+            RetrievalIntent.ENDPOINT_SECURITY: self._resolve_passthrough,
+            RetrievalIntent.CALL_NEIGHBORHOOD: self._resolve_passthrough,
+            # GRAPH-analysis: the two path/reachability intents pass their symbol through;
+            # subsystem-coupling is whole-repo (no anchor).
+            RetrievalIntent.EXECUTION_PATHS_THROUGH: self._resolve_passthrough,
+            RetrievalIntent.TRANSACTIONS_REACHING: self._resolve_passthrough,
+            RetrievalIntent.SUBSYSTEM_COUPLING: self._resolve_no_anchors,
+        }
+
+    def resolve(self, request: RetrievalRequest, ctx: "KnowledgeContext") -> ResolvedIntent:
+        strategy = self._strategies.get(request.intent)
+        if strategy is None:
+            raise UnknownIntentError(f"no resolver strategy for intent {request.intent!r}")
+        return strategy(request, ctx)
+
+    # ── strategies ─────────────────────────────────────────────────────────────
+    @staticmethod
+    def _resolve_no_anchors(
+        request: RetrievalRequest, ctx: "KnowledgeContext"
+    ) -> ResolvedIntent:
+        return ResolvedIntent(request.intent, ())
+
+    @staticmethod
+    def _resolve_passthrough(
+        request: RetrievalRequest, ctx: "KnowledgeContext"
+    ) -> ResolvedIntent:
+        """Bind each anchor to its own raw token as the identity (structural passthrough).
+        No fuzzy search, no guessing; the downstream engine resolves the token."""
+        return ResolvedIntent(
+            request.intent,
+            tuple(ResolvedAnchor(a, (a.raw,)) for a in request.anchors),
+        )
+
+    # ── structured binding helpers (for future anchored intents) ────────────────
+    # Kept here to fix the ONE sanctioned resolution mechanism: a structured index
+    # lookup, never a text scan. Not exercised by the first (anchor-free) intent.
+    @staticmethod
+    def _bind_symbol(anchor: RetrievalAnchor, ctx: "KnowledgeContext") -> ResolvedAnchor:
+        fqns = tuple(sorted(ctx.services.types_by_simple().get(anchor.raw, ())))
+        if not fqns:
+            return ResolvedAnchor(anchor, (), unresolved_reason=f"unknown symbol {anchor.raw!r}")
+        return ResolvedAnchor(anchor, fqns)

sourcecode/retrieval/result.py

@@ -0,0 +1,144 @@
+"""KnowledgeResult and its typed parts (design §4.6, §5.3).
+
+Everything the engine returns is **structured** — no prose, no generated natural
+language. The one free-text field, `Explanation.engine_explanation`, is passed through
+VERBATIM from the reused engine; the retriever synthesizes no sentences of its own.
+Every object is JSON-serializable via `to_dict()`.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class RetrievalEvidence:
+    """Structured evidence for a result, mirroring the ADR-0003 evidence contract
+    (signal / weight / strength / mass / contribution). It CAN carry a
+    ``source_file:line`` grounding when the backing fact is span-anchored; for the
+    archetype signals it is ``None`` (they are mass-derived, not span-anchored)."""
+
+    signal: str
+    detail: str
+    weight: float
+    strength: float
+    mass: float
+    contribution: float
+    provider: str
+    source_file: str | None = None
+    source_line: int | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "signal": self.signal,
+            "detail": self.detail,
+            "weight": self.weight,
+            "strength": round(self.strength, 3),
+            "mass": round(self.mass, 4),
+            "contribution": round(self.contribution, 4),
+            "provider": self.provider,
+            "source_file": self.source_file,
+            "source_line": self.source_line,
+        }
+
+
+@dataclass(frozen=True)
+class KnowledgeEntity:
+    """One structured hit. `identity` is a graph identity (label / FQN / id), never
+    prose; `attributes` carries structured extras."""
+
+    identity: str
+    kind: str
+    score: float
+    attributes: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "identity": self.identity,
+            "kind": self.kind,
+            "score": round(self.score, 4),
+            "attributes": self.attributes,
+        }
+
+
+@dataclass(frozen=True)
+class Observation:
+    """A structured, named measurement reused from a Knowledge-Layer provider
+    (e.g. a module-graph topology metric). Not a hit; supporting context."""
+
+    name: str
+    value: Any
+    detail: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"name": self.name, "value": self.value, "detail": self.detail}
+
+
+@dataclass(frozen=True)
+class Provenance:
+    """Which existing capabilities produced this result, and what knowledge state
+    backed it. Makes every answer auditable back to the reused engines."""
+
+    services: tuple[str, ...]
+    signals_used: tuple[str, ...]
+    signals_missing: tuple[str, ...]
+    knowledge_source: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "services": list(self.services),
+            "signals_used": list(self.signals_used),
+            "signals_missing": list(self.signals_missing),
+            "knowledge_source": self.knowledge_source,
+        }
+
+
+@dataclass(frozen=True)
+class Explanation:
+    """Structured, machine-readable rationale. `engine_explanation` is verbatim from
+    the reused engine — the retriever generates NO natural language of its own."""
+
+    winner: str | None
+    score: float
+    confidence: str
+    top_contributions: tuple[tuple[str, float], ...]
+    runner_up: str | None
+    engine_explanation: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "winner": self.winner,
+            "score": round(self.score, 4),
+            "confidence": self.confidence,
+            "top_contributions": [
+                {"signal": s, "contribution": round(c, 4)} for s, c in self.top_contributions
+            ],
+            "runner_up": self.runner_up,
+            "engine_explanation": self.engine_explanation,
+        }
+
+
+@dataclass(frozen=True)
+class KnowledgeResult:
+    """The typed answer to a `RetrievalRequest`. Fully structured; no prose."""
+
+    intent: str
+    entities: tuple[KnowledgeEntity, ...]
+    evidence: tuple[RetrievalEvidence, ...]
+    confidence: str
+    observations: tuple[Observation, ...]
+    explanation: Explanation
+    provenance: Provenance
+    query: tuple[str, ...]  # executed plan, as step names (traceability)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "intent": self.intent,
+            "entities": [e.to_dict() for e in self.entities],
+            "evidence": [e.to_dict() for e in self.evidence],
+            "confidence": self.confidence,
+            "observations": [o.to_dict() for o in self.observations],
+            "explanation": self.explanation.to_dict(),
+            "provenance": self.provenance.to_dict(),
+            "query": list(self.query),
+        }

sourcecode/retrieval/retriever.py

@@ -0,0 +1,62 @@
+"""SemanticRetriever — the façade / orchestrator (design §4.1).
+
+The single public entry point. It wires `IntentResolver → QueryPlanner →
+KnowledgeExecutor` over a `KnowledgeContext` and returns a typed `KnowledgeResult`. It
+performs NO graph logic itself — it is composition only, so consumers depend on one
+stable surface and never on the internal stages.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from sourcecode.retrieval.context import KnowledgeContext
+from sourcecode.retrieval.executor import KnowledgeExecutor
+from sourcecode.retrieval.planner import QueryPlanner
+from sourcecode.retrieval.query import KnowledgeQuery
+from sourcecode.retrieval.request import RetrievalRequest
+from sourcecode.retrieval.resolution import IntentResolver
+from sourcecode.retrieval.result import KnowledgeResult
+from sourcecode.retrieval.runtime import RuntimeResult
+
+
+class SemanticRetriever:
+    """Orchestrates the retrieval pipeline over a bundle of already-built knowledge."""
+
+    def __init__(
+        self,
+        context: KnowledgeContext,
+        *,
+        resolver: IntentResolver | None = None,
+        planner: QueryPlanner | None = None,
+        executor: KnowledgeExecutor | None = None,
+    ) -> None:
+        self._ctx = context
+        self._resolver = resolver or IntentResolver()
+        self._planner = planner or QueryPlanner()
+        self._executor = executor or KnowledgeExecutor()
+
+    @classmethod
+    def for_repo(cls, root: Path) -> "SemanticRetriever":
+        """Convenience constructor: acquire existing knowledge for `root` (the
+        acquisition boundary in `KnowledgeContext.for_repo`) and wire the pipeline."""
+        return cls(KnowledgeContext.for_repo(Path(root)))
+
+    @property
+    def context(self) -> KnowledgeContext:
+        return self._ctx
+
+    def plan(self, request: RetrievalRequest) -> KnowledgeQuery:
+        """Resolve + plan WITHOUT executing — for explaining "which plan would run"."""
+        resolved = self._resolver.resolve(request, self._ctx)
+        return self._planner.plan(resolved)
+
+    def retrieve(self, request: RetrievalRequest) -> KnowledgeResult:
+        """Run the full pipeline and return the typed result."""
+        return self.run(request).result
+
+    def run(self, request: RetrievalRequest) -> RuntimeResult:
+        """Run the full pipeline and return the typed result plus the execution report
+        (per-step trace + profiling + Knowledge-Cache status)."""
+        resolved = self._resolver.resolve(request, self._ctx)
+        query = self._planner.plan(resolved)
+        return self._executor.run(query, self._ctx, resolved, request.options)

sourcecode/retrieval/runtime.py

@@ -0,0 +1,259 @@
+"""Query Plan Runtime — the engine that executes ANY plan of registered Steps.
+
+This is the definitive Semantic Retrieval infrastructure. It is **generic**: it knows how
+to sequence steps, thread a shared execution context, pass results between steps, time and
+trace each step, and surface errors — and it knows **nothing** about any specific intent.
+All execution logic lives in registered step **handlers** (`steps.py`); intents are
+declarative plans (`planner.py`). Consequently:
+
+    Adding a new RetrievalIntent = declaring a new QueryPlan. The Runtime is NOT modified.
+
+Responsibilities delivered here (design §4.5, Fase 4):
+* sequential execution of a plan's steps;
+* a shared `StepContext` (knowledge handles + a blackboard for inter-step results);
+* result passing between steps via the blackboard;
+* error handling (typed, with the failing step captured);
+* traceability (an ordered `StepTrace` per step);
+* profiling (per-step + total wall time);
+* Knowledge-Cache reuse (the single `KnowledgeContext` is shared across every step, so
+  the cached CIR / SourceMap is acquired at most once — no new cache is introduced).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from time import perf_counter
+from typing import Any, Callable, Optional, TYPE_CHECKING
+
+from sourcecode.retrieval.context import KnowledgeContext
+from sourcecode.retrieval.errors import (
+    IncompletePlanError,
+    RetrievalError,
+    StepContractError,
+    StepExecutionError,
+    UnknownStepError,
+)
+from sourcecode.retrieval.query import KnowledgeQuery, Step
+from sourcecode.retrieval.request import RetrievalIntent, RetrievalOptions
+
+if TYPE_CHECKING:
+    from sourcecode.retrieval.resolution import ResolvedAnchor, ResolvedIntent
+    from sourcecode.retrieval.result import KnowledgeResult
+
+# A step handler is a pure procedure over (step, context). It reads/writes the shared
+# blackboard and (for the terminal step) sets the context result. It returns nothing.
+StepHandler = Callable[[Step, "StepContext"], None]
+
+
+# ── shared execution context ─────────────────────────────────────────────────────
+class StepContext:
+    """The execution scope threaded across every step of one plan run.
+
+    * `knowledge` — read-only handles to already-built knowledge (shared → cache reuse).
+    * `anchors` — the request's resolved anchors, so anchored intents reach their target.
+    * blackboard — a keyed store steps use to pass intermediate results to later steps.
+    * `result` — the terminal `KnowledgeResult`, set by the BuildResult step.
+    * `trace` — accumulated per-step traces.
+    """
+
+    def __init__(
+        self,
+        knowledge: KnowledgeContext,
+        intent: RetrievalIntent,
+        resolved: "Optional[ResolvedIntent]" = None,
+        options: "Optional[RetrievalOptions]" = None,
+    ) -> None:
+        self.knowledge = knowledge
+        self.intent = intent
+        self._resolved = resolved
+        self.options = options or RetrievalOptions()
+        self._slots: dict[str, Any] = {}
+        self._result: "Optional[KnowledgeResult]" = None
+        self.trace: list["StepTrace"] = []
+
+    @property
+    def anchors(self) -> "tuple[ResolvedAnchor, ...]":
+        """The request's resolved anchors (empty for anchor-free intents)."""
+        return self._resolved.anchors if self._resolved is not None else ()
+
+    # blackboard ------------------------------------------------------------------
+    def put(self, key: str, value: Any) -> None:
+        self._slots[key] = value
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._slots.get(key, default)
+
+    def has(self, key: str) -> bool:
+        return key in self._slots
+
+    def require(self, key: str) -> Any:
+        """Fetch a slot a prior step must have produced; a missing slot is a plan
+        ordering fault, not a runtime bug."""
+        if key not in self._slots:
+            raise StepContractError(f"step requires slot {key!r} which no prior step produced")
+        return self._slots[key]
+
+    # terminal result -------------------------------------------------------------
+    def set_result(self, result: "KnowledgeResult") -> None:
+        self._result = result
+
+    @property
+    def result(self) -> "Optional[KnowledgeResult]":
+        return self._result
+
+
+# ── trace / profiling ────────────────────────────────────────────────────────────
+@dataclass(frozen=True)
+class StepTrace:
+    """One executed step's record: identity, params, status, wall time, error (if any)."""
+
+    index: int
+    kind: str
+    step: str  # Python class name
+    params: dict[str, Any]
+    status: str  # "ok" | "error"
+    duration_ms: float
+    error: Optional[str] = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "index": self.index,
+            "kind": self.kind,
+            "step": self.step,
+            "params": self.params,
+            "status": self.status,
+            "duration_ms": round(self.duration_ms, 3),
+            "error": self.error,
+        }
+
+
+@dataclass(frozen=True)
+class RuntimeReport:
+    """Inspectable execution report: the plan, per-step traces, totals, cache status, and
+    the knowledge-acquisition timings (B2)."""
+
+    intent: str
+    plan: tuple[str, ...]
+    steps: tuple[StepTrace, ...]
+    total_ms: float
+    knowledge_source: str  # Knowledge-Cache status (HIT/MISS/disabled/not-acquired)
+    acquisitions: tuple[tuple[str, float], ...] = ()  # (name, ms) lazy acquisitions
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "intent": self.intent,
+            "plan": list(self.plan),
+            "steps": [s.to_dict() for s in self.steps],
+            "total_ms": round(self.total_ms, 3),
+            "knowledge_source": self.knowledge_source,
+            "acquisitions": [
+                {"name": n, "ms": round(ms, 3)} for n, ms in self.acquisitions
+            ],
+            "acquisition_ms": round(sum(ms for _, ms in self.acquisitions), 3),
+        }
+
+
+@dataclass(frozen=True)
+class RuntimeResult:
+    """A run's output: the typed result plus the execution report."""
+
+    result: "KnowledgeResult"
+    report: RuntimeReport
+
+
+# ── step registry ────────────────────────────────────────────────────────────────
+class StepRegistry:
+    """Maps a step `kind` to its handler. The ONLY place execution logic is bound to a
+    step. New capabilities register a handler here; plans then reference the kind."""
+
+    def __init__(self) -> None:
+        self._handlers: dict[str, StepHandler] = {}
+
+    def register(self, kind: str, handler: StepHandler) -> None:
+        if kind in self._handlers:
+            raise ValueError(f"step kind {kind!r} already registered")
+        self._handlers[kind] = handler
+
+    def handler_for(self, step: Step) -> StepHandler:
+        handler = self._handlers.get(step.kind)
+        if handler is None:
+            raise UnknownStepError(f"no handler registered for step kind {step.kind!r}")
+        return handler
+
+    def kinds(self) -> frozenset[str]:
+        return frozenset(self._handlers)
+
+
+# ── the runtime ──────────────────────────────────────────────────────────────────
+class QueryPlanRuntime:
+    """Executes any `KnowledgeQuery` composed of registered steps."""
+
+    def __init__(self, registry: Optional[StepRegistry] = None) -> None:
+        if registry is None:
+            # Lazy import to avoid a cycle (steps import the result/context types).
+            from sourcecode.retrieval.steps import default_registry
+
+            registry = default_registry()
+        self._registry = registry
+
+    @property
+    def registry(self) -> StepRegistry:
+        return self._registry
+
+    def run(
+        self,
+        query: KnowledgeQuery,
+        knowledge: KnowledgeContext,
+        resolved: "Optional[ResolvedIntent]" = None,
+        options: "Optional[RetrievalOptions]" = None,
+    ) -> RuntimeResult:
+        # `resolved` carries the request's bound anchors so anchored intents (the whole
+        # IMPACT pack) can reach their target; `options` carries the request's presentation
+        # knobs (e.g. `limit`, applied by the terminal BuildResult). Both are additive and
+        # optional — anchor-free / default-option requests pass None and behave exactly as
+        # before. Neither changes execution semantics (sequence/trace/profiling).
+        ctx = StepContext(knowledge, query.intent, resolved, options)
+        t0 = perf_counter()
+        for index, step in enumerate(query.steps):
+            handler = self._registry.handler_for(step)  # UnknownStepError propagates (plan fault)
+            s0 = perf_counter()
+            try:
+                handler(step, ctx)
+            except RetrievalError as exc:  # typed fault (e.g. bad slot/dimension) — keep as-is
+                self._record(ctx, index, step, s0, status="error", error=repr(exc))
+                raise
+            except Exception as exc:  # unexpected fault — wrap, but preserve the trace
+                self._record(ctx, index, step, s0, status="error", error=repr(exc))
+                raise StepExecutionError(
+                    f"step {type(step).__name__} ({step.kind}) failed: {exc!r}"
+                ) from exc
+            self._record(ctx, index, step, s0, status="ok", error=None)
+        total_ms = (perf_counter() - t0) * 1000.0
+
+        if ctx.result is None:
+            raise IncompletePlanError("plan finished without producing a result (no BuildResult step)")
+
+        report = RuntimeReport(
+            intent=query.intent.value,
+            plan=query.describe(),
+            steps=tuple(ctx.trace),
+            total_ms=total_ms,
+            knowledge_source=knowledge.cache_render,
+            acquisitions=knowledge.acquisitions,  # B2: intent-agnostic infra timings
+        )
+        return RuntimeResult(result=ctx.result, report=report)
+
+    @staticmethod
+    def _record(
+        ctx: StepContext, index: int, step: Step, s0: float, *, status: str, error: Optional[str]
+    ) -> None:
+        ctx.trace.append(
+            StepTrace(
+                index=index,
+                kind=step.kind,
+                step=type(step).__name__,
+                params=step.params(),
+                status=status,
+                duration_ms=(perf_counter() - s0) * 1000.0,
+                error=error,
+            )
+        )