Crate mant_protocol

Expand description

§mant-protocol

Explanation pages share original declaration contexts in a document-local support pool. ExplanationContent::DeclarationMember references one physical member without copying its body a second time. Nested groups retain separate member/provider descriptors but use typed paths into a materialized ancestor; SharedEntry likewise addresses a physical owner within that source fragment. resolve_range retains the owner-local coordinate contract, while response decoding validates pool, owner and position references. Context is neither an alias nor another query match.

Explanation responses can carry a page-local supports pool. A direct evidence owner’s optional support index refers to a recovered declaration-group, containing the original heads and the final member’s description. This is reading context, not another match or an alias edge. For scoped explanations the pool belongs to the evidence’s documentIndex. supportOmitted distinguishes a known context that exceeded the copy budget from an owner with no available context. Consumers must not treat an empty own description as an empty explanation without checking this support. Only direct evidence with a matching owner, forms and content reference can claim group support. Decoding and offline rendering use the same validated resolver; a valid numeric index alone never authorizes another owner’s body.

mant-protocol is ManT’s transport-neutral interaction boundary. It defines query contracts and projections shared by in-process hosts, CLI JSON, request JSON, and compact MCP presentation without owning any transport. It owns schema markers, logical catalog addresses, pagination, outline, excerpt, explanation, search, tldr-update results, local doctor reports, stable business labels, and JSON Schema generation. The mant crate separately composes host callbacks, process framing, terminal policy, and MCP transport.

Resolved document geometry belongs to mant-ir::geometry: pure display-cell measurement, signed origin composition/reparenting and bounded gap composition. mant-render consumes those rules without owning document geometry or terminal viewport state. Cell coordinates remain distinct from the byte/scalar positions used by semantic bindings and explanation evidence.

Original owner slice-to-scalar conversion belongs to mant-ir through project_content_slice and RootTextRange. Protocol response locations remain relative to their returned payload; render-owned presentation bindings reuse the IR rule rather than maintaining another interpretation of source bytes and scalars.

Use this crate whenever a Rust host or process consumer needs stable inputs, projections, or their validation. The same DTO may cross an in-memory callback, be serialized by a versioned JSON boundary, or be rendered into a compact MCP result; serialization is a supported representation, not the crate’s sole purpose. mant-render supplies deterministic reports from these DTOs. Protocol performs no document discovery, parsing, query execution, report rendering, terminal I/O, or MCP transport.

§Contract families

QueryRequest ──> host / mant-engine ──┬─> QueryBundle
                                      ├─> QueryOutline
                                      ├─> QueryExcerpt
                                      ├─> QueryExplanation
                                      └─> QuerySearch

ScopeQueryRequest ──> host / mant-engine ──> ScopeQueryResponse

CatalogQuery ──> host ──────────────────> DocumentCatalog

local inspection ───────────────────────> DoctorReport
explicit cache maintenance ─────────────> TldrCacheUpdate

Hosts pass existing DTOs to mant-render for compact text or CommonMark; this does not execute another query or load content.

Family	Current discriminator	Purpose
Process framing	`mant.cli/v0.11`	Advertised by the `mant` executable
Request	`mant.request/v0.11`	Closed input accepted by `--request-json`
Scope request/result	`mant.scope-request/v0.11`, `mant.scope-query/v0.11`	Bounded multi-document search and explanation
Full query	`mant.query/v0.11`	Document plus optional tldr content
Document	`mant.document/v0.11`	Versioned projection of the normalized document
Catalog	`mant.catalog/v0.11`	Registered Markdown and native-manual discovery
Outline, excerpt, search	`mant.outline/v0.11`, `mant.excerpt/v0.11`, `mant.search/v0.11`	Focused query projections
Explanation	`mant.explanation/v0.11`	Bounded independent name/form/content/relationship evidence
Doctor	`mant.doctor/v1`	Read-only local installation diagnostics
tldr update	`mant.tldr-update/v1`	Explicit native cache-maintenance result

The schemas generated from the Rust types are authoritative. Request schemas are generated for deserialization so closed-object and default behavior match what the process accepts; response schemas are generated for serialization. mant --schema all includes every row above, including the two independent maintenance and diagnostic contracts. These native schema discriminators describe CLI and request JSON. MCP uses its own negotiated protocol version and presents the same logical identities and focused projections as bounded text or CommonMark instead of serializing the native response envelopes.

§Basic use

Construct requests with the typed tagged unions and discover the exact JSON Schema rather than copying a shape by hand:

use mant_protocol::{
    EntryProjection, NATIVE_API_VERSION, QueryInput, QueryRequest, QueryView,
    RequestSchema, query_request_json_schema,
};

let request = QueryRequest {
    schema: RequestSchema::V0Dot11,
    input: QueryInput::Document {
        selector: "git".to_owned(),
        source: None,
        manual_section: None,
    },
    view: QueryView::Outline {
        references: Default::default(),
        entries: EntryProjection::Summary,
        root: None,
    },
};

assert_eq!(NATIVE_API_VERSION, "0.11");
assert_eq!(request.schema, RequestSchema::V0Dot11);
let _schema = query_request_json_schema();

The native query family follows ManT’s pre-stable minor release line: ManT 0.11.x uses v0.11, and patch releases remain backward compatible. They may add documented optional response fields, but never change requests, required fields, tagged unions, or existing field semantics. The former bare v1 through v7 schemas were experimental and are intentionally not accepted by 0.11. Historical tags preserve those contracts; the first stable native protocol will use a v1.0 release line. Independent contracts such as mant.doctor/v1 and mant.markdown/v1 keep their own identifiers. Clients must therefore compare complete discriminators. The mant-protocol crate has its own semver; upgrading that Rust package does not by itself select a new wire discriminator.

Adding or changing a Rust field does not by itself authorize a wire change. The native discriminator must advance whenever its serialized contract changes outside a patch-compatible addition.

The unreleased v0.11 document envelope retains authoritative heading inlines: Document.heading is optional, Section.heading is required, and a plain section title is rejected. Outline/excerpt displayTitle is only a derived report label. Root excerpts include the real heading even without body blocks.

Scoped search has one pagination coordinate system. ScopeSearch owns the global total, offset, truncation flag, and continuation offset; each ScopedSearchDocument carries only its logical address, depth, canonical Markdown render descriptor, and globally numbered hits. Consumers must never derive a continuation cursor from an individual document group.

Explanation is a separate QueryExplanation contract, not an excerpt wrapper. ExplanationQuery supplies a literal and bounded ExplanationOptions (50 owners by default, at most 256; zero-based offset; 1 MiB default / 4 MiB maximum forms/facts/previews/body copy budget). EvidenceClass distinguishes direct entries, explicitly related entries, entry mentions and context mentions. One owner retains all match bases but only one class, independent of omitted details or empty names. order is always class-then-source; the four fixed counts totals/returned sum to the response counts, including zero categories. ScopeExplanation has one globally ordered evidence page, one cursor and one copy budget. Its BFS documents are source reports without nested bodies or cursors; each record’s documentIndex refers to those reports, not the outer scope graph. Class priority precedes document order even at limit 1.

Every record has previews and previewsOmitted. Literal matches may retain two distinct matched blocks in source order, each a window of at most 1024 Unicode scalars preserving a complete match. Ranges are half-open scalar positions after control masking; source and absolute final-IR blockPath identify the actual block. Paths start at root or sections/sN[/sN...], with bN, iN, dN and rN/cN components. Page direct-match facts, direct bodies and necessary contexts precede optional details/windows and weaker evidence in the shared budget. Clipping is not omission; an omitted window sets previewsOmitted and content truncation, never replaces atomic content. Normal multiple results and no-evidence are not failures; check outcome, source coverage, truncation and diagnostics separately. semanticsComplete is validation coverage, not exhaustive recall. It is derived from IR diagnostic impact (none or semantic-coverage), independently of severity or producer-specific code names. Every serialized diagnostic requires this field; missing or unknown impacts are rejected.

An independently declared empty definition is a real direct record, not a missing-body result: it must not borrow the following owner’s description. Renderers may suppress Forms only when that particular record displays the complete matching owner and forms. Mentions and omitted/cropped content retain the separately returned forms. Plain reports have no generated body frame; their headings aid navigation but do not authenticate untrusted body text. Structured consumers use the DTO’s class, source and omission fields instead.

Name/Form bases retain bounded matched spellings and occurrences, not just a unit discriminator; Identity bases identify the matched outline fields. ExplanationEntry::name_bindings is the independent, owner-local ordinary-name projection. Form and content locations use half-open safe-text Unicode scalars, with typed definition-term roots and response-relative paths. Consumers can resolve them using ExplanationContentRange::resolve and ExplanationFormRange::resolve after deserialization, without the source document. Invalid locations are ignored rather than rediscovered by text searching. The separate match_details_omitted and name_bindings_omitted flags report bounded detail loss, independently of complete body/metadata omission. Limits are 32 match records, 32 ordinary bindings, 32 occurrences, 32 fragments per occurrence/domain and 1,024 fragments per owner, all within the copy budget.

mant-protocol deliberately reuses the semantic Block, Section, Inline, EntryFacts, DocumentAddress, source, metadata, diagnostic, and tldr types from mant-ir. Those types form the wire-bearing semantic subset: a Serde change to any of them is also a protocol change. CI compares every generated structural schema with the checked-in v0.11 snapshot, so an accidental IR representation change fails until compatibility is restored or the affected protocol discriminator is advanced explicitly. Rustdoc descriptions and schema titles are excluded from that structural comparison.

Focused excerpt, explanation and search results share OutlineTrail: ordered compact ancestors plus one typed terminal node. This keeps full tree-chain rendering and machine navigation consistent. Ordinary evidence adds its real IR block path, without manufacturing an entry or replacing strict selection.

Outline requests use EntryProjection: Summary is the compact default, None emits section topology only, All emits the complete nested semantic index, and Kinds retains selected roles plus their required ancestors. An optional root selector can focus any projection on one section or entry. Outline entries keep exact selector names separate from authored forms, explicit aliasGroups / aliasOf, and evidence-backed value domains.

Definitions remain authoritative content in mant-ir; SemanticEntry is a rebuildable concept index, and an outline entry is the selected protocol projection. Its id selects the definition that supplies content, while documentTargets describes explicit links carried by entry terms. This separation lets summary and role-filtered outlines omit entries without changing the document or inventing another semantic model.

This supports stateless agent exploration: inspect the compact summary, reuse a path or ID from that current response as the next request’s explicit ContentSelector root, expand all or selected entry kinds below it, then read the chosen local node. The closed wire forms are {"kind":"path","path":"2/e1"} and {"kind":"id","id":"option-help"}. Names, aliases, fragments and reference positions never fall back into content selection; use explanation for semantic discovery. Paths remain source-order coordinates without cross-call stale detection; clients rediscover after source edits or reordering. A kind filter with no matches returns an empty node set rather than the unrelated section topology.

QueryOutline.references is independent from that content tree. Its policy and occurrence records also supply associated navigation without changing source content. Entry outline nodes retain their exact original owner; validated form associations retain the semantic owner whose bindings were checked. Join these structural positions, not similarly named labels or IDs. Heading/form badges use mant-render’s shared reference_attachment and reference_badge presentation helpers, with the independent TextRole::Reference role. A partial record page describes known targets only and never establishes uniqueness.

ReferenceProjection selects none/summary/all, original target kinds and an occurrence page. Counts retain exact/lower-bound/unknown precision; scan coverage, target-validation coverage and retained-page limits are separate. ReferenceRecord points to the original content location and carries a containing sourceRead selector; it is not a semantic entry or an implicit cross-document read. Logical address derivation never proves a destination exists or an unloaded fragment is valid. The shared presentation remains usable after serialization without a parser, resolver or filesystem. DocumentOpenTarget is an explicit interactive host request, not authority for MCP or a reference inventory to execute an opener.

Normalized document content is defined separately by mant-ir. Parsing lives in mant-codec, lookup in mant-loader, pure projection in mant-query, and formatting in mant-render; mant-engine composes loading and query execution. The complete wire contract is documented by mant-protocol(5). Compatibility and migration notes are recorded in the crate changelog.

§In-memory presentation

EntryLabelMode makes Compact (validated names, visible forms, then ID) and Forms (visible forms first) explicit. This stable label policy remains in protocol for query and presentation consumers. mant-render’s EntryTone preserves the complete EntryKind at adapter boundaries; terms are primary content, not muted metadata. These are display policies, not aliases, confidence levels or new wire fields.

mant-render’s EntryStyleMap prepares owner-local validated name ranges once per borrowed document or excerpt. project_content_slice maps UTF-8 content slices into root-relative Unicode scalar ranges without copying the source tree. Its visit_inline_text composes those ranges with Strong, Emphasis, Code and Link markup as borrowed spans. Adapters own colors, escaping and line geometry; they must not reconstruct name bindings by searching rendered strings. Query-match and selection overlays remain separate from ordinary name roles. The shared entry presentation contract documents ownership, coordinate roots and adapter responsibilities.

§License

Apache-2.0.

Structs§

CatalogCoverage: Indexed namespaces available to one catalog query.
CatalogMatchScore: Complete literal relevance score shared by catalog frontends.
CatalogQuery: Bounded filtering and pagination shared by CLI, TUI, and MCP discovery.
DoctorCheck: One independently actionable installation check.
DoctorEnvironment: Effective local paths and host identity inspected by mant --doctor.
DoctorReport: Complete read-only installation health report.
DoctorSummary: Stable counts for one complete doctor run.
DocumentCatalog: Deterministically ordered page of discoverable local documents.
DocumentEdge: One resolved edge in source order.
DocumentFrontier: One typed outbound link excluded by a traversal bound.
DocumentResponse: Serializable v0.11 envelope around ManT’s protocol-independent document IR.
DocumentScope: Initial documents and the link policy used to expand them.
DocumentSelector: One logical document selector before catalog resolution.
DocumentSummary: One catalog row identified entirely by logical names.
DocumentTraversal: Bounded traversal applied after resolving the initial documents.
Engine: Parser implementation recorded at the process boundary.
EntryDocumentTarget: One exact cross-document destination declared by a semantic entry term.
EvidenceCount: Collected lower-bound total and the count returned on the current page.
EvidenceCounts: Fixed four-class counts. Each column sums to the response total/returned.
ExplanationEntry: Original semantic facts and forms; no executable argument grammar is implied.
ExplanationEvidence: One independently addressable evidence owner.
ExplanationFormMatch: One complete authored form that actually matched during collection.
ExplanationFormRange: Half-open Unicode scalar offsets in returned entry.forms[formIndex].
ExplanationNameBinding: One ordinary name binding, independent of whether that name matched a query.
ExplanationNameMatch: One documented name that actually matched under the owner’s case policy.
ExplanationOccurrence: One whole occurrence, with independent complete projections per target domain. An unavailable or omitted domain is empty; a partial name is never retained.
ExplanationOptions: Request-local semantic pagination and materialization controls.
ExplanationPreview: One representative literal window, not a replacement IR block or a summary.
ExplanationQuery: A literal evidence request, not executable syntax or a unique selector.
ExplanationTruncation: Independent reasons that a bounded explanation may omit material.
InvalidContentSelector: A malformed, noncanonical or oversized explicit content selector.
NodePath: Canonical structural address emitted for a node in a projected outline.
OutlineReference: Compact ancestor identity attached to an excerpt selection.
OutlineTrail: Complete logical location of one addressable document node.
Producer: Identifies ManT and the parser used to build a wire document.
QueryBundle: Versioned full-query result emitted at CLI and request JSON boundaries.
QueryExcerpt: One or more independently selected nodes from a complete query.
QueryExplanation: One readable document’s independently collected explanation evidence.
QueryOutline: A block-free tree used to discover selectable query content.
QueryRequest: Native use-case input. The engine validates semantic constraints before I/O.
QuerySearch: Complete, paginatable search result returned to agents and scripts.
ReferenceCoverage: Accounted work and actual content coverage for one scan.
ReferenceInventory: Independent reference output embedded alongside an outline’s content tree.
ReferencePage: A bounded page over original link occurrences in source order.
ReferenceProjection: Independent reference selection policy; entry filtering never changes it.
ReferenceRecord: One occurrence, not a grouped or deduplicated navigation row.
ResolvedDocumentScope: Logical graph produced before applying a projection.
ScopeExplanation: Global evidence page over a resolved scope. Source loading failures/frontier remain in ScopeQueryResponse.scope, independently of this normal outcome.
ScopeQueryRequest: Native request for a bounded multi-document query.
ScopeQueryResponse: Complete bounded multi-document response.
ScopeReferenceLimit: A bounded outbound scan that could not establish the complete edge set.
ScopeSearch: Globally paginated search over a resolved document scope.
ScopedDocument: One distinct document in breadth-first traversal order.
ScopedExplanation: One readable document’s contribution to the evidence result.
ScopedExplanationEvidence: One global evidence record with an explicit source-report reference.
ScopedQueryFailure: One per-document projection failure that does not invalidate other results.
ScopedSearchDocument: One document’s search hits inside a globally paginated scope result.
SearchContextLine: One rendered Markdown line surrounding a match.
SearchHit: One rendered line or line span containing one or more exact occurrences.
SearchLineRange: One exact occurrence fragment within an anchor-free rendered Markdown line.
SearchMarkdownRange: Half-open byte range plus one-based human coordinates in full Markdown.
SearchOccurrence: One exact matcher occurrence in the canonical Markdown render.
SearchQuery: Normalized search configuration echoed in a search response.
SearchRender: Description of the deterministic document whose Markdown coordinates are reported.
TldrCacheUpdate: Result of an explicit mant --update-tldr operation.
UnresolvedDocument: A seed or typed link that could not be resolved.

Enums§

CatalogDocumentKind: Optional family filter for catalog discovery.
CatalogMatchRank: Stable relevance tier for literal catalog matching.
CatalogSchema: Exact schema marker for a local document catalog.
CatalogSpellingRank: Spelling fidelity inside one catalog relevance tier.
ContentSelector: One exact local owner in the document actually loaded for this operation.
DoctorCheckStatus: Severity of one stable doctor check.
DoctorOutcome: Aggregate health derived from every doctor check.
DoctorSchema: Exact schema marker for an installation health report.
DocumentAddress: Stable selector for one discoverable document candidate.
DocumentEdgeKind: Typed cross-document edge retained in a resolved scope.
DocumentOpenTarget: An interactive request to load a local document, not permission to execute it.
DocumentSchema: Exact schema marker for a normalized structured document response.
EntryLabelMode: Which already validated entry facts supply a display label first.
EntryProjection: Semantic entry material included beneath structural outline nodes.
EntryValueDomain: Resolved value space accepted by one semantic entry.
EvidenceBasis: Why this owner is included. Multiple bases do not duplicate its content.
EvidenceClass: Mutually exclusive owner category, in normative presentation/page order. This is a source-evidence distinction, not a confidence or relevance score.
EvidenceOrder: Fixed explanation ordering; no legacy/source-only ordering mode exists.
ExcerptSchema: Exact schema marker for selected query content.
ExcerptSelection: One selected document node together with its location in the complete outline.
ExplanationBlockStep: Shared structural step, rooted here in the single returned content.block. Item/cell steps select an array and must be followed by a block step. A checked transition through block arrays and their containing items/cells.
ExplanationContent: Original content copied for one evidence owner, not a navigation selection.
ExplanationContentRange: Half-open Unicode scalar offsets rooted in this response’s original body. The path does not reference the full source document or a preview window.
ExplanationIdentityField: An actual identity match, referencing this evidence’s outline fields.
ExplanationOutcome: A normal result outcome, independent of pagination and source coverage.
ExplanationSchema: Exact marker for the independent explanation result contract.
ExplanationSupport: Original content supporting directly matched declarations. IDs are indices in the containing document response’s pool, never persistent identities.
ExplanationTextRoot: A borrowed original text root; not a flattened compound block or rendered line.
InputFormat: Parser selected for an explicit physical input.
LoadedFragment: Fragment outcome in an actually loaded target snapshot.
MarkdownOrigin: Storage identity of one registered Markdown document.
MarkdownSchema: Markdown contract used as the coordinate space for every search format.
OutlineDetail: Compatibility selector for in-process callers migrating from v0.9.
OutlineNode: One uniquely addressable node in a query outline.
OutlineNodeReference: Compact typed identity for the terminal node in an OutlineTrail.
OutlineSchema: Exact schema marker for a query outline response.
QueryInput: Source selected by one public query request.
QuerySchema: Exact schema marker for a complete ManT query result.
QueryView: Projection requested after loading one complete structured document.
ReferenceAssociation: Validation state of optional original form bindings.
ReferenceCount: Precision of an occurrence or distinct-target count.
ReferenceCoverageStatus: Coverage is independent of target-set precision and returned-page truncation.
ReferenceLimitReason: Why bounded traversal could not inspect all selected source content.
ReferencePageLimit: A return-page cap, not a scan-coverage claim.
ReferenceProjectionMode: Whether reference facts are omitted, counted, or materialized.
ReferenceResolution: Staged resolution; locating an address never implies loading or validating it.
ReferenceTargetType: Kind of the original typed link, before any destination lookup.
ReferenceUnknownReason: Why a requested quantity has no observation.
RequestSchema: Exact schema marker for a native query request.
ScopeQueryResult: Projection result carried by a scope-query response.
ScopeQuerySchema: Exact schema marker for a resolved scope query.
ScopeQueryView: Query projection supported over a document set.
ScopeRequestSchema: Exact schema marker for a scope-query request.
ScopeTextError: One violated runtime constraint shared by scope-query request adapters.
SearchCase: Case-folding policy applied when compiling the matcher.
SearchRenderFormat: Canonical render format used for search coordinates.
SearchRenderScope: Amount of the query included in the coordinate-bearing render.
SearchSchema: Exact schema marker for structure-aware search results.
SearchScope: Text representation searched while Markdown remains the coordinate basis.
SearchSyntax: Pattern language used for one search.
TldrCacheAction: How an explicit tldr cache refresh changed local state.
TldrCacheUpdateSchema: Exact schema marker for an explicit tldr cache update result.
TraversalLimit: Traversal bound that excluded an outbound logical link.
UnloadedFragment: Fragment facts permitted before a target document is loaded.

Constants§

CLI_PROTOCOL_VERSION: Exact process protocol reported by the native CLI boundary.
DEFAULT_SCOPE_DEPTH: Default maximum number of link edges followed from an initial document.
DEFAULT_SCOPE_DOCUMENT_LIMIT: Default maximum number of distinct documents in one resolved scope.
DEFAULT_SEARCH_LIMIT: Default maximum number of matching line groups returned in one page.
MAX_CATALOG_PATTERN_CHARS: Maximum Unicode scalar length of one native catalog pattern.
MAX_DOCUMENT_SELECTOR_CHARS: Maximum Unicode scalar length of one logical document selector.
MAX_EXPLANATION_CANDIDATES: Maximum matching owners indexed per document before reporting incomplete recall.
MAX_EXPLANATION_CONTENT_BYTES: Maximum serialized content bytes copied into one response page.
MAX_EXPLANATION_FRAGMENTS: Maximum fragments in one occurrence in each target domain.
MAX_EXPLANATION_MATCH_RECORDS: Maximum retained Name and Form records combined per evidence owner.
MAX_EXPLANATION_NAME_BINDINGS: Maximum ordinary display bindings per evidence owner (not a names limit).
MAX_EXPLANATION_OCCURRENCES: Maximum source occurrences retained per match or display-binding record.
MAX_EXPLANATION_POSITIONS: Combined match, display-binding and preview/body fragments per owner.
MAX_EXPLANATION_RELATIONS: Maximum explicit relationship edges followed per document.
MAX_EXPLANATION_RELATION_DEPTH: Maximum edges in one returned relationship chain.
MAX_EXPLANATION_RESULTS: Maximum evidence owners materialized in one page.
MAX_MANUAL_SECTION_CHARS: Maximum Unicode scalar length of one native manual section selector.
MAX_NODE_SELECTORS: Maximum outline selectors accepted by one focused read request.
MAX_SCOPE_CONTENT_BYTES: Maximum aggregate normalized-document payload retained by one scope.
MAX_SCOPE_DEPTH: Hard maximum number of link edges accepted by the native scope contract.
MAX_SCOPE_DOCUMENTS: Maximum number of initial documents accepted by the native scope contract.
MAX_SCOPE_DOCUMENT_LIMIT: Hard maximum number of distinct documents in one resolved scope.
MAX_SEARCH_PATTERN_CHARS: Maximum Unicode scalar length of one search pattern.
MAX_SEMANTIC_ENTRY_CHARS: Maximum Unicode scalar length of one semantic-entry selector.
MAX_SOURCE_SELECTOR_CHARS: Maximum Unicode scalar length of one configured Markdown source selector.
NATIVE_API_VERSION: Pre-stable native API release line shared by the query protocol family.

Functions§

catalog_literal_match_rank: Rank one document name or slash-delimited path using the catalog’s literal-search case policy.
catalog_literal_match_score: Rank one literal candidate while preferring case-faithful spellings inside the same exact, prefix, or substring tier.
default_catalog_limit: Return the default maximum number of catalog rows.
default_explanation_content_bytes: Default shared forms/body budget (1 MiB).
default_explanation_limit: Default number of explanation records (50).
default_scope_depth: Return DEFAULT_SCOPE_DEPTH.
default_scope_document_limit: Return DEFAULT_SCOPE_DOCUMENT_LIMIT.
default_search_limit: Return DEFAULT_SEARCH_LIMIT.
doctor_report_json_schema: Generate the read-only installation health report schema.
document_catalog_json_schema: Generate the local document-catalog JSON representation.
entry_kind_label: Stable human label, distinct from Rust Debug and from wire discriminators.
entry_label: Produce a nonempty entry label without parsing names or implying aliases.
query_bundle_json_schema: Generate the complete-query JSON representation emitted by mant.
query_excerpt_json_schema: Generate the selected-excerpt JSON representation emitted by mant.
query_explanation_json_schema: Generate the independent semantic-evidence response representation.
query_json_schema_catalog: Generate every public request and query-response contract in stable order.
query_outline_json_schema: Generate the outline JSON representation emitted by mant.
query_request_json_schema: Generate the JSON representation accepted when deserializing a request.
query_search_json_schema: Generate the structure-aware search result emitted by mant.
scope_query_request_json_schema: Generate the bounded multi-document request representation.
scope_query_response_json_schema: Generate the bounded multi-document result representation.
tldr_cache_update_json_schema: Generate the explicit tldr cache update result schema.
validate_scope_text: Validate one bounded logical selector at the native request boundary.