Struct BulkCtx 

pub struct BulkCtx<T> {
    pub input: T,
    pub batch_id: String,
    pub key: String,
    pub run_id: String,
    pub headers: HashMap<String, String>,
    /* private fields */
}

Per-item execution context handed to Pipeline::run.

Wraps the typed input together with the durable per-item memo, a cost accumulator, the run’s cooperative cancellation token, the delivery’s lease handle, the item’s staged KV effects and read access to the caller KV namespace.

Fields

input: T

The deserialized input item for this run.

batch_id: String

The batch this item belongs to.

key: String

The item’s key: the value of BulkBuilder::key_fn for the input, or the positional item-{i} default.

run_id: String

The workflow run identifier of this item, derived from the batch id and the key.

headers: HashMap<String, String>

Submitter-supplied metadata threaded through from the bulk run.

Implementations

impl<T> BulkCtx<T>

pub fn memo(&self) -> &Memo

The item’s durable memo. Wrap each expensive phase of Pipeline::run in Memo::memoized or Memo::memoized_by_content so a retried item reads the completed phases back. Calls to record_cost inside a memoized future run only when the future runs; use memoized_with_cached_cost when memoized results must also contribute to the cost report.

pub async fn memoized_with_cached_cost<R, F, E>( &self, key: &str, f: F, ) -> Result<R, E>

where R: Serialize + DeserializeOwned, F: Future<Output = Result<(R, CostReport), E>>, E: From<Error>,

Run f once and memoize both its value and counters under key, or return the memoized value and replay its counters on a retry.

f returns (value, cost), and the counters are recorded after memoization returns, so they are included whether the phase runs or reads its memo entry.

pub async fn memoized_by_content_with_cached_cost<K, R, F, E>( &self, input: &K, f: F, ) -> Result<R, E>

where K: Serialize + ?Sized, R: Serialize + DeserializeOwned, F: Future<Output = Result<(R, CostReport), E>>, E: From<Error>,

Self::memoized_with_cached_cost under Memo::content_key of input.

pub fn record_cost(&self, metric: &str, amount: f64)

Add amount to the cost counter named metric for this item. The per-item totals roll up into the batch-level ProgressSnapshot and BulkReport.

pub fn cancel_token(&self) -> &CancellationToken

The run’s cooperative cancellation token. Watch it to short-circuit a long-running step when the bulk run is draining (e.g. on spot preemption); see crate::Step::cancel_token.

pub fn lease(&self) -> &LeaseHandle

The lease handle for this item’s delivery. A long-running pipeline calls LeaseHandle::ensure_at_least at progress points (or once, with a slow call’s timeout, before issuing it) so the item is not re-queued while it still runs; see crate::Step::lease.

pub fn effects(&self) -> &EffectsHandle

The item’s staged application KV effects. Writes and deletes staged here are applied atomically with the item’s successful completion; an item that fails applies nothing, and a staged value must be correct when applied more than once, since delivery is at-least-once. See EffectsHandle for the staging rules.

pub async fn kv_get(&self, key: &[u8]) -> Result<Option<Vec<u8>>, StepError>

Read the committed value under key from the caller KV namespace, None when no value exists. Effects staged by this item become readable only once its completion commits; see crate::KvReadHandle for the read semantics.