Enum PrepareError 

pub enum PrepareError {
    RuntimeMismatch {
        expected: RuntimeId,
        actual: RuntimeId,
    },
    StaleEpoch {
        prepared: RuntimeEpoch,
        current: RuntimeEpoch,
    },
    InputSignature {
        source: InputSignatureError,
    },
    ShapeGuard {
        source: ShapeGuardError,
    },
    Specialization {
        source: SpecializationError,
    },
    NoEligibleEngine {
        constraint: ProgramPlacementConstraint,
    },
    NoExecutableEngine {
        engine_id: EngineId,
    },
    NoInputIngress {
        input_index: usize,
        placement: Placement,
    },
    DispatchSearchBudgetExceeded {
        attempts: usize,
        limit: usize,
    },
    MissingTransferProvider {
        instruction_index: usize,
        value_slot: usize,
        destination_endpoint: TransferEndpoint,
        available_source_endpoints: Vec<TransferEndpoint>,
    },
    ResolvedEngineUnavailable {
        engine_id: EngineId,
    },
    Unsupported {
        reason: UnsupportedReason,
    },
    DeterminismUnsupported {
        engine_id: EngineId,
    },
    ProviderContract {
        source: ProviderContractError,
    },
    PreparationCycle {
        key: PreparationKeySummary,
    },
    NestedPreparationUnsupported {
        parent: PreparationKeySummary,
        requested: PreparationKeySummary,
    },
    CacheInFlightCapacityExceeded {
        in_flight: usize,
        queued_distinct_keys: usize,
    },
    CacheState {
        source: RuntimeStateError,
    },
    Engine {
        source: Arc<dyn Error + Send + Sync>,
    },
}

Reports failures while preparing runtime execution artifacts.

Examples

use tenferro_runtime::{InputSignature, PrepareError, SpecializationRequirements};

let error = SpecializationRequirements::polymorphic(1)
    .project(&InputSignature::new(Vec::new()))
    .unwrap_err();
assert!(matches!(error, PrepareError::Specialization { .. }));

Variants

RuntimeMismatch

Prepared artifact belongs to a different runtime.

Fields

expected: RuntimeId

Runtime expected by the prepared artifact.

actual: RuntimeId

Runtime currently executing.

StaleEpoch

Prepared artifact was created for a stale runtime epoch.

Fields

prepared: RuntimeEpoch

Epoch captured by the prepared artifact.

current: RuntimeEpoch

Runtime’s current epoch.

InputSignature

Input signature construction failed.

Fields

source: InputSignatureError

Typed source error.

ShapeGuard

Semantic shape guards failed.

Fields

source: ShapeGuardError

Typed source error.

Specialization

Signature projection through specialization requirements failed.

Fields

source: SpecializationError

Typed source error.

NoEligibleEngine

No eligible engine matched the placement and capability constraints.

Fields

constraint: ProgramPlacementConstraint

Placement constraint that could not be satisfied.

NoExecutableEngine

A preparation-only engine advertised the required capability but cannot produce an executable prepared schedule.

Fields

engine_id: EngineId

Engine whose preparation capability cannot be used for execution.

NoInputIngress

No eligible engine declared an ingress compatible with an input placement.

Fields

input_index: usize

Input position in the compiled-program signature.

placement: Placement

Placement rejected by every eligible engine ingress.

DispatchSearchBudgetExceeded

Placement resolution exceeded its bounded combination-search budget.

Fields

attempts: usize

Number of dispatch combinations attempted.

limit: usize

Configured hard limit for this search.

MissingTransferProvider

No available copy of a value has a registered direct transfer provider to the storage required by its consumer.

Fields

instruction_index: usize

Staged instruction whose input cannot be reached.

value_slot: usize

Value slot required by the instruction.

destination_endpoint: TransferEndpoint

Destination endpoint required by the instruction.

available_source_endpoints: Vec<TransferEndpoint>

Endpoints retaining an available copy.

ResolvedEngineUnavailable

A resolved placement references an engine absent from its preparation snapshot.

Fields

engine_id: EngineId

Engine referenced by the resolved placement.

Unsupported

No provider supports this operation under the requested constraints.

Fields

reason: UnsupportedReason

Deterministic unsupported reason.

DeterminismUnsupported

Deterministic execution was requested from an engine that cannot provide it.

Fields

engine_id: EngineId

Engine that cannot satisfy deterministic preparation.

ProviderContract

Provider returned a value that violates the runtime preparation contract.

Fields

source: ProviderContractError

Typed provider-contract source.

PreparationCycle

Preparation recursion reached an unsupported cycle.

Fields

key: PreparationKeySummary

Bounded summary of the recursive key.

NestedPreparationUnsupported

Preparation recursively requested a different key.

Fields

parent: PreparationKeySummary

Parent key currently preparing on this thread.

requested: PreparationKeySummary

Nested key requested by the producer.

CacheInFlightCapacityExceeded

The preparation cache is full of active/queued distinct keys.

Fields

in_flight: usize

Active distinct preparations.

queued_distinct_keys: usize

Queued distinct keys.

CacheState

Runtime cache state could not be accessed.

Fields

source: RuntimeStateError

Runtime state source.

Engine

Engine or internal preparation source failed.

Fields

source: Arc<dyn Error + Send + Sync>

Shared typed source.

Trait Implementations

impl Debug for PrepareError

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

Formats the value using the given formatter.

impl Display for PrepareError

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

Formats the value using the given formatter.

impl Error for PrepareError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.