Enum Operation 

pub enum Operation {
    Hello(HelloAgreement),
    Present(PassPresent),
    DraftsRun(DraftsRun),
    Branches(BranchPage),
    Collections(CollectionPage),
    Get(DocumentRead),
    List(DocumentPage),
    History(HistoryPage),
    Follow(HeadFollow),
    Review(ReviewPage),
    ReviewCounts(ReviewPage),
    MergePrepare(ReviewPage),
    MergeDangling(ReviewPage),
    Mutate(Mutation),
    Receipt(ReceiptQuery),
    CountsRebuild(CountsRebuild),
    CountsAudit(Selection),
    EdgesOut(EdgePage),
    EdgesIn(EdgePage),
    GraphExport(GraphPage),
    VectorGet(VectorRead),
    VectorList(VectorPage),
    VectorSearch(VectorSearch),
    VectorSearchText(VectorSearchText),
    StoreStats(StoreRead),
    VectorFields(StoreRead),
    EmbedRewalk(EmbedRewalk),
    Relations(RelationsRead),
    QueryRun(QueryRequest),
    QueryCheck(CheckRequest),
    QueryWords(WordsRequest),
    ChangesList(ChangesRequest),
}

Reads select a captured version; mutations have a separate stable identity.

Variants

Hello(HelloAgreement)

Present(PassPresent)

Presents the connection’s Lys pass; every later request on the connection is decided from it (ACCESS-001 R2). Answers {holder, expires} once the pass verifies.

DraftsRun(DraftsRun)

Runs one page of the drafts Lys approved for this database, with the connection’s pass as the connector’s: each is applied exactly once and acknowledged (ACCESS-001 R2). Answers {acknowledged, next}; nothing polls or retries on its own.

Branches(BranchPage)

Collections(CollectionPage)

Get(DocumentRead)

List(DocumentPage)

History(HistoryPage)

Follow(HeadFollow)

Answers a stream of frames, all with the request’s id: the branch’s head {branch, version} at once, then one each time its published version changes, ended by a refusal: pass_expired when the connection’s pass expires, branch_unknown when the branch is gone. Pushed by the publish itself; nothing polls (serve/follow.rs).

Review(ReviewPage)

ReviewCounts(ReviewPage)

Answers partial owner-key counts; sum pages until done is true.

MergePrepare(ReviewPage)

Answers pinned three-way owner lines without admitting a mutation.

MergeDangling(ReviewPage)

Answers merge endpoint findings without choosing a conflict winner.

Mutate(Mutation)

Receipt(ReceiptQuery)

CountsRebuild(CountsRebuild)

Recounts visible rows atomically; a repeated request replays its receipt.

CountsAudit(Selection)

Compares kept counts with visible rows without changing the selected version.

EdgesOut(EdgePage)

Answers {selection, edges: [Edge], next_after}: edges leaving node.

EdgesIn(EdgePage)

Answers {selection, edges: [Edge], next_after}: edges arriving at node.

GraphExport(GraphPage)

Answers {selection, edges: [Edge], next_after}: every edge of the version.

VectorGet(VectorRead)

Answers {selection, vector}; vector is null when none is stored.

VectorList(VectorPage)

Answers {selection, vectors: [{document_id, vector}], next_after}.

VectorSearch(VectorSearch)

Answers {selection, hits: [{document_id, score}], scanned}.

VectorSearchText(VectorSearchText)

Answers {selection, hits: [{document_id, score}], compared, stale, coverage}: text embedded as a question, then the field searched.

StoreStats(StoreRead)

VectorFields(StoreRead)

EmbedRewalk(EmbedRewalk)

Answers {branch, collection, field, through}: opens one walk of the field toward through for the texts it passed as longer than the model reads (EMB-E2 (j)).

Relations(RelationsRead)

Answers {selection, relations: [Relation]} at the captured version.

QueryRun(QueryRequest)

Answers {selection, rows: [{value, origin}], next, engine, reading, collection, records_read}: one page of a query’s rows at one captured moment; collection is the one a pipeline read, else null.

QueryCheck(CheckRequest)

QueryWords(WordsRequest)

ChangesList(ChangesRequest)

Answers {from, to, rows: [{kind, origin, before, after}], next, changes_read}: the documents changed between two versions.

Implementations

impl Operation

pub const WIRE_NAMES: &'static [&'static str]

Every wire name of this vocabulary, in declaration order; the route matrix is checked against it.

Trait Implementations

impl Debug for Operation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Operation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Operation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.