Enum Event 

pub enum Event {
    WorkflowStarted {
        envelope: EventEnvelope,
        workflow_type: String,
        input: Payload,
        run_id: RunId,
        parent_run_id: Option<RunId>,
        parent_workflow_id: Option<WorkflowId>,
        package_version: PackageVersion,
    },
    WorkflowCompleted {
        envelope: EventEnvelope,
        result: Payload,
    },
    WorkflowFailed {
        envelope: EventEnvelope,
        error: WorkflowError,
    },
    WorkflowCancelled {
        envelope: EventEnvelope,
        reason: String,
    },
    WorkflowTimedOut {
        envelope: EventEnvelope,
        timeout: String,
    },
    WorkflowContinuedAsNew {
        envelope: EventEnvelope,
        input: Payload,
        workflow_type: Option<String>,
        parent_run_id: RunId,
    },
    WorkflowReopened {
        envelope: EventEnvelope,
        run_id: RunId,
        reopened: Vec<ActivityId>,
    },
    WorkflowPaused {
        envelope: EventEnvelope,
        run_id: RunId,
        reason: Option<String>,
        operator: Option<String>,
    },
    WorkflowResumed {
        envelope: EventEnvelope,
        run_id: RunId,
        operator: Option<String>,
    },
    SearchAttributesUpdated {
        envelope: EventEnvelope,
        workflow_id: WorkflowId,
        attributes: HashMap<String, SearchAttributeValue>,
    },
    ActivityScheduled {
        envelope: EventEnvelope,
        activity_id: ActivityId,
        activity_type: String,
        input: Payload,
        task_queue: String,
        node: Option<String>,
    },
    ActivityStarted {
        envelope: EventEnvelope,
        activity_id: ActivityId,
        attempt: u32,
    },
    ActivityLeased {
        envelope: EventEnvelope,
        activity_id: ActivityId,
        attempt: u32,
        worker: WorkerAttribution,
    },
    ActivityAdoptionOffered {
        envelope: EventEnvelope,
        activity_id: ActivityId,
        attempt: u32,
    },
    ActivityCompleted {
        envelope: EventEnvelope,
        activity_id: ActivityId,
        result: Payload,
        attempt: u32,
    },
    ActivityFailed {
        envelope: EventEnvelope,
        activity_id: ActivityId,
        error: ActivityError,
        attempt: u32,
    },
    ActivityAdvisoryExhausted {
        envelope: EventEnvelope,
        activity_id: ActivityId,
        activity_type: String,
        reason: String,
        attempt: u32,
    },
    ActivityFallbackRouted {
        envelope: EventEnvelope,
        activity_id: ActivityId,
        attempt: u32,
        from_task_queue: String,
        to_task_queue: String,
        fallback_index: u32,
    },
    ActivityCancelled {
        envelope: EventEnvelope,
        activity_id: ActivityId,
        attempt: u32,
    },
    TimerStarted {
        envelope: EventEnvelope,
        timer_id: TimerId,
        fire_at: DateTime<Utc>,
    },
    TimerFired {
        envelope: EventEnvelope,
        timer_id: TimerId,
    },
    TimerCancelled {
        envelope: EventEnvelope,
        timer_id: TimerId,
        cause: TimerCancelCause,
    },
    WithTimeoutCompleted {
        envelope: EventEnvelope,
        timer_id: TimerId,
        outcome: WithTimeoutOutcome,
        result: Option<Payload>,
    },
    SignalReceived {
        envelope: EventEnvelope,
        name: String,
        payload: Payload,
    },
    SignalSent {
        envelope: EventEnvelope,
        target_workflow_id: WorkflowId,
        name: String,
        payload: Payload,
    },
    ChildWorkflowStarted {
        envelope: EventEnvelope,
        child_workflow_id: WorkflowId,
        workflow_type: String,
        input: Payload,
        package_version: PackageVersion,
    },
    ChildWorkflowCompleted {
        envelope: EventEnvelope,
        child_workflow_id: WorkflowId,
        result: Payload,
    },
    ChildWorkflowFailed {
        envelope: EventEnvelope,
        child_workflow_id: WorkflowId,
        error: WorkflowError,
    },
    ChildWorkflowCancelled {
        envelope: EventEnvelope,
        child_workflow_id: WorkflowId,
    },
    ScheduleCreated {
        envelope: EventEnvelope,
        schedule_id: ScheduleId,
        config: ScheduleConfig,
    },
    ScheduleUpdated {
        envelope: EventEnvelope,
        schedule_id: ScheduleId,
        config: ScheduleConfig,
    },
    SchedulePaused {
        envelope: EventEnvelope,
        schedule_id: ScheduleId,
    },
    ScheduleResumed {
        envelope: EventEnvelope,
        schedule_id: ScheduleId,
    },
    ScheduleDeleted {
        envelope: EventEnvelope,
        schedule_id: ScheduleId,
    },
    ScheduleTriggered {
        envelope: EventEnvelope,
        schedule_id: ScheduleId,
        workflow_id: WorkflowId,
        run_id: RunId,
    },
    CadenceFired {
        envelope: EventEnvelope,
        window_seq: u64,
    },
    IterationClosed {
        envelope: EventEnvelope,
        routes: Vec<String>,
        health_samples: Vec<HealthSample>,
    },
    LoopRetired {
        envelope: EventEnvelope,
        reason: String,
    },
    WorkflowHatched {
        envelope: EventEnvelope,
        child_workflow_id: WorkflowId,
        key: String,
    },
    InvariantUnconfirmed {
        envelope: EventEnvelope,
        invariant: String,
        cause: AlarmCause,
        window_seq: Option<u64>,
        last_confirmed_at: Option<DateTime<Utc>>,
        consecutive_unconfirmed: u64,
    },
}

A recorded workflow history event.

User data is carried as opaque Payload values, while failures use the closed workflow and activity error types from this crate.

Variants

WorkflowStarted

A workflow execution started with a type name and input payload.

Fields

envelope: EventEnvelope

Recording metadata for this event.

workflow_type: String

Workflow type selected by the caller.

input: Payload

Opaque workflow input payload.

run_id: RunId

Concrete run identifier started by this event.

parent_run_id: Option<RunId>

Parent run that continued as this run, when this start is part of a continue-as-new chain.

parent_workflow_id: Option<WorkflowId>

The parent WORKFLOW that spawned this run as a child (aion#77): the child wears its parent, so a handoff chain is traversable backward from any run and the console can group an arc without scanning every parent history. None for operator-started roots and for histories recorded before the field existed (the serde default, exactly as task_queue and attempt decode legacies).

package_version: PackageVersion

Package version this run was resolved against at record time.

Recovery and replay resolve workflow code from this recorded version; they never re-resolve a “latest” version.

WorkflowCompleted

A workflow execution completed successfully; this terminal event projects to Completed.

Fields

envelope: EventEnvelope

Recording metadata for this event.

result: Payload

Opaque workflow result payload.

WorkflowFailed

A workflow execution failed terminally; this terminal event projects to Failed.

Fields

envelope: EventEnvelope

Recording metadata for this event.

error: WorkflowError

Terminal workflow failure.

WorkflowCancelled

A workflow execution was cancelled; this terminal event projects to Cancelled.

Fields

envelope: EventEnvelope

Recording metadata for this event.

reason: String

Human-readable cancellation reason.

WorkflowTimedOut

A workflow execution timed out; this terminal event projects to TimedOut.

Fields

envelope: EventEnvelope

Recording metadata for this event.

timeout: String

Descriptor identifying the timeout that elapsed.

Intentionally stringly-typed: the closed set of timeout kinds is defined by cluster AT (timers and signals), not by the core event model.

WorkflowContinuedAsNew

A workflow execution continued as a new run; this terminal event projects to ContinuedAsNew.

Fields

envelope: EventEnvelope

Recording metadata for this event.

input: Payload

Opaque workflow input payload carried into the new run.

workflow_type: Option<String>

Workflow type override for the new run, when migration changes the workflow type.

When absent, the new run uses the current workflow type.

parent_run_id: RunId

Run identifier for the current run that is being continued.

WorkflowReopened

A failed run was reopened.

Engine-internal — never authored by workflow or SDK code. This is the compensating event that reconciles reopen with the status-is-a-projection invariant: under the last-lifecycle-event-wins scan it supersedes the run’s prior terminal event and returns the run to Running, exactly as a replacement Event::WorkflowStarted does for continue-as-new. Terminal detection is scoped to “since the last reopen point”, so a run holds exactly one terminal event per lease.

Fields

envelope: EventEnvelope

Recording metadata for this event.

run_id: RunId

Run being reopened — the run that recorded the superseded terminal event and that the reopened execution continues.

reopened: Vec<ActivityId>

Activities to re-dispatch on replay: those that ended in a terminal failure in this run with no later successful attempt. The history cursor treats each as a reset point so the recorded failure is superseded and the activity resolves to live re-dispatch.

WorkflowPaused

A running workflow was paused by an operator.

Engine-internal — never authored by workflow or SDK code. A NON-terminal lifecycle marker: under the last-lifecycle-event-wins scan it projects the run to crate::WorkflowStatus::Paused, holding new activity dispatch at the outbox while every durable record path (timer fires, signal receipts, drained completions) keeps recording. It is invisible to the replay cursor (it is neither a terminal nor a run-start reset), so a paused-then-resumed history replays byte-identically to one that was never paused.

Fields

envelope: EventEnvelope

Recording metadata for this event.

run_id: RunId

Run being paused — the live, non-terminal run the operator held.

reason: Option<String>

Optional operator-supplied pause reason.

operator: Option<String>

Optional identity of the operator who issued the pause.

WorkflowResumed

A paused workflow was resumed by an operator.

Engine-internal — never authored by workflow or SDK code. Supersedes the run’s prior Event::WorkflowPaused under the last-lifecycle-event-wins scan, returning the run to crate::WorkflowStatus::Running, and — like Event::WorkflowPaused — is invisible to the replay cursor.

Fields

envelope: EventEnvelope

Recording metadata for this event.

run_id: RunId

Run being resumed.

operator: Option<String>

Optional identity of the operator who issued the resume.

SearchAttributesUpdated

Workflow search attributes were updated for visibility and query projection.

Fields

envelope: EventEnvelope

Recording metadata for this event.

workflow_id: WorkflowId

Workflow whose search attributes changed.

attributes: HashMap<String, SearchAttributeValue>

Updated search attributes keyed by attribute name.

ActivityScheduled

An activity was scheduled by workflow code.

Fields

envelope: EventEnvelope

Recording metadata for this event.

activity_id: ActivityId

Deterministic activity identifier derived from the scheduling sequence position.

activity_type: String

Activity type selected by workflow code.

input: Payload

Opaque activity input payload.

task_queue: String

Pool/flavour selector this activity dispatches to within the workflow’s namespace (NSTQ-3). This is the durable source-of-truth for re-targeting the same task queue on reopen/recovery, mirroring how the namespace is recovered from history but recorded per-activity rather than as a workflow-level search attribute.

Replay-safety: histories recorded before this field existed have no task_queue on their ActivityScheduled events. Decode defaults the missing value to DEFAULT_TASK_QUEUE ("default") via #[serde(default = ...)], so an old history deterministically re-derives task_queue = "default" — never panics, never differs run-to-run. The encoding of the existing fields is untouched.

node: Option<String>

OPTIONAL node affinity this activity dispatches to (NODE-3). None = no affinity (the genuine current value; SDK-level node selection is NODE-4). This is the durable source-of-truth for re-targeting the same node on reopen/recovery, recorded per-activity alongside task_queue.

Replay-safety: histories recorded before this field existed have no node key on their ActivityScheduled events. serde’s Option default is None, so #[serde(default)] decodes a missing node deterministically to None — never a sentinel, never panics, never differs run-to-run. The encoding of the existing fields is untouched.

ActivityStarted

The engine DISPATCHED an activity attempt to its task queue.

This does NOT mean a worker has taken the work. The event is written by the engine at dispatch time, in the SAME atomic append as its Event::ActivityScheduled and under the same recorded_at, before any worker has been selected — let alone leased the attempt. Worker selection happens afterwards, in the server, and may wait indefinitely: a dispatch to a task queue nobody serves records this event and then nothing, so a run parked forever and a run a worker is actively executing have identical history shapes and both project WorkflowStatus::Running. That is not a projection bug — history genuinely holds no terminal event — but it means this event alone can never answer “is anyone working on it”.

Every producing seam behaves this way: the single-dispatch and in-VM seams (aion::runtime::nif_activity_dispatch, aion::runtime::nif_activity_in_vm), the retry delivery (aion::runtime::nif_activity_retry_dispatch, which records the next attempt’s start “before it goes on the wire”), and the fan-out batch (aion::durability::recorder::fan_out).

The name is therefore wrong and the behaviour is not. A rename to ActivityDispatched is PROPOSED and PENDING an owner ruling, together with the question of whether a separate lease-time event should exist; see docs/design/aion-authoring/ACTIVITY-STARTED-SEMANTICS-DECISION.md. Deferring THIS event to lease time is recommended against there, because it would silently change what every already-recorded ActivityStarted meant.

To ask whether an in-flight activity can still reach a worker, join its recorded address to the live fleet — aion_server’s worker::ActivityReachability, surfaced on POST /workflows/describe.

Fields

envelope: EventEnvelope

Recording metadata for this event.

activity_id: ActivityId

Activity that was dispatched.

attempt: u32

One-based activity attempt number this start belongs to (NOI-0).

Matches the attempt on the Event::ActivityFailed / Event::ActivityCompleted / Event::ActivityCancelled that terminates the SAME attempt, so (workflow, activity, attempt) is a stable identity across the whole lifecycle — the key the NOI dedupe/guard/session-id design is built on.

Replay-safety: histories recorded before this field existed have no attempt key on their ActivityStarted events. Decode defaults the missing value to [LEGACY_ACTIVITY_ATTEMPT] (0) via #[serde(default = ...)] — never panics, never differs run-to-run. Because real attempts are one-based, 0 is a distinguishable legacy/unknown sentinel, never a genuine attempt. The encoding of the existing fields is untouched.

ActivityLeased

A selected worker accepted the push of one activity attempt.

This is the lease-time fact Event::ActivityStarted is not: the dispatch record says the engine put the attempt on a queue; this says WHICH worker took it off. It is recorded by the workflow’s one Recorder at the outbox handoff seam, after the selected worker accepted delivery and before any completion, on both transports. It is an asynchronous arrival like Event::SignalReceived: no workflow command waits on it, replay treats it as informational, and it projects no status.

worker carries durable NAMES only (identity, task queue, node, deployment, instance, transport) and deliberately NOT the server-process WorkerId: that is a registry counter minted per process, so after a restart the same number names a different worker and in an exported history it names nothing. An attribution that dies with the server would be a lie in a durable log.

Histories recorded before this event existed carry none; readers report such attempts as unattributed rather than inventing a worker. The (workflow, activity, attempt) identity is the one the matching ActivityStarted anchored — a lease adds a fact about that attempt, it never opens a new one.

Fields

envelope: EventEnvelope

Recording metadata for this event.

activity_id: ActivityId

Activity whose attempt was leased.

attempt: u32

One-based attempt number the lease belongs to — the same attempt its Event::ActivityStarted carries.

worker: WorkerAttribution

The worker that accepted the attempt, by durable names.

ActivityAdoptionOffered

Recovery offered a previously dispatched, still-dangling activity attempt back to the worker adoption path.

This is deliberately an OFFER, not a claim that the worker found a live holder: the engine cannot observe a harness process directly. It records the truthful recovery decision — retain and redeliver the same execution identity instead of falsely terminating it as server death. The worker’s single-flight/spawn gate then either joins the holder or starts it when no holder survived.

Fields

envelope: EventEnvelope

Recording metadata for this event.

activity_id: ActivityId

Activity whose dangling attempt is being offered for adoption.

attempt: u32

One-based attempt identity retained across the recovery redelivery.

ActivityCompleted

An activity completed successfully.

Fields

envelope: EventEnvelope

Recording metadata for this event.

activity_id: ActivityId

Activity that produced the result.

result: Payload

Opaque activity result payload.

attempt: u32

One-based activity attempt number that produced this completion (NOI-0).

Matches the attempt on the Event::ActivityStarted of the SAME attempt, so a completed activity carries one consistent attempt readable off both its start and its terminal — the negative-control invariant NOI-0 gates on.

Replay-safety: histories recorded before this field existed have no attempt key on their ActivityCompleted events. Decode defaults the missing value to [LEGACY_ACTIVITY_ATTEMPT] (0) via #[serde(default = ...)] — never panics, never differs run-to-run. The encoding of the existing fields is untouched.

ActivityFailed

An activity attempt failed.

The attempt field together with ActivityError’s retryable or terminal classification lets replay distinguish a retryable interim failure from a terminal one for the same ActivityId.

Fields

envelope: EventEnvelope

Recording metadata for this event.

activity_id: ActivityId

Activity whose attempt failed.

error: ActivityError

Classified activity failure.

attempt: u32

One-based activity attempt number that produced this failure.

ActivityAdvisoryExhausted

An ADVISORY activity spent its whole attempt budget and failed for good (RUNTIME-OPERATIONS.md R5).

The warning the class promises: an advisory action is a side channel (a heartbeat, a notification), so its exhaustion never faults the calling step — but it must never be silent either. This event is that visibility. It ACCOMPANIES the activity’s honest terminal Event::ActivityFailed; it never replaces it, because the activity really did fail and history says so.

Non-terminal for the workflow: it says nothing about the run’s outcome, so status projection deliberately ignores it.

Fields

envelope: EventEnvelope

Recording metadata for this event.

activity_id: ActivityId

Advisory activity whose attempt budget was spent.

activity_type: String

Activity type of the exhausted advisory activity.

reason: String

The last attempt’s failure reason, verbatim — the same string the accompanying terminal Event::ActivityFailed carries.

attempt: u32

One-based number of the attempt that spent the budget.

ActivityFallbackRouted

A policy-refused activity execution was durably routed to a fallback queue.

This event is nonterminal and status-invisible. Its recorded destination is the durable replay answer; recovery reuses it rather than choosing again.

Fields

envelope: EventEnvelope

Recording metadata for this event.

activity_id: ActivityId

Activity whose refusing execution caused the hop.

attempt: u32

One-based execution attempt whose policy refusal caused this hop.

from_task_queue: String

Queue the refusing execution was dispatched on.

to_task_queue: String

Queue the next execution is dispatched on.

fallback_index: u32

Zero-based position consumed from the authored fallback list.

ActivityCancelled

An activity was cancelled as an explicit cancellation outcome.

Fields

envelope: EventEnvelope

Recording metadata for this event.

activity_id: ActivityId

Activity that was cancelled.

attempt: u32

One-based activity attempt number that was cancelled (NOI-0).

Matches the attempt on the Event::ActivityStarted of the SAME attempt, so the cancellation terminal is attributable to a specific attempt exactly like Event::ActivityFailed is.

Replay-safety: histories recorded before this field existed have no attempt key on their ActivityCancelled events. Decode defaults the missing value to [LEGACY_ACTIVITY_ATTEMPT] (0) via #[serde(default = ...)] — never panics, never differs run-to-run. The encoding of the existing fields is untouched.

TimerStarted

A timer was scheduled to fire at a deterministic timestamp.

Fields

envelope: EventEnvelope

Recording metadata for this event.

timer_id: TimerId

Timer selected by workflow code or assigned by the engine.

fire_at: DateTime<Utc>

UTC timestamp at which the timer becomes eligible to fire.

TimerFired

A timer fired.

Fields

envelope: EventEnvelope

Recording metadata for this event.

timer_id: TimerId

Timer that fired.

TimerCancelled

A timer was cancelled as an explicit cancellation outcome.

Fields

envelope: EventEnvelope

Recording metadata for this event.

timer_id: TimerId

Timer that was cancelled.

cause: TimerCancelCause

Who retired the timer. Decides reopen behavior: a TimerCancelCause::CancelTeardown cancellation is re-armed when the run is reopened; a TimerCancelCause::WorkflowIntent cancellation is permanent.

Replay-safety: histories recorded before this field existed have no cause key. Decode defaults the missing value to TimerCancelCause::WorkflowIntent via #[serde(default)] — the pre-field behavior (never resurrected), never panics, never differs run-to-run. The encoding of the existing fields is untouched.

WithTimeoutCompleted

A with_timeout operation reached a durable terminal outcome.

Fields

envelope: EventEnvelope

Recording metadata for this event.

timer_id: TimerId

Timer that bounded the operation.

outcome: WithTimeoutOutcome

Recorded timeout outcome.

result: Option<Payload>

JSON-encoded BEAM term payload for completed operation results.

SignalReceived

A signal was delivered to the workflow.

Fields

envelope: EventEnvelope

Recording metadata for this event.

name: String

Signal name selected by the sender.

payload: Payload

Opaque signal payload.

SignalSent

A signal was sent by this workflow to another workflow.

Fields

envelope: EventEnvelope

Recording metadata for this event.

target_workflow_id: WorkflowId

Target workflow identifier selected by workflow code.

name: String

Signal name selected by workflow code.

payload: Payload

Opaque signal payload.

ChildWorkflowStarted

A child workflow was started.

Fields

envelope: EventEnvelope

Recording metadata for this event.

child_workflow_id: WorkflowId

Child workflow identifier.

workflow_type: String

Child workflow type selected by the parent.

input: Payload

Opaque child workflow input payload.

package_version: PackageVersion

Package version resolved for the child at record time.

The crash-repair sweep and the child’s own start use exactly this recorded version, so the crash path resolves identically to the crash-free path.

ChildWorkflowCompleted

A child workflow completed successfully.

Fields

envelope: EventEnvelope

Recording metadata for this event.

child_workflow_id: WorkflowId

Child workflow that produced the result.

result: Payload

Opaque child workflow result payload.

ChildWorkflowFailed

A child workflow failed terminally.

Fields

envelope: EventEnvelope

Recording metadata for this event.

child_workflow_id: WorkflowId

Child workflow that failed.

error: WorkflowError

Terminal child workflow failure.

ChildWorkflowCancelled

A child workflow was cancelled as an explicit cancellation outcome.

Fields

envelope: EventEnvelope

Recording metadata for this event.

child_workflow_id: WorkflowId

Child workflow that was cancelled.

ScheduleCreated

A schedule resource was created.

Fields

envelope: EventEnvelope

Recording metadata for this event.

schedule_id: ScheduleId

Schedule resource that was created.

config: ScheduleConfig

Persisted schedule configuration.

ScheduleUpdated

A schedule resource was updated.

Fields

envelope: EventEnvelope

Recording metadata for this event.

schedule_id: ScheduleId

Schedule resource that was updated.

config: ScheduleConfig

Updated schedule configuration.

SchedulePaused

A schedule resource was paused.

Fields

envelope: EventEnvelope

Recording metadata for this event.

schedule_id: ScheduleId

Schedule resource that was paused.

ScheduleResumed

A paused schedule resource was resumed.

Fields

envelope: EventEnvelope

Recording metadata for this event.

schedule_id: ScheduleId

Schedule resource that was resumed.

ScheduleDeleted

A schedule resource was deleted.

Fields

envelope: EventEnvelope

Recording metadata for this event.

schedule_id: ScheduleId

Schedule resource that was deleted.

ScheduleTriggered

A schedule tick started a workflow execution.

Fields

envelope: EventEnvelope

Recording metadata for this event.

schedule_id: ScheduleId

Schedule resource that fired.

workflow_id: WorkflowId

Workflow execution started by the schedule tick.

run_id: RunId

Run started by the schedule tick.

CadenceFired

An engine-side cadence window fired for a workloop (workloop brief R1.4/R4.3): the dead-man clock ticked and the fire was durably recorded through the loop’s single Recorder, exactly as any other asynchronous arrival. Nonterminal and status-invisible.

Fields

envelope: EventEnvelope

Recording metadata for this event.

window_seq: u64

One-based sequence number of the cadence window that fired.

IterationClosed

A workloop iteration closed its bounded history generation (R3.1). The iteration’s terminal routes land as health samples against the loop’s invariants per the declared confirms mapping (R3.3). Nonterminal and status-invisible: the accompanying Event::WorkflowContinuedAsNew carries the generation boundary itself.

Fields

envelope: EventEnvelope

Recording metadata for this event.

routes: Vec<String>

Routes the iteration took, in order; the last is its terminal.

health_samples: Vec<HealthSample>

Health samples derived from the routes against the loop’s invariants — every invariant is sampled on the same tick (R2.2).

LoopRetired

A workloop was retired: the declared, recorded way to stop that is not failure (R2.5). Nonterminal and status-invisible on its own — the terminal is the Event::WorkflowCompleted recorded in the SAME append, so retirement reads as an intentional stop, never an outage, without any new terminal machinery or status variant.

Fields

envelope: EventEnvelope

Recording metadata for this event.

reason: String

Declared retirement reason, named at the point of stopping.

WorkflowHatched

A detached top-level workflow was hatched by this run (R13.1). NOT a child: no lifecycle tie, no supervision edge, no awaited terminal — the hatched workflow outlives the hatching iteration and owes it nothing. Nonterminal and status-invisible.

Fields

envelope: EventEnvelope

Recording metadata for this event.

child_workflow_id: WorkflowId

Deterministic identity of the hatched workflow, derived by crate::hatch_workflow_id from (namespace, workflow type, key) — so a retry or replay re-mints the SAME id and a duplicate hatch is a recorded no-op returning it.

key: String

Dedupe key derived from the observed subject (e.g. a task id).

InvariantUnconfirmed

The ONE alarm path (R4.2): an invariant is not confirmed held. A missed window, a red sample, a dead loop, and duration-form silence are all THIS event — cause is a field, never a separate alarm channel. Nonterminal and status-invisible; trigger selectors (Leg 3) arm on named causes as allowlists (R5.2a).

Fields

envelope: EventEnvelope

Recording metadata for this event.

invariant: String

Invariant that is not confirmed held.

cause: AlarmCause

Why confirmation is missing — the evidence class, named.

window_seq: Option<u64>

Cadence window at which tolerance was exceeded; None on a signal-only loop, which has no windows.

last_confirmed_at: Option<DateTime<Utc>>

When the invariant was last confirmed, if ever — part of the alarm’s completeness claim (R4.4): what was sampled and when.

consecutive_unconfirmed: u64

Consecutive unconfirmed samples/windows observed at alarm time — the other half of the completeness claim.

Implementations

impl Event

pub const fn envelope(&self) -> &EventEnvelope

Returns the envelope recorded with this event.

pub const fn seq(&self) -> u64

Returns the monotonic sequence number recorded for this event.

pub const fn recorded_at(&self) -> &DateTime<Utc>

Returns the deterministic recorded timestamp for this event.

pub const fn workflow_id(&self) -> &WorkflowId

Returns the workflow history that owns this event.

Trait Implementations

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Event

fn deserialize<__D>( __deserializer: __D, ) -> Result<Event, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Event

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Event

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Event

impl TS for Event

type WithoutGenerics = Event

If this type does not have generic parameters, then WithoutGenerics should just be Self. If the type does have generic parameters, then all generic parameters must be replaced with a dummy type, e.g ts_rs::Dummy or ().
The only requirement for these dummy types is that EXPORT_TO must be None.

type OptionInnerType = Event

If the implementing type is std::option::Option<T>, then this associated type is set to T. All other implementations of TS should set this type to Self instead.

fn ident(cfg: &Config) -> String

Identifier of this type, excluding generic parameters.

fn docs() -> Option<String>

JSDoc comment to describe this type in TypeScript - when TS is derived, docs are automatically read from your doc comments or #[doc = ".."] attributes

fn name(cfg: &Config) -> String

Name of this type in TypeScript, including generic parameters

fn decl_concrete(cfg: &Config) -> String

Declaration of this type using the supplied generic arguments. The resulting TypeScript definition will not be generic. For that, see TS::decl(). If this type is not generic, then this function is equivalent to TS::decl().

fn decl(cfg: &Config) -> String

Declaration of this type, e.g. type User = { user_id: number, ... }. This function will panic if the type has no declaration.

fn inline(cfg: &Config) -> String

Formats this types definition in TypeScript, e.g { user_id: number }. This function will panic if the type cannot be inlined.

fn inline_flattened(cfg: &Config) -> String

Flatten a type declaration. This function will panic if the type cannot be flattened.

fn visit_generics(v: &mut impl TypeVisitor)

where Event: 'static,

Iterates over all type parameters of this type.

fn output_path() -> Option<PathBuf>

Returns the output path to where T should be exported, relative to the output directory. The returned path does not include any base directory.

fn visit_dependencies(v: &mut impl TypeVisitor)

where Event: 'static,

Iterates over all dependency of this type.

fn dependencies(cfg: &Config) -> Vec<Dependency>

where Self: 'static,

Resolves all dependencies of this type recursively.

fn export(cfg: &Config) -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem. To export this type together with all of its dependencies, use TS::export_all.

fn export_all(cfg: &Config) -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem, together with all of its dependencies. To export only this type, without its dependencies, use TS::export.

fn export_to_string(cfg: &Config) -> Result<String, ExportError>

where Self: 'static,

Manually generate bindings for this type, returning a String. This function does not format the output, even if the format feature is enabled.