🥮 mooncakes.io

    finos/morphir-engine/execution does not have a README file

    LifecycleError

    source
    pub(all) suberror LifecycleError {
      CleanupFailed(Error?, Error)
    }

    SchemePlanError

    source
    pub(all) suberror SchemePlanError {
      AdmissionInvalid(String)
    }

    CallResult

    source
    pub(all) struct CallResult {
      id : String
      actual : 
    Value
      expected : 
    Value    ?
      matches : Bool
      mismatch_path : String?
    }

    CapabilityPolicy

    source
    #alias(AdmissionPolicy)
    pub(all) enum CapabilityPolicy {
      Strict
      Permissive
    } derive(Eq, 
    Debug    )

    Capability validation scope and timing. Existing compiled plans always remain strict. AdmissionPolicy remains a source-compatible alias for existing consumers.

    CapabilityPolicy::equal

    source

    CapabilityPolicy::not_equal

    source
    fn CapabilityPolicy::not_equal(x : CapabilityPolicy, y : CapabilityPolicy) -> Bool

    CapabilityPolicy::to_repr

    source

    Evaluator

    source

    Evaluator::scheme

    source
    fn Evaluator::scheme() -> Evaluator

    Failure

    source
    pub(all) struct Failure {
      phase : String
      cause : Error?
      cleanup : Error?
    }

    Failure::cancelled

    source
    fn Failure::cancelled(self : Failure) -> Bool

    Failure::to_json

    source

    InvocationResults

    source
    pub(all) struct InvocationResults {
      values : Array[
    Value    ]
      evidence : 
    Json
    }

    Providers own executable storage; the engine never assumes a filesystem.

    Plan

    source

    Provider

    source
    pub(all) struct Provider {
      targets : Array[String]
      acquire : () -> Session raise
    }

    Report

    source
    pub(all) struct Report {
      calls : Array[CallResult]
      evidence : 
    Json
      invocation_evidence : 
    Json
      evaluator : String?
      target : String
      comparison : 
    ComparisonPolicy
      extensions : Bytes?
      terminals : Array[Terminal]
      failure : Failure?
    }

    Report::status

    source
    fn Report::status(self : Report) -> String

    Report::successful

    source
    fn Report::successful(self : Report) -> Bool

    Report::to_ion

    source
    fn Report::to_ion(self : Report) -> 
    Ion     raise

    Native rich values and opaque annotations remain Ion in verification receipts.

    Report::to_json

    source

    SchemePlan

    source
    pub struct SchemePlan {
      // private fields
    }

    A validated Scheme call snapshot. No caller-owned arrays or maps are retained.

    SchemePlan::boundary_json

    source

    Fresh observation only; editing it cannot change the validated declarations.

    SchemePlan::evaluate

    source

    SchemePlan::evaluate_outcomes

    source
    fn SchemePlan::evaluate_outcomes(self : SchemePlan, cancelled? : () -> Bool) -> 
    Outcomes     raise

    Execute each captured call and publish only fully validated typed terminals. Cancellation and runtime limits share the file-load and invocation budget.

    SchemePlan::policy

    source
    fn SchemePlan::policy(self : SchemePlan) -> CapabilityPolicy

    SchemePlan::suite

    source

    Return a newly decoded invocation suite, independent of retained arguments.

    SchemePlan::unit

    source

    Return a newly decoded source snapshot. Editing it cannot change this plan.

    SchemePlan::validate_outcomes

    source
    fn SchemePlan::validate_outcomes(self : SchemePlan, outcomes : 
    Outcomes    ) -> Unit raise

    Check complete terminal evidence against the plan's captured public context. This validates evidence; it neither executes nor authenticates a execution.

    SchemePlan::validate_outputs

    source
    fn SchemePlan::validate_outputs(self : SchemePlan, values : Array[
    Value    ]) -> Unit raise

    Session

    source

    Terminal

    source
    pub(all) struct Terminal {
      id : String
      status : String
    }

    cancelled_report

    source

    Produce the existing terminal report when cancellation precedes provider capability discovery. No executable storage or provider is acquired.

    matrix_successful

    source
    fn matrix_successful(required : Array[String], reports : Array[Report]) -> Bool

    A required matrix cannot infer success from a partial set or matching errors.

    plan

    source
    fn plan(unit : 
    IRUnit    , suite : 
    Suite    , target? : String, available_targets? : Array[String]) -> Plan raise

    Validation and pure generation occur before acquiring a provider session.

    plan_scheme

    source

    A separate interpreter plan. Strict selection retains the existing generator gate; permissive selection never constructs a generated library or driver.

    plan_scheme_capabilities

    source

    The policy-aware interpreter boundary. The narrow selected-plan API remains separate so its historical exact contract keeps its original behavior.

    run

    source
    fn run(plan : Plan, provider : Provider, evaluator? : Evaluator?, observer? : 
    Observer    , cancelled? : () -> Bool, comparison? : 
    ComparisonPolicy    ) -> Report raise

    Compatibility API preserves typed causes. Reporting callers use run_report.

    run_report

    source
    fn run_report(plan : Plan, provider : Provider, evaluator? : Evaluator?, observer? : 
    Observer    , cancelled? : () -> Bool, comparison? : 
    ComparisonPolicy    ) -> Report raise

    scheme_entry_boundary

    source

    Discover one complete public type boundary without compiling executable code. This is an input-editor description, not permission to execute. A run must still use plan_scheme_capabilities to validate its source, inputs and policy.

    Source Files