katalyst-plugin-context 0.1.1a1__py3-none-any.whl

katalyst_plugin_context/domain/context.py

@@ -0,0 +1,762 @@
+"""The context of one node: the map around it, and the items an agent asks for.
+
+Pure: it walks a :class:`~katalyst_plugin_context.domain.graph.Graph` under a
+:class:`~katalyst_plugin_context.domain.policy.Policy`, and asks a :class:`Schema` what each
+kind declares. The graph, the policy and the schema are built by the service per call.
+Nothing here names a kind, a relationship or a field.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import Any, Protocol
+
+from katalyst_plugin_context.domain.graph import Graph, GraphNode
+from katalyst_plugin_context.domain.paths import OUT, Step, parse_path, path_text
+from katalyst_plugin_context.domain.policy import DETAIL_LEVELS, FULL, REFS, SUMMARY, Policy
+from katalyst_plugin_context.domain.settings import ItemHints, View
+
+__all__ = [
+    "ContextError",
+    "ContextRequest",
+    "Schema",
+    "build_map",
+    "build_result",
+    "estimate_tokens",
+]
+
+#: How much of a description ``summary`` shows, and of each summary field's value.
+DESCRIPTION_LIMIT = 300
+FIELD_LIMIT = 120
+#: At most this many arrivals per walk: a bound on a pathological fan-out, far above any budget.
+WALK_LIMIT = 5000
+#: At most this many qualified names per group in the "what was cut" report.
+CUT_NAMES = 20
+
+_SCALARS = ("string", "integer", "number", "boolean")
+
+
+class ContextError(Exception):
+    """A request that cannot be answered: ``code`` is the envelope's error code."""
+
+    def __init__(self, code: str, message: str, details: Mapping[str, Any] | None = None) -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.details = dict(details or {})
+
+
+class Schema(Protocol):
+    """What the context needs to know about kinds and relationships."""
+
+    parent_rel: str
+
+    def kind_label(self, kind: str) -> str: ...
+    def hints(self, kind: str) -> ItemHints: ...
+    def declared_fields(self, kind: str) -> Sequence[tuple[str, str]]: ...
+    def blocking(self, kind: str, spec: Mapping[str, Any]) -> list[dict[str, Any]]: ...
+    def relationship_description(self, rel: str) -> str: ...
+    def carried(self, kind: str) -> Sequence[tuple[str, frozenset[str]]]: ...
+
+
+@dataclass(frozen=True, slots=True)
+class ContextRequest:
+    """What an agent asks for. ``None`` means "per policy"."""
+
+    paths: tuple[str, ...] | None = None
+    views: tuple[str, ...] | None = None
+    depth: int | None = None
+    detail: str | None = None
+    budget: int | None = None
+    inherit: bool | None = None
+    format: str = "json"
+
+    @property
+    def names_nothing(self) -> bool:
+        return not self.paths and not self.views
+
+    def as_payload(self) -> dict[str, Any]:
+        return {
+            "paths": list(self.paths) if self.paths is not None else None,
+            "views": list(self.views) if self.views is not None else None,
+            "depth": self.depth,
+            "detail": self.detail,
+            "budget": self.budget,
+            "inherit": self.inherit,
+        }
+
+
+def estimate_tokens(text: str) -> int:
+    """Approximate tokens: a quarter of the characters, rounded up."""
+    return math.ceil(len(text) / 4)
+
+
+# ── walking ──────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True, slots=True)
+class _Hop:
+    source: str
+    rel: str
+    direction: str
+    target: str
+
+
+@dataclass(frozen=True, slots=True)
+class _Arrival:
+    key: str
+    start: str
+    hops: tuple[_Hop, ...]
+
+
+def _walk(
+    graph: Graph,
+    start: str,
+    steps: Sequence[Step],
+    policy: Policy,
+    *,
+    exclude: frozenset[str],
+    inherited: bool,
+    parent_rel: str,
+    collect_every_level: bool,
+) -> list[_Arrival]:
+    """Every node reached from *start* by following *steps*, with the hops that reached it.
+
+    A node never appears twice on one branch (cycles stop). *exclude* (the focus node and
+    its ancestors) is never reached. From an ancestor, its structural parent edges are
+    never followed: they would only reach siblings.
+    """
+    frontier: list[tuple[str, tuple[_Hop, ...]]] = [(start, ())]
+    arrivals: list[_Arrival] = []
+    for index, step in enumerate(steps):
+        nxt: list[tuple[str, tuple[_Hop, ...]]] = []
+        for current, hops in frontier:
+            on_branch = {start, *(h.target for h in hops)}
+            for neighbour in graph.neighbours(current):
+                if inherited and index == 0 and neighbour.rel == parent_rel:
+                    continue
+                other = graph.nodes[neighbour.other]
+                if neighbour.other in exclude or neighbour.other in on_branch:
+                    continue
+                if not step.matches(neighbour.rel, neighbour.direction, other.kind):
+                    continue
+                if not policy.visible(neighbour.rel, neighbour.direction, other.kind):
+                    continue
+                hop = _Hop(current, neighbour.rel, neighbour.direction, neighbour.other)
+                nxt.append((neighbour.other, (*hops, hop)))
+                if len(nxt) + len(arrivals) > WALK_LIMIT:
+                    break
+        frontier = nxt
+        if collect_every_level or index == len(steps) - 1:
+            arrivals.extend(_Arrival(key, start, hops) for key, hops in frontier)
+        if not frontier:
+            break
+    return arrivals
+
+
+# ── items ────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class _Entry:
+    node: GraphNode
+    rank: tuple[Any, ...]
+    view: str | None
+    path: str
+    detail: str
+    inherited_from: str | None
+    depth: int
+    whys: list[tuple[tuple[Any, ...], _Arrival, str]] = field(
+        default_factory=lambda: list[tuple[tuple[Any, ...], _Arrival, str]]()
+    )
+    blocking: list[dict[str, Any]] = field(default_factory=lambda: list[dict[str, Any]]())
+
+
+@dataclass(frozen=True, slots=True)
+class _Source:
+    """One thing walked: a view's path, an asked path, or the exploration."""
+
+    section: int
+    view: View | None
+    steps: tuple[Step, ...]
+    path_index: int
+    detail: str
+    inherit: bool
+    repeat: int
+    """For a single step, how many times to follow it; else 1."""
+
+
+def _label(graph: Graph, schema: Schema, key: str) -> str:
+    node = graph.nodes[key]
+    return f"{node.kind} {key}"
+
+
+def _why_payload(graph: Graph, schema: Schema, arrival: _Arrival, focus: str) -> dict[str, Any]:
+    inherited = arrival.start != focus
+    words: list[str] = []
+    if inherited:
+        words.append(_label(graph, schema, arrival.start))
+    for i, hop in enumerate(arrival.hops):
+        arrow = f"─{hop.rel}→" if hop.direction == OUT else f"←{hop.rel}─"
+        words.append(arrow)
+        if i < len(arrival.hops) - 1:
+            words.append(_label(graph, schema, hop.target))
+    if inherited:
+        words.append("(inherited)")
+    return {
+        "path": "/".join(f"{h.rel}:{h.direction}" for h in arrival.hops),
+        "from": arrival.start,
+        "inherited": inherited,
+        "hops": [
+            {"from": h.source, "rel": h.rel, "dir": h.direction, "to": h.target}
+            for h in arrival.hops
+        ],
+        "text": " ".join(words),
+    }
+
+
+def _shorten(text: str, limit: int) -> str:
+    if len(text) <= limit:
+        return text
+    cut = text[:limit]
+    end = max(cut.rfind(". "), cut.rfind(".\n"))
+    if end >= limit // 2:
+        return cut[: end + 1]
+    return cut.rstrip() + "…"
+
+
+def _scalar(value: object) -> bool:
+    return isinstance(value, (str, int, float, bool))
+
+
+def _title(node: GraphNode, hints: ItemHints) -> str:
+    if hints.title_field:
+        value = node.spec.get(hints.title_field)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return node.name
+
+
+def _item_payload(
+    entry: _Entry, level: str, graph: Graph, schema: Schema, focus: str
+) -> dict[str, Any]:
+    node = entry.node
+    hints = schema.hints(node.kind)
+    whys = sorted(entry.whys, key=lambda w: w[0])
+    payload: dict[str, Any] = {
+        "qualifiedName": node.key,
+        "kind": node.kind,
+        "title": _title(node, hints),
+        "view": entry.view,
+        "path": entry.path,
+        "depth": entry.depth,
+        "inheritedFrom": entry.inherited_from,
+        "detail": level,
+        "why": [_why_payload(graph, schema, arrival, focus) for _, arrival, _ in whys],
+        "blocking": (entry.blocking[0] if len(entry.blocking) == 1 else (entry.blocking or None)),
+    }
+    if level in (SUMMARY, FULL):
+        description = node.description or ""
+        payload["description"] = (
+            description if level == FULL else _shorten(description, DESCRIPTION_LIMIT)
+        )
+        payload["descriptionLength"] = len(description)
+        declared = schema.declared_fields(node.kind)
+        wanted = hints.summary_fields
+        fields: dict[str, Any] = {}
+        for name, field_type in declared:
+            if wanted is not None and name not in wanted:
+                continue
+            if wanted is None and field_type not in _SCALARS:
+                continue
+            value = node.spec.get(name)
+            if value is None or (hints.title_field and name == hints.title_field):
+                continue
+            if _scalar(value):
+                fields[name] = _shorten(value, FIELD_LIMIT) if isinstance(value, str) else value
+            elif level == FULL or wanted is not None:
+                fields[name] = value
+        payload["fields"] = fields
+    if level == FULL:
+        payload["spec"] = {
+            name: node.spec[name]
+            for name, _ in schema.declared_fields(node.kind)
+            if name in node.spec
+        }
+        payload["body"] = node.body
+    return payload
+
+
+def _lower(level: str) -> list[str]:
+    """*level* and every level below it, highest first."""
+    return list(reversed(DETAIL_LEVELS[: DETAIL_LEVELS.index(level) + 1]))
+
+
+# ── markdown sizes (shared with the renderer) ───────────────────────────
+
+
+SizeOf = Callable[[dict[str, Any]], int]
+
+
+def json_size(item: dict[str, Any]) -> int:
+    return estimate_tokens(json.dumps(item, separators=(",", ":"), default=str))
+
+
+# ── the result ───────────────────────────────────────────────────────────
+
+
+def _sources(
+    request: ContextRequest,
+    policy: Policy,
+    views: Mapping[str, View],
+    *,
+    always: Sequence[str],
+    depth: int,
+    detail_for: Callable[[str | None], str],
+    inherit: bool,
+    refused: list[dict[str, Any]],
+    notes: list[dict[str, Any]],
+) -> list[_Source]:
+    sources: list[_Source] = []
+
+    def add_view(view: View, section: int) -> None:
+        for index, steps in enumerate(view.paths):
+            hidden = next(
+                (by for by in (policy.step_hidden_by(s) for s in steps) if by is not None), None
+            )
+            if hidden is not None:
+                notes.append(
+                    {
+                        "view": view.name,
+                        "path": path_text(steps),
+                        "limitedBy": hidden,
+                        "text": f"view {view.name!r} path {path_text(steps)!r} is hidden by {hidden}",
+                    }
+                )
+                continue
+            if len(steps) > policy.max_depth:
+                notes.append(
+                    {
+                        "view": view.name,
+                        "path": path_text(steps),
+                        "limitedBy": policy.max_depth_by,
+                        "text": f"view {view.name!r} path {path_text(steps)!r} is longer than "
+                        f"max_depth {policy.max_depth} ({policy.max_depth_by})",
+                    }
+                )
+                steps = steps[: policy.max_depth]
+                if not steps:
+                    continue
+            sources.append(
+                _Source(
+                    section=section,
+                    view=view,
+                    steps=steps,
+                    path_index=index,
+                    detail=detail_for(request.detail or view.detail),
+                    inherit=view.inherit and inherit,
+                    repeat=1,
+                )
+            )
+
+    if request.names_nothing:
+        for name in sorted(always, key=lambda n: -views[n].priority):
+            add_view(views[name], 0)
+        if not sources and not always:
+            sources.append(
+                _Source(3, None, (Step("*"),), 0, detail_for(request.detail), inherit, depth)
+            )
+        return sources
+    for name in sorted(request.views or (), key=lambda n: -views[n].priority):
+        add_view(views[name], 1)
+    for index, text in enumerate(request.paths or ()):
+        steps = parse_path(text)
+        hidden = next(
+            (by for by in (policy.step_hidden_by(s) for s in steps) if by is not None), None
+        )
+        if hidden is not None:
+            refused.append(
+                {"path": text, "limitedBy": hidden, "text": f"{text!r} is hidden by {hidden}"}
+            )
+            continue
+        if len(steps) > policy.max_depth:
+            refused.append(
+                {
+                    "path": text,
+                    "limitedBy": policy.max_depth_by,
+                    "text": f"{text!r} is longer than max_depth {policy.max_depth} "
+                    f"({policy.max_depth_by})",
+                }
+            )
+            continue
+        sources.append(
+            _Source(
+                2,
+                None,
+                steps,
+                index,
+                detail_for(request.detail),
+                inherit,
+                depth if len(steps) == 1 else 1,
+            )
+        )
+    return sources
+
+
+def _collect(
+    graph: Graph,
+    schema: Schema,
+    focus: str,
+    ancestors: Sequence[str],
+    policy: Policy,
+    sources: Sequence[_Source],
+) -> tuple[dict[str, _Entry], list[dict[str, Any]]]:
+    entries: dict[str, _Entry] = {}
+    exclude = frozenset({focus, *ancestors})
+    group_members: dict[tuple[str | None, str], set[str]] = {}
+    for source in sources:
+        starts = [focus, *(ancestors if source.inherit else ())]
+        steps = source.steps * source.repeat if source.repeat > 1 else source.steps
+        text = path_text(source.steps)
+        group = group_members.setdefault((source.view.name if source.view else None, text), set())
+        for distance, start in enumerate(starts):
+            arrivals = _walk(
+                graph,
+                start,
+                steps,
+                policy,
+                exclude=exclude,
+                inherited=start != focus,
+                parent_rel=schema.parent_rel,
+                collect_every_level=source.repeat > 1,
+            )
+            for arrival in arrivals:
+                node = graph.nodes[arrival.key]
+                hints = schema.hints(node.kind)
+                blocking = schema.blocking(node.kind, node.spec)
+                view_priority = source.view.priority if source.view else 0
+                blocking_rank = (
+                    (0 if any(b.get("blocking") for b in blocking) else 1)
+                    if source.view is not None and source.view.blocking_first
+                    else 0
+                )
+                rank = (
+                    source.section,
+                    -view_priority,
+                    source.view.name if source.view else "",
+                    blocking_rank,
+                    source.path_index,
+                    distance,
+                    len(arrival.hops),
+                    -hints.priority,
+                    node.key,
+                )
+                group.add(node.key)
+                entry = entries.get(node.key)
+                if entry is None or rank < entry.rank:
+                    previous = entry.whys if entry is not None else []
+                    entry = _Entry(
+                        node=node,
+                        rank=rank,
+                        view=source.view.name if source.view else None,
+                        path=text,
+                        detail=source.detail,
+                        inherited_from=None if start == focus else start,
+                        depth=len(arrival.hops),
+                        whys=previous,
+                        blocking=blocking,
+                    )
+                    entries[node.key] = entry
+                if not any(w[1].hops == arrival.hops for w in entry.whys):
+                    entry.whys.append((rank, arrival, text))
+    groups = [
+        {"view": view, "path": path, "count": len(members)}
+        for (view, path), members in group_members.items()
+    ]
+    return entries, groups
+
+
+def build_result(
+    graph: Graph,
+    schema: Schema,
+    focus: str,
+    policy: Policy,
+    views: Mapping[str, View],
+    request: ContextRequest,
+    *,
+    size_of: SizeOf = json_size,
+) -> dict[str, Any]:
+    """The items *request* asks for around *focus*, budgeted, with why each is here."""
+    unknown = [name for name in request.views or () if name not in views]
+    if unknown:
+        raise ContextError(
+            "INVALID_INPUT",
+            f"{graph.nodes[focus].kind} has no view {unknown[0]!r}; it has: "
+            + (", ".join(sorted(views)) or "none"),
+            {"views": sorted(views)},
+        )
+    if request.detail is not None and request.detail not in DETAIL_LEVELS:
+        raise ContextError(
+            "INVALID_INPUT",
+            f"detail must be one of {', '.join(DETAIL_LEVELS)}; got {request.detail!r}",
+        )
+    clamped: list[dict[str, Any]] = []
+    refused: list[dict[str, Any]] = []
+    notes = list(policy.notes)
+    depth, note = policy.clamp_depth(request.depth)
+    clamped.extend([note] if note else [])
+    budget, note = policy.clamp_budget(request.budget)
+    clamped.extend([note] if note else [])
+    inherit, note = policy.clamp_inherit(request.inherit)
+    clamped.extend([note] if note else [])
+    requested_detail_note: list[dict[str, Any]] = []
+
+    def detail_for(wanted: str | None) -> str:
+        level, note = policy.clamp_detail(wanted, REFS)
+        if note and note not in requested_detail_note:
+            requested_detail_note.append(note)
+        return level
+
+    ancestors = graph.ancestors(focus, schema.parent_rel) if inherit else ()
+    always = [name for name in policy.always or () if name in views]
+    sources = _sources(
+        request,
+        policy,
+        views,
+        always=always,
+        depth=depth,
+        detail_for=detail_for,
+        inherit=inherit,
+        refused=refused,
+        notes=notes,
+    )
+    clamped.extend(requested_detail_note)
+    entries, groups = _collect(graph, schema, focus, ancestors, policy, sources)
+    ordered = sorted(entries.values(), key=lambda e: e.rank)
+
+    items: list[dict[str, Any]] = []
+    downgraded: list[dict[str, Any]] = []
+    cut: list[_Entry] = []
+    used = 0
+    for position, entry in enumerate(ordered):
+        placed = False
+        for level in _lower(entry.detail):
+            payload = _item_payload(entry, level, graph, schema, focus)
+            cost = size_of(payload)
+            if used + cost <= budget:
+                items.append(payload)
+                used += cost
+                if level != entry.detail:
+                    downgraded.append(
+                        {"qualifiedName": entry.node.key, "from": entry.detail, "to": level}
+                    )
+                placed = True
+                break
+        if not placed:
+            cut = ordered[position:]
+            break
+
+    returned = {item["qualifiedName"] for item in items}
+    for group in groups:
+        group["returned"] = sum(
+            1
+            for e in entries.values()
+            if e.node.key in returned and (e.view, e.path) == (group["view"], group["path"])
+        )
+    truncated: dict[str, Any] | None = None
+    if cut or downgraded:
+        by_group: dict[tuple[str | None, str], list[str]] = {}
+        for entry in cut:
+            by_group.setdefault((entry.view, entry.path), []).append(entry.node.key)
+        whole = sum(size_of(_item_payload(e, e.detail, graph, schema, focus)) for e in ordered)
+        truncated = {
+            "budget": budget,
+            "used": used,
+            "downgraded": downgraded,
+            "cut": [
+                {
+                    "view": view,
+                    "path": path,
+                    "count": len(names),
+                    "qualifiedNames": names[:CUT_NAMES],
+                }
+                for (view, path), names in by_group.items()
+            ],
+            "cutTotal": len(cut),
+            "hint": {"budget": min(max(whole, budget + 1), policy.budget_max)},
+        }
+    return {
+        "node": _node_payload(graph, schema, focus),
+        "request": request.as_payload(),
+        "effective": {
+            "views": list(dict.fromkeys(s.view.name for s in sources if s.view is not None)),
+            "paths": [path_text(s.steps) for s in sources if s.view is None],
+            "depth": depth,
+            "detail": detail_for(request.detail) if request.detail else None,
+            "budget": budget,
+            "inherit": inherit,
+        },
+        "items": items,
+        "groups": groups,
+        "truncated": truncated,
+        "used": used,
+        "dropped": {"unresolved": graph.dropped},
+        "policy": {
+            "layers": list(policy.layers),
+            "notes": notes,
+            "clamped": clamped,
+            "refused": refused,
+        },
+    }
+
+
+def _node_payload(graph: Graph, schema: Schema, key: str) -> dict[str, Any]:
+    node = graph.nodes[key]
+    return {
+        "qualifiedName": key,
+        "kind": node.kind,
+        "kindLabel": schema.kind_label(node.kind),
+        "title": _title(node, schema.hints(node.kind)),
+        "description": _shorten(node.description or "", DESCRIPTION_LIMIT),
+    }
+
+
+# ── the map ──────────────────────────────────────────────────────────────
+
+
+def build_map(
+    graph: Graph,
+    schema: Schema,
+    focus: str,
+    policy: Policy,
+    views: Mapping[str, View],
+    *,
+    size_of: SizeOf = json_size,
+) -> dict[str, Any]:
+    """Every relationship around *focus*, what it inherits, its views and the options."""
+    ancestors = graph.ancestors(focus, schema.parent_rel) if policy.inheritance else ()
+    rows: list[dict[str, Any]] = []
+    hidden: dict[str, str] = {}
+    steps: set[str] = set()
+    for start in (focus, *ancestors):
+        grouped: dict[tuple[str, str], dict[str, int]] = {}
+        for neighbour in graph.neighbours(start):
+            if start != focus and neighbour.rel == schema.parent_rel:
+                continue
+            other = graph.nodes[neighbour.other]
+            if neighbour.other == focus:
+                continue
+            text = f"{neighbour.rel}:{neighbour.direction}"
+            by = policy.hidden_by(neighbour.rel, neighbour.direction, other.kind)
+            if by is not None:
+                hidden.setdefault(text, by)
+                continue
+            if start == focus:
+                steps.add(text)
+            kinds = grouped.setdefault((neighbour.rel, neighbour.direction), {})
+            kinds[other.kind] = kinds.get(other.kind, 0) + 1
+        for (rel, direction), kinds in sorted(grouped.items()):
+            row: dict[str, Any] = {
+                "path": f"{rel}:{direction}",
+                "rel": rel,
+                "dir": direction,
+                "description": schema.relationship_description(rel),
+                "count": sum(kinds.values()),
+                "kinds": dict(sorted(kinds.items())),
+                "from": "self" if start == focus else start,
+            }
+            if start != focus:
+                row["inherited"] = True
+            rows.append(row)
+    for rel, targets in schema.carried(graph.nodes[focus].kind):
+        text = f"{rel}:{OUT}"
+        visible = (
+            any(policy.visible(rel, OUT, kind) for kind in targets)
+            if targets
+            else policy.step_hidden_by(Step(rel, OUT)) is None
+        )
+        if visible:
+            steps.add(text)
+    for text in list(hidden):
+        if text in steps:
+            del hidden[text]
+
+    view_rows: list[dict[str, Any]] = []
+    always = [name for name in policy.always or () if name in views]
+    for name, view in sorted(views.items(), key=lambda kv: (-kv[1].priority, kv[0])):
+        counted = build_result(
+            graph,
+            schema,
+            focus,
+            policy,
+            views,
+            ContextRequest(views=(name,), detail=REFS, budget=policy.budget_max),
+            size_of=lambda _item: 0,
+        )
+        view_rows.append(
+            {
+                "name": name,
+                "title": view.title,
+                "description": view.description,
+                "paths": view.path_texts,
+                "inherit": view.inherit,
+                "detail": view.detail,
+                "always": name in always,
+                "count": len(counted["items"]),
+            }
+        )
+    always_result = (
+        build_result(graph, schema, focus, policy, views, ContextRequest(), size_of=size_of)
+        if always
+        else None
+    )
+    address = focus
+    suggestions = [
+        f"taxonomy_context(node={address!r}, views=[{name!r}])"
+        for name in sorted(views)
+        if name not in always
+    ]
+    present = [r["path"] for r in rows if r["from"] == "self" and r["rel"] != schema.parent_rel]
+    if present or steps:
+        first = present[0] if present else sorted(steps)[0]
+        suggestions.append(
+            f"taxonomy_context(node={address!r}, paths=[{first!r}], detail='summary')"
+        )
+    return {
+        "node": _node_payload(graph, schema, focus),
+        "ancestors": [
+            {
+                "qualifiedName": key,
+                "kind": graph.nodes[key].kind,
+                "title": _title(graph.nodes[key], schema.hints(graph.nodes[key].kind)),
+            }
+            for key in ancestors
+        ],
+        "relationships": rows,
+        "hiddenByPolicy": [{"path": text, "limitedBy": by} for text, by in sorted(hidden.items())],
+        "views": view_rows,
+        "always": always_result,
+        "options": {
+            "steps": sorted(steps),
+            "maxDepth": policy.max_depth,
+            "detail": list(policy.detail),
+            "defaultDetail": policy.default_detail
+            if policy.default_detail in policy.detail
+            else REFS,
+            "budget": {
+                "default": min(policy.default_budget, policy.budget_max),
+                "max": policy.budget_max,
+            },
+            "inheritance": policy.inheritance,
+        },
+        "policy": {
+            "layers": list(policy.layers),
+            "notes": list(policy.notes),
+            "clamped": [],
+            "refused": [],
+        },
+        "next": suggestions,
+    }