Struct StandardWebDecisionRuntime 

pub struct StandardWebDecisionRuntime { /* private fields */ }

Single-use target runtime for evidence collection and deterministic decisions.

Examples

use url::Url;
use termivar_scanner::StandardWebDecisionRuntime;

let target = Url::parse("https://example.test/")?;
let mut runtime = StandardWebDecisionRuntime::builder(target)
    .planning_budget(100)
    .risk_limit(40)
    .max_action_cycles(8)
    .enable_api_reasoning()
    .build()?;

let report = runtime.analyze().await?;
println!("terminal command: {:?}", report.terminal());

Implementations

impl StandardWebDecisionRuntime

pub async fn run_api_visibility_pair( &mut self, request: ApiVisibilityDifferentialRequest, ) -> Result<RuntimeApiVisibilityRunReport, RuntimeApiVisibilityExecutionError>

Executes one authorized, same-target JSON authorization-context pair.

Both legs use isolated broker pools backed by the runtime’s shared accounting authority, are charged as active verifications, and are independently cancellation/budget bounded. Only two complete JSON views reach Comparator V3 and atomic observation ingestion. A difference can yield ApiVisibilityDifferentialDisposition::AwaitHumanReview, never a vulnerability verdict or decision-loop success.

Once pre-I/O configuration and target checks pass, this operation consumes the runtime’s single-use execution right even on cancellation or transport failure. Use another runtime instance for the standard endpoint analysis workflow.

Examples

use url::Url;
use termivar_scanner::{
    ApiComparisonProfile, ApiVisibilityContextProbe,
    ApiVisibilityDifferentialRequest, ApiVisibilityDimension, EntityId,
    HttpProbe, HttpProbeMethod, StandardWebDecisionRuntime,
};

let target = Url::parse("https://example.test/api/account")?;
let control = HttpProbe::new(target.clone(), HttpProbeMethod::Get)?
    .with_header("authorization", "Bearer control-context")?;
let candidate = HttpProbe::new(target.clone(), HttpProbeMethod::Get)?
    .with_header("authorization", "Bearer candidate-context")?;
let request = ApiVisibilityDifferentialRequest::new(
    "comparison-1",
    EntityId::new("resource:account")?,
    ApiVisibilityContextProbe::new("context:control", control)?,
    ApiVisibilityContextProbe::new("context:candidate", candidate)?,
    ["authorization"],
    ApiComparisonProfile::default(),
    ApiVisibilityDimension::Fields,
    1_800_000_000_000,
)?;
let mut runtime = StandardWebDecisionRuntime::builder(target)
    .enable_api_reasoning()
    .build()?;

let report = runtime.run_api_visibility_pair(request).await?;
assert_eq!(report.audit().usage().total_requests(), 2);

impl StandardWebDecisionRuntime

pub fn ingest_api_visibility( &mut self, observation: ApiVisibilityObservation, expected_resource: &EntityId, ) -> Result<ApiObservationReceipt, RuntimeApiVisibilityError>

Commits one authorized, host-paired API visibility observation.

The runtime must have API reasoning enabled. Disabled runtimes reject the call before any write. The host remains responsible for authenticating the producer, authorizing both compared contexts, and asserting that expected_resource is the same logical resource in both views.

This boundary accepts no raw response, URL, header, credential, or principal. It preserves the observation’s isolated comparison subject and never rewrites it to the runtime endpoint subject. Ingestion performs no request and does not change runtime usage, experience, planning, or decision-session state. Exact replay remains idempotent.

Examples

use url::Url;
use termivar_scanner::{
    ApiSurfaceKind, ApiVisibilityComparison, ApiVisibilityDimension,
    ApiVisibilityPairKind, ApiVisibilityResult, ApiVisibilityReviewQuery,
    ConfidenceScore, EntityId, StandardWebDecisionRuntime,
};

let resource = EntityId::new("resource:account-42")?;
let observation = ApiVisibilityComparison::new(
    "comparison-17",
    ApiSurfaceKind::JsonHttp,
    ApiVisibilityPairKind::AuthorizationContext,
    ApiVisibilityResult::Different,
    ApiVisibilityDimension::Fields,
    "anonymous-view",
    "member-view",
    resource.as_str(),
)?
.to_observation("host.api-comparator", ConfidenceScore::MAX)?;
let mut runtime = StandardWebDecisionRuntime::builder(
    Url::parse("https://example.test/api/accounts/42")?,
)
.enable_api_reasoning()
.build()?;

runtime.ingest_api_visibility(observation, &resource)?;
let page = runtime.api_visibility_reviews(
    &resource,
    &ApiVisibilityReviewQuery::default(),
)?;
assert_eq!(page.reviews().len(), 1);

pub fn api_visibility_reviews( &self, resource: &EntityId, query: &ApiVisibilityReviewQuery, ) -> Result<ApiVisibilityReviewPage, RuntimeApiVisibilityError>

Returns one cursor-bounded page of paired-visibility reviews.

Review projection is available only when API reasoning was explicitly enabled. It reads the runtime’s comparison subjects without feeding their hypotheses into the endpoint planner or decision session.

impl StandardWebDecisionRuntime

pub fn builder(target: Url) -> StandardWebDecisionRuntimeBuilder

Starts a target-scoped runtime builder.

pub fn target(&self) -> &Url

Returns the authorized target supplied by the host.

pub fn subject(&self) -> &EntityId

Returns the stable endpoint subject used by every runtime layer.

pub fn installation(&self) -> StandardWebDecisionInstallReport

Returns the standard profile installation receipt.

pub fn api_reasoning_installation(&self) -> Option<StandardApiInstallReport>

Returns the passive API reasoning installation receipt when enabled.

pub fn unsupported_actions(&self) -> &BTreeSet<String>

Returns actions omitted because no executor was installed for them.

pub fn knowledge(&self) -> &KnowledgeBase

Returns the runtime knowledge base for audit and reporting.

pub fn experience(&self) -> &ExperienceStore

Returns learned target-scoped outcomes.

pub fn session(&self) -> &DecisionSession

Returns the replayable session state.

pub const fn budget(&self) -> RuntimeBudget

Returns the immutable resource envelope for this session.

pub fn usage(&self) -> &RuntimeUsage

Returns current resource accounting, including failed request attempts.

pub fn cancellation_token(&self) -> CancellationToken

Returns a clone of the host-owned cancellation token.

Cancelling the returned token stops this single-use runtime at its next async or deterministic planning boundary.

pub fn has_started(&self) -> bool

Returns whether execution has been attempted.

pub fn into_experience(self) -> ExperienceStore

Consumes the runtime and returns its learned experience.

pub async fn analyze( &mut self, ) -> Result<StandardWebDecisionRunReport, StandardWebDecisionRuntimeError>

Collects bootstrap evidence and drives commands to a terminal state.

The runtime is single-use even when execution returns an error. This prevents a caller from replaying a partially committed network session under the same deterministic case identities.