Struct RunRequest 

pub struct RunRequest<'a> {
    pub code: &'a str,
    pub intent: Option<&'a str>,
    pub mode: RunMode,
    pub detail: ReceiptDetail,
    pub budget: ExecutionBudget,
}

One borrowed native execution request.

Fields

code: &'a str

Exact Monty source executed against virtual state.

intent: Option<&'a str>

Optional out-of-band intent bound into transaction identity.

mode: RunMode

Preview-only or deterministic auto-commit behavior.

detail: ReceiptDetail

Compact or complete canonical change detail.

budget: ExecutionBudget

Independent execution caps for this request.

Implementations

impl<'a> RunRequest<'a>

pub fn new(code: &'a str) -> Self

Construct a safe preview request with default resource caps.

Examples found in repository

examples/native_benchmark.rs (line 198)

fn sample(runtime: &Runtime, code: &str, intent: &str) -> Result<Sample, Box<dyn Error>> {
    let started = Instant::now();
    let receipt = runtime.preview(RunRequest::new(code).with_intent(intent))?;
    let wall_ns = elapsed_ns(started);
    if receipt.state == TransactionState::AutoApproved
        && !runtime.discard_preview(receipt.transaction)?
    {
        return Err(io::Error::other("runtime did not retain its auto-approved preview").into());
    }
    Ok(Sample {
        wall_ns,
        internal_ns: receipt.timings.total_ns,
        stages: receipt.timings.into(),
        state: receipt.state,
        changed_paths: u64::try_from(receipt.changed_paths).unwrap_or(u64::MAX),
    })
}

examples/staged_release.rs (line 38)

fn main() -> Result<(), Box<dyn Error>> {
    let workspace = Workspace::new()?;
    fs::create_dir(workspace.0.join("templates"))?;
    fs::write(
        workspace.0.join("templates/service.toml"),
        b"channel = \"dev\"\n",
    )?;
    let runtime = Runtime::open(RuntimeConfig::new(&workspace.0))?;
    let code = include_str!("staged_release.monty");
    let preview = runtime.preview(RunRequest::new(code).with_detail(ReceiptDetail::Full))?;
    assert!(matches!(
        preview.decision,
        RuntimeDecision::PendingApproval(_)
    ));
    assert_eq!(preview.changed_paths, 3);
    assert!(!workspace.0.join("release").exists());
    assert_eq!(
        preview
            .changes
            .iter()
            .map(|entry| entry.path.as_str())
            .collect::<Vec<_>>(),
        ["release", "release/README.txt", "release/app.toml"]
    );
    let now = u64::try_from(SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis())?;
    // A rename is a semantic risk even if it only rearranges generated files.
    // Production code must authenticate a reviewer before this trusted call.
    runtime.approve(
        preview.transaction,
        PrincipalId::digest_label("fixture-reviewer"),
        now,
        now + 30_000,
    )?;
    let committed = runtime.commit(preview.transaction, now)?;
    assert_eq!(committed.transaction, preview.transaction);
    assert!(committed.commit.is_some());
    assert_eq!(
        fs::read_to_string(workspace.0.join("release/app.toml"))?,
        "channel = \"stable\"\n"
    );
    assert_eq!(
        fs::read_to_string(workspace.0.join("release/README.txt"))?,
        "channel=stable\n"
    );
    assert!(!workspace.0.join("release/service.toml").exists());
    println!(
        "Committed {} reviewed paths: {}",
        committed.changed_paths, committed.transaction
    );
    Ok(())
}

pub const fn with_intent(self, intent: &'a str) -> Self

Bind an out-of-band intent to this request.

Examples found in repository

examples/native_benchmark.rs (line 198)

fn sample(runtime: &Runtime, code: &str, intent: &str) -> Result<Sample, Box<dyn Error>> {
    let started = Instant::now();
    let receipt = runtime.preview(RunRequest::new(code).with_intent(intent))?;
    let wall_ns = elapsed_ns(started);
    if receipt.state == TransactionState::AutoApproved
        && !runtime.discard_preview(receipt.transaction)?
    {
        return Err(io::Error::other("runtime did not retain its auto-approved preview").into());
    }
    Ok(Sample {
        wall_ns,
        internal_ns: receipt.timings.total_ns,
        stages: receipt.timings.into(),
        state: receipt.state,
        changed_paths: u64::try_from(receipt.changed_paths).unwrap_or(u64::MAX),
    })
}

pub const fn with_mode(self, mode: RunMode) -> Self

Select preview or deterministic auto-commit behavior.

pub const fn with_detail(self, detail: ReceiptDetail) -> Self

Select compact or complete receipt detail.

Examples found in repository

examples/staged_release.rs (line 38)

fn main() -> Result<(), Box<dyn Error>> {
    let workspace = Workspace::new()?;
    fs::create_dir(workspace.0.join("templates"))?;
    fs::write(
        workspace.0.join("templates/service.toml"),
        b"channel = \"dev\"\n",
    )?;
    let runtime = Runtime::open(RuntimeConfig::new(&workspace.0))?;
    let code = include_str!("staged_release.monty");
    let preview = runtime.preview(RunRequest::new(code).with_detail(ReceiptDetail::Full))?;
    assert!(matches!(
        preview.decision,
        RuntimeDecision::PendingApproval(_)
    ));
    assert_eq!(preview.changed_paths, 3);
    assert!(!workspace.0.join("release").exists());
    assert_eq!(
        preview
            .changes
            .iter()
            .map(|entry| entry.path.as_str())
            .collect::<Vec<_>>(),
        ["release", "release/README.txt", "release/app.toml"]
    );
    let now = u64::try_from(SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis())?;
    // A rename is a semantic risk even if it only rearranges generated files.
    // Production code must authenticate a reviewer before this trusted call.
    runtime.approve(
        preview.transaction,
        PrincipalId::digest_label("fixture-reviewer"),
        now,
        now + 30_000,
    )?;
    let committed = runtime.commit(preview.transaction, now)?;
    assert_eq!(committed.transaction, preview.transaction);
    assert!(committed.commit.is_some());
    assert_eq!(
        fs::read_to_string(workspace.0.join("release/app.toml"))?,
        "channel = \"stable\"\n"
    );
    assert_eq!(
        fs::read_to_string(workspace.0.join("release/README.txt"))?,
        "channel=stable\n"
    );
    assert!(!workspace.0.join("release/service.toml").exists());
    println!(
        "Committed {} reviewed paths: {}",
        committed.changed_paths, committed.transaction
    );
    Ok(())
}

pub const fn with_budget(self, budget: ExecutionBudget) -> Self

Replace all request-scoped execution caps.

Trait Implementations

impl<'a> Clone for RunRequest<'a>

fn clone(&self) -> RunRequest<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for RunRequest<'a>

impl<'a> Debug for RunRequest<'a>

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

Formats the value using the given formatter.