Enum Resolution 

pub enum Resolution {
    NativeCross,
    CrossDocker,
    Emulate {
        docker_platform: String,
    },
    Offload {
        target: String,
    },
    Skip {
        reason: String,
    },
}

The verdict of resolve for one step’s platform triple-set (R531-F3, W222): how QED should satisfy a “build for target T” / “pull image P” step on the host it actually runs on.

The ordering encodes W222’s cross-compile first, emulate last ladder: a target that can be built with a host-native linker always is; emulation is an explicit, named fallback for the residue, never the silent default.

Variants

NativeCross

Tier 1 — host-native cross-compile (cargo-zigbuild / musl-cross), no container, no emulation. The default path for the overwhelming majority of Rust targets (W222: ~99%). Also covers a plain host-native build (target absent or host-arch).

CrossDocker

Tier 2 — cross via a host-arch toolchain container. The toolchain runs in a container, but the container’s arch matches the host so this is genuinely emulation-free (unlike a foreign-arch cross image, which resolves to Emulate). Chosen when the target isn’t host-native crossable but a host-arch cross image can build it.

Emulate

Tier 3 — QEMU / platform virtualization. The step pulls a foreign-arch image (docker_platform) and runs it under emulation. This is the W222 mesofact case (linux/amd64 cross-rs image on an arm64 host) and multi-arch buildx image builds, where there is no cross-compile for an image. Slow and explicit — the preflight (T4) flags it so the operator sees the cost before the run.

Fields

docker_platform: String

Offload

No local path: the target can’t be host-native crossed and no container can build it here (e.g. *-apple-darwin from a Linux host) — it needs a real runner capable of building target. The scheduler picks the concrete remote (P2+); the verdict just names what’s needed.

Fields

target: String

Skip

Nothing resolvable: a foreign target with an unrecognized arch and no container — QED can neither cross it, emulate it, nor name a runner for it. Carries a human-readable reason for the preflight.

Fields

reason: String

Implementations

impl Resolution

pub fn label(&self) -> String

Short human label with the cost/mechanism parenthetical, for the T4 portability preflight and the QED detail pane.

pub fn is_slow_or_unsatisfiable(&self) -> bool

True for the emulation / offload tiers — the verdicts that mean “this step will not run fast (or at all) on this host”. The preflight uses this to flag divergence; tier 1/2 (NativeCross / CrossDocker) are the emulation-free happy path.

Trait Implementations

impl Clone for Resolution

fn clone(&self) -> Resolution

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Resolution

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

Formats the value using the given formatter.

impl Eq for Resolution

impl PartialEq for Resolution

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Resolution