Enum EventKind 

pub enum EventKind {
    RunCreated {
        run_id: String,
        plan_id: String,
        version: String,
        targets: Vec<String>,
    },
    PhaseEntered {
        phase: Phase,
    },
    PhaseCompleted {
        phase: Phase,
        outcome: PhaseOutcome,
    },
    TargetDryRun {
        target: String,
    },
    TargetBuilt {
        target: String,
    },
    TargetPublished {
        target: String,
        receipt: PublishReceipt,
    },
    TargetCancelled {
        target: String,
        reason: String,
    },
    TagCreatedLocal {
        tag: String,
    },
    TagPushedRemote {
        tag: String,
    },
    GithubReleaseCreated {
        tag: String,
        url: Option<String>,
    },
    RunAbandoned {
        reason: String,
    },
}

The payload of a journal event — the ADR-0002 event classes. Serialized internally tagged on a kind discriminator, flattened into the JournalEvent envelope so each JSONL line is one flat object.

Variants

RunCreated

The run was created: fixes its identity (run_id), the approved plan it executes (plan_id), and the ordered target set. Always the first event.

Fields

run_id: String

The run’s unique id (a ULID from the injected IdGen).

plan_id: String

The sealed, content-addressed plan id this run executes (ADR-0002).

version: String

The chosen release version this run publishes — the human’s approved bump, sealed into plan_id and journalled as an input so resume (wave-3) can reconstruct the plan from the durable record alone (ADR-0002 §3; the plan module persists exactly plan_id + version).

A required field of the v1 event, deliberately not #[serde(default)]: a RunCreated without it is corrupt (a resume must never fabricate an empty version and hash it into a wrong plan_id), so crate::release::journal::read_events refuses such a line with an actionable error rather than defaulting to "".

targets: Vec<String>

The ordered target set (e.g. ["rust", "node"]).

PhaseEntered

A phase barrier was entered.

Fields

phase: Phase

The barrier now in progress.

PhaseCompleted

A phase barrier completed.

Fields

phase: Phase

The barrier that completed.

outcome: PhaseOutcome

Its outcome.

TargetDryRun

A target cleared its dry-run.

Fields

target: String

The target id.

TargetBuilt

A target’s release artifact was built.

Fields

target: String

The target id.

TargetPublished

A target was published — the point-of-no-return fact, with its receipt.

Fields

target: String

The target id.

receipt: PublishReceipt

The receipt proving exactly what landed.

TargetCancelled

A target was cancelled (skipped) with a reason.

Fields

target: String

The target id.

reason: String

Why it was cancelled.

TagCreatedLocal

The release tag was created locally.

Fields

tag: String

The tag name.

TagPushedRemote

The release tag was pushed to the remote.

Fields

tag: String

The tag name.

GithubReleaseCreated

The GitHub Release for the tag was created.

Fields

tag: String

The tag name.

url: Option<String>

The Release URL, when GitHub reports one.

RunAbandoned

The run was abandoned. Terminal; there is no auto-rollback (ADR-0002).

Fields

reason: String

Why the run was abandoned.

Implementations

impl EventKind

pub fn idempotency_key(&self) -> String

The stable idempotency key for this event — its natural semantic identity, so a retried step (re-publishing an already-published target, re-entering a phase) resolves to the same key.

This is metadata only: it is deliberately not used to suppress an append (see JournalEvent::idempotency_key). Two events can share a key yet be distinct facts that must both be recorded — a phase_completed Failed and, after a resume, a phase_completed Ok for the same phase. Replay idempotency comes from JournalEvent::seq (the watermark), never from this key.

Trait Implementations

impl Clone for EventKind

fn clone(&self) -> EventKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EventKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for EventKind

impl PartialEq for EventKind

fn eq(&self, other: &EventKind) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for EventKind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EventKind