Ghostlight/crates/ghostlight/src/mailbox.rs
Meta Vens 5277973afb Verse run: a tick is (world, clock-advance ordinal), its span and cells frozen in a tick document
The tick index is the world's TimeAdvanced count, read through a driver-only
mailbox door, and derive_cover takes it instead of now and the span. A tick
document ghostlight.verse_tick.v1 is written before the first cell and read by
any later run, so a resume under another span or cover budget finishes the open
tick as it was opened. The clock id is clock_command_id(world, ordinal) and is
pinned by a test. TickIndex::of and run_tick's per-call derive_cover are gone.

Fixes findings resume-rederives-tick-identity, tick-identity-collides-across-spans,
clock-id-unpinned. Not yet built or run at this commit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-11 12:11:07 +02:00

1647 lines
60 KiB
Rust

use super::{
AgencyGraph, AuthenticatedCaller, CallerId, CommandBody, CommandEnvelope, CommandId,
ConsumerId, CreateWorld, CreateWorldIntent, CreationReceipt, DecisionInvocation,
DecisionOpportunity, Declaration, DraftHandle, EntityDeclaration, EntityKind, JurisdictionKey,
KernelError, NewController, OperatorEvent, PatchAnswer, PrincipalCommandIntent, PrincipalId,
EntityId, Ref, SubjectDeclaration, SubjectKind, SubmitReceipt, SystemCapability, TickMinutes, WorldId,
WorldKernel, WorldPatch, WorldPhase, WorldScaleIntentRef, WorldSnapshot, journal,
patch::kernel_speak_grant, prepare_creation,
verse::{CreateVerseWorldIntent, VerseGenesisError},
};
use crate::VerifiedPrincipalEvidence;
use chrono::Utc;
use std::path::Path;
use thiserror::Error;
use tokio::sync::{mpsc, oneshot};
use tokio::task::JoinHandle;
/// The one place a world starts with, so its first subjects can hear each
/// other. A world that wants more declares them through the patch lane.
const GENESIS_PLACE: &str = "commons";
/// The commons every genesis declares, the one room its first subjects share.
pub(crate) fn commons_declaration() -> Declaration {
Declaration::Entity(EntityDeclaration {
handle: DraftHandle::new(GENESIS_PLACE),
label: "The Commons".into(),
kind: EntityKind::Place,
container: None,
})
}
/// Where a genesis subject stands.
pub(crate) fn commons_ref() -> Ref<EntityId> {
Ref::Draft(DraftHandle::new(GENESIS_PLACE))
}
const REQUEST_CAPACITY: usize = 32;
#[derive(Clone, Debug)]
pub struct WorldMailbox {
sender: mpsc::Sender<Request>,
}
enum OwnedWorld {
Empty(journal::EmptyWorldJournal),
Live(WorldKernel),
}
enum Request {
Create {
input: CreateWorld,
authenticated: AuthenticatedCaller,
reply: oneshot::Sender<Result<CreationReceipt, KernelError>>,
},
Submit {
command: CommandEnvelope,
authenticated: AuthenticatedCaller,
reply: oneshot::Sender<Result<SubmitReceipt, KernelError>>,
},
/// An opportunity-bearing command. Its scope digest is the whole binding, so
/// the envelope revision is stamped here, inside the owner task, where there
/// is no race — a caller-supplied revision would be a second, stricter
/// binding for a proposal the digest already binds.
SubmitStamped {
command_id: CommandId,
caller: CallerId,
body: CommandBody,
authenticated: AuthenticatedCaller,
reply: oneshot::Sender<Result<SubmitReceipt, KernelError>>,
},
Snapshot {
reply: oneshot::Sender<Result<WorldSnapshot, KernelError>>,
},
/// The human operator's story feed. Separate from `Snapshot` so no
/// controller lane can reach an unscoped event log.
OperatorLog {
reply: oneshot::Sender<Result<Vec<OperatorEvent>, KernelError>>,
},
/// The scheduler's adjacency projection. Separate from `Snapshot` for the
/// same reason the story feed is: it is wider than any subject view, and
/// only the tick driver may hold it.
AgencyGraph {
reply: oneshot::Sender<Result<AgencyGraph, KernelError>>,
},
/// The tick driver's opportunity list. Separate from `Snapshot` so the
/// list a cover is derived from has one door, held by the driver.
Opportunities {
reply: oneshot::Sender<Result<Vec<DecisionOpportunity>, KernelError>>,
},
/// The tick ordinal's one door: how many clock advances the world has
/// committed. Held by the tick driver, as `Opportunities` is.
ClockAdvances {
reply: oneshot::Sender<Result<u64, KernelError>>,
},
ControllerReceipt {
command_id: CommandId,
opportunity: super::DecisionOpportunity,
invocation: super::DecisionInvocation,
reply: oneshot::Sender<Result<Option<super::CommitReceipt>, KernelError>>,
},
ControllerDeclineReceipt {
command_id: CommandId,
opportunity: super::DecisionOpportunity,
reply: oneshot::Sender<Result<Option<super::CommitReceipt>, KernelError>>,
},
}
#[derive(Debug, Error)]
pub enum MailboxError {
#[error("world owner mailbox is unavailable")]
Unavailable,
#[error("world command outcome is unknown after enqueue: {command_id:?}")]
OutcomeUnknown { command_id: CommandId },
#[error(transparent)]
Kernel(#[from] KernelError),
}
impl WorldMailbox {
pub fn open(path: impl AsRef<Path>) -> Result<(Self, JoinHandle<()>), KernelError> {
let owned = match journal::WorldJournal::open_owner(path.as_ref())? {
journal::JournalOpen::Empty(empty) => OwnedWorld::Empty(empty),
journal::JournalOpen::Live { journal, state } => {
OwnedWorld::Live(WorldKernel { state, journal })
}
};
let (sender, receiver) = mpsc::channel(REQUEST_CAPACITY);
let task = tokio::spawn(run_owner(owned, receiver));
Ok((Self { sender }, task))
}
pub async fn create(
&self,
input: CreateWorldIntent,
principal: &VerifiedPrincipalEvidence,
) -> Result<CreationReceipt, MailboxError> {
let principal_id = PrincipalId::new(principal.account_subject_hash());
// Ingress owns label normalization; the reducer only admits canonical
// labels.
// A world needs a room. Co-located speech fills the place its speaker
// stands in, so ingress declares one and stands every genesis subject
// there rather than creating a world where nobody can be heard.
let declare = |handle: &str, label: String, kind, controller| {
Declaration::Subject(SubjectDeclaration {
handle: DraftHandle::new(handle),
label: label.trim().to_owned(),
kind,
controller,
affordances: kernel_speak_grant(),
position: Some(commons_ref()),
import_key: None,
})
};
// Roots stand beside the commons, not inside it: a root contained by
// the commons would make every commons subject count toward that root
// through `covers_place`, and the world's first person belongs to no
// jurisdiction's population target. The owner subject lands in
// `Uncovered`, visible and reducing nothing.
let mut declarations = vec![
commons_declaration(),
declare(
"first-person",
input.human_subject_label,
SubjectKind::Person,
NewController::Human {
principal: principal_id.clone(),
},
),
];
if let Some(label) = input.narrative_persona_label {
declarations.push(declare(
"narrative-persona",
label,
SubjectKind::Person,
NewController::NarrativePersona,
));
}
if let Some(label) = input.operational_agent_label {
declarations.push(declare(
"operational-agent",
label,
SubjectKind::Institution,
NewController::OperationalAgent,
));
}
for root in &input.jurisdictions {
declarations.push(Declaration::Entity(EntityDeclaration {
handle: DraftHandle::new(root.handle.clone()),
label: root.label.trim().to_owned(),
kind: EntityKind::Place,
container: None,
}));
}
let scale_intent = WorldScaleIntentRef {
targets: input.targets,
jurisdictions: input
.jurisdictions
.iter()
.map(|root| (DraftHandle::new(root.handle.clone()), root.permille))
.collect(),
};
self.create_authenticated(
CreateWorld {
id: input.id,
owner: principal_id.clone(),
title: input.title,
brief: input.brief,
patch: WorldPatch {
declarations,
operations: Vec::new(),
evidence: Vec::new(),
},
scale_intent,
lens_weights: input.lens_weights,
grammar: None,
},
AuthenticatedCaller::verified_principal(principal_id),
)
.await
}
async fn create_authenticated(
&self,
input: CreateWorld,
authenticated: AuthenticatedCaller,
) -> Result<CreationReceipt, MailboxError> {
let command_id = input.id;
let (reply, response) = oneshot::channel();
self.sender
.send(Request::Create {
input,
authenticated,
reply,
})
.await
.map_err(|_| MailboxError::Unavailable)?;
response
.await
.map_err(|_| MailboxError::OutcomeUnknown { command_id })?
.map_err(mailbox_outcome)
}
/// Creates the canonical Aetheria verse world through the same
/// authenticated creation `create` uses.
pub async fn create_verse(
&self,
intent: CreateVerseWorldIntent,
principal: &VerifiedPrincipalEvidence,
) -> Result<CreationReceipt, VerseGenesisError> {
let principal_id = PrincipalId::new(principal.account_subject_hash());
let input = intent.lower(principal_id.clone())?;
Ok(self
.create_authenticated(input, AuthenticatedCaller::verified_principal(principal_id))
.await?)
}
/// A wall-clock read at the boundary a request crosses into the mailbox is
/// ingress, not reduce: the reducer stays deterministic over its journal,
/// and this is the one place a caller's own claim of continued authority
/// is checked against the moment it is spent, not the moment it was
/// minted. `VerifiedPrincipalEvidence` can outlive one request inside a
/// long-running port such as `SeedPort`, so this is the gate that keeps
/// holding it bounded by the session's own expiry.
pub async fn submit_principal(
&self,
intent: PrincipalCommandIntent,
principal: &VerifiedPrincipalEvidence,
) -> Result<SubmitReceipt, MailboxError> {
if principal.valid_until() <= Utc::now() {
return Err(MailboxError::Kernel(KernelError::Unauthorized));
}
let principal_id = PrincipalId::new(principal.account_subject_hash());
let caller = CallerId::Principal(principal_id.clone());
let authenticated = AuthenticatedCaller::verified_principal(principal_id);
if matches!(
intent.body,
CommandBody::ExerciseDecision { .. } | CommandBody::DeclineDecision { .. }
) {
return self
.submit_stamped(intent.id, caller, intent.body, authenticated)
.await;
}
self.submit_authenticated(
CommandEnvelope {
id: intent.id,
world_id: intent.world_id,
expected_revision: intent.expected_revision,
caller,
body: intent.body,
},
authenticated,
)
.await
}
/// Stamps both `world_id` and `expected_revision` from the live kernel. The
/// mailbox owns exactly one world, so there is no other world a caller could
/// have meant, and asking a controller runner to restate an ID it cannot
/// choose would only invent a way to be wrong. The consequence is that
/// `WorldKernel::submit`'s `WorldMismatch` check cannot fire on this path:
/// scope, not world identity, is what fails an opportunity-bearing command
/// here, and `soul_a_stamped_submission_still_fails_closed_on_a_foreign_scope`
/// is the proof that it still fails closed.
async fn submit_stamped(
&self,
command_id: CommandId,
caller: CallerId,
body: CommandBody,
authenticated: AuthenticatedCaller,
) -> Result<SubmitReceipt, MailboxError> {
let (reply, response) = oneshot::channel();
self.sender
.send(Request::SubmitStamped {
command_id,
caller,
body,
authenticated,
reply,
})
.await
.map_err(|_| MailboxError::Unavailable)?;
response
.await
.map_err(|_| MailboxError::OutcomeUnknown { command_id })?
.map_err(mailbox_outcome)
}
async fn submit_authenticated(
&self,
command: CommandEnvelope,
authenticated: AuthenticatedCaller,
) -> Result<SubmitReceipt, MailboxError> {
let command_id = command.id;
let (reply, response) = oneshot::channel();
self.sender
.send(Request::Submit {
command,
authenticated,
reply,
})
.await
.map_err(|_| MailboxError::Unavailable)?;
response
.await
.map_err(|_| MailboxError::OutcomeUnknown { command_id })?
.map_err(mailbox_outcome)
}
/// Controller-only commit port. This method is visible inside the world
/// subtree, where the controller organ lives, but not to runtime ingress.
pub(super) async fn submit_controller(
&self,
command_id: CommandId,
opportunity: &DecisionOpportunity,
invocation: DecisionInvocation,
) -> Result<SubmitReceipt, MailboxError> {
let controller_id = opportunity.controller_id;
self.submit_stamped(
command_id,
CallerId::Controller(controller_id),
CommandBody::ExerciseDecision {
opportunity: opportunity.clone(),
invocation,
},
AuthenticatedCaller::verified_controller(controller_id),
)
.await
}
pub(super) async fn submit_controller_decline(
&self,
command_id: CommandId,
opportunity: &DecisionOpportunity,
) -> Result<SubmitReceipt, MailboxError> {
let controller_id = opportunity.controller_id;
self.submit_stamped(
command_id,
CallerId::Controller(controller_id),
CommandBody::DeclineDecision {
opportunity: opportunity.clone(),
},
AuthenticatedCaller::verified_controller(controller_id),
)
.await
}
/// The clock port. Stamped, like every opportunity-bearing command, because
/// the tick task cannot know the live revision either. It is visible inside
/// the world subtree and unreachable from runtime ingress, which builds
/// `CallerId::Principal` from verified evidence and nothing else.
pub async fn submit_clock(
&self,
command_id: CommandId,
minutes: TickMinutes,
) -> Result<SubmitReceipt, MailboxError> {
self.submit_stamped(
command_id,
CallerId::System(SystemCapability::Clock),
CommandBody::AdvanceTime { minutes },
AuthenticatedCaller::verified_system(SystemCapability::Clock),
)
.await
}
/// The elaborator's only commit port. Stamped, like every digest-binding
/// command: the loop cannot know the live revision either, and an
/// `AdmitPatch` from an elaborator binds by its answer's digest exactly as
/// an `ExerciseDecision` binds by scope digest. `answers` is not an
/// `Option`, so the port cannot express an unanswered elaborator patch and
/// `AnswerRequired` is reachable only through the owner lane and the
/// journal. Visible inside the world subtree, where the elaboration organ
/// lives; unreachable from runtime ingress.
pub(super) async fn submit_elaboration(
&self,
command_id: CommandId,
jurisdiction: JurisdictionKey,
answers: PatchAnswer,
patch: WorldPatch,
) -> Result<SubmitReceipt, MailboxError> {
self.submit_stamped(
command_id,
CallerId::System(SystemCapability::Elaborator { jurisdiction }),
CommandBody::AdmitPatch {
answers: Some(answers),
patch,
},
AuthenticatedCaller::verified_system(SystemCapability::Elaborator { jurisdiction }),
)
.await
}
/// The consumer lane's one door, and the only constructor of a `Consumer`
/// capability. It takes the revision the consumer built against rather than
/// stamping one: a caller that cannot name its revision cannot be told its
/// batch is stale, and telling it so is the whole point of the field.
pub(super) async fn submit_consumer(
&self,
world_id: WorldId,
expected_revision: u64,
command_id: CommandId,
consumer: ConsumerId,
answers: Option<PatchAnswer>,
patch: WorldPatch,
) -> Result<SubmitReceipt, MailboxError> {
let capability = SystemCapability::Consumer { consumer };
self.submit_authenticated(
CommandEnvelope {
id: command_id,
world_id,
expected_revision,
caller: CallerId::System(capability),
body: CommandBody::AdmitPatch { answers, patch },
},
AuthenticatedCaller::verified_system(capability),
)
.await
}
#[cfg(test)]
pub(super) async fn create_fixture(
&self,
input: CreateWorld,
authenticated: &AuthenticatedCaller,
) -> Result<CreationReceipt, MailboxError> {
self.create_authenticated(input, authenticated.clone())
.await
}
#[cfg(test)]
pub(super) async fn submit_fixture(
&self,
command: CommandEnvelope,
authenticated: &AuthenticatedCaller,
) -> Result<SubmitReceipt, MailboxError> {
self.submit_authenticated(command, authenticated.clone())
.await
}
/// The human operator's story feed. It is not a perception surface, and no
/// controller lane calls it.
/// The tick driver's adjacency projection. It is on `WorldMailbox` and on
/// neither `ControllerPort` nor `ElaborationPort`: a controller organ that
/// tried to read adjacency would fail to compile.
pub async fn agency_graph(&self) -> Result<AgencyGraph, MailboxError> {
let (reply, response) = oneshot::channel();
self.sender
.send(Request::AgencyGraph { reply })
.await
.map_err(|_| MailboxError::Unavailable)?;
response
.await
.map_err(|_| MailboxError::Unavailable)?
.map_err(MailboxError::Kernel)
}
/// The tick driver's opportunity list, in snapshot order. It is on
/// `WorldMailbox` and on no controller port, as `agency_graph` is.
pub async fn opportunities(&self) -> Result<Vec<DecisionOpportunity>, MailboxError> {
let (reply, response) = oneshot::channel();
self.sender
.send(Request::Opportunities { reply })
.await
.map_err(|_| MailboxError::Unavailable)?;
response
.await
.map_err(|_| MailboxError::Unavailable)?
.map_err(MailboxError::Kernel)
}
/// The tick driver's ordinal: how many clock advances the world has
/// committed. It is on `WorldMailbox` and on no controller port, as
/// `opportunities` is.
pub async fn clock_advances(&self) -> Result<u64, MailboxError> {
let (reply, response) = oneshot::channel();
self.sender
.send(Request::ClockAdvances { reply })
.await
.map_err(|_| MailboxError::Unavailable)?;
response
.await
.map_err(|_| MailboxError::Unavailable)?
.map_err(MailboxError::Kernel)
}
pub async fn operator_log(&self) -> Result<Vec<OperatorEvent>, MailboxError> {
let (reply, response) = oneshot::channel();
self.sender
.send(Request::OperatorLog { reply })
.await
.map_err(|_| MailboxError::Unavailable)?;
response
.await
.map_err(|_| MailboxError::Unavailable)?
.map_err(MailboxError::Kernel)
}
pub async fn snapshot(&self) -> Result<WorldSnapshot, MailboxError> {
let (reply, response) = oneshot::channel();
self.sender
.send(Request::Snapshot { reply })
.await
.map_err(|_| MailboxError::Unavailable)?;
response
.await
.map_err(|_| MailboxError::Unavailable)?
.map_err(MailboxError::Kernel)
}
pub(super) async fn controller_receipt(
&self,
command_id: CommandId,
opportunity: &super::DecisionOpportunity,
invocation: &super::DecisionInvocation,
) -> Result<Option<super::CommitReceipt>, MailboxError> {
let (reply, response) = oneshot::channel();
self.sender
.send(Request::ControllerReceipt {
command_id,
opportunity: opportunity.clone(),
invocation: invocation.clone(),
reply,
})
.await
.map_err(|_| MailboxError::Unavailable)?;
response
.await
.map_err(|_| MailboxError::Unavailable)?
.map_err(MailboxError::Kernel)
}
pub(super) async fn controller_decline_receipt(
&self,
command_id: CommandId,
opportunity: &super::DecisionOpportunity,
) -> Result<Option<super::CommitReceipt>, MailboxError> {
let (reply, response) = oneshot::channel();
self.sender
.send(Request::ControllerDeclineReceipt {
command_id,
opportunity: opportunity.clone(),
reply,
})
.await
.map_err(|_| MailboxError::Unavailable)?;
response
.await
.map_err(|_| MailboxError::Unavailable)?
.map_err(MailboxError::Kernel)
}
}
/// The narrow port `ControllerRunner` is built against, instead of the whole
/// `WorldMailbox`. It forwards exactly the five requests a controller lane
/// makes today — a snapshot to read from, and the four commit paths a
/// controller may exercise or decline through — and names nothing else. In
/// particular it has no `operator_log` method: "no controller lane calls the
/// human operator's story feed" used to be a convention about who calls a
/// `pub(crate)` method on `WorldMailbox`. Now it is a fact about which methods
/// this type has. Adding `.operator_log()` to `controllers.rs` fails to
/// compile, because `ControllerPort` never named it; that failure is the
/// proof, not a test that runs and passes.
/// The elaboration organ's narrowing of the mailbox: it reads a snapshot and
/// commits one authored patch. Nothing else on `WorldMailbox` is reachable from
/// the authoring lane, and that is a fact about which methods this type has
/// rather than a test that runs and passes.
#[derive(Clone)]
pub(crate) struct ElaborationPort {
mailbox: WorldMailbox,
}
impl ElaborationPort {
pub fn new(mailbox: WorldMailbox) -> Self {
Self { mailbox }
}
pub(super) async fn snapshot(&self) -> Result<WorldSnapshot, MailboxError> {
self.mailbox.snapshot().await
}
pub(super) async fn submit_elaboration(
&self,
command_id: CommandId,
jurisdiction: JurisdictionKey,
answers: PatchAnswer,
patch: WorldPatch,
) -> Result<SubmitReceipt, MailboxError> {
self.mailbox
.submit_elaboration(command_id, jurisdiction, answers, patch)
.await
}
}
/// The seeding organ's narrowing of the mailbox. It reads a snapshot and
/// commits one unanswered Draft patch as the owner. It has no `operator_log`,
/// no `agency_graph`, no `submit_clock`, and no `ApproveDraft`/`ActivateWorld`:
/// those are not methods on this type, so reaching for one fails to compile.
///
/// It carries the owner's `VerifiedPrincipalEvidence` for the session's
/// lifetime because a multi-round session cannot re-derive it: the only minter
/// is the consumer authenticating a live principal, and a checkpoint that stored an
/// account hash so the runner could re-mint one would be a second minter and an
/// offline forge path. The evidence is captured from the request that asked for
/// the work and dies with the port — but holding it is also bounded by the
/// evidence's own `valid_until`, not only by the port's own lifetime: every
/// submission through `submit_principal` is refused once that expiry has
/// passed, whatever the port itself still thinks the session's shape is.
#[derive(Clone)]
pub struct SeedPort {
mailbox: WorldMailbox,
principal: VerifiedPrincipalEvidence,
}
impl SeedPort {
pub fn new(mailbox: WorldMailbox, principal: VerifiedPrincipalEvidence) -> Self {
Self { mailbox, principal }
}
pub(super) async fn snapshot(&self) -> Result<WorldSnapshot, MailboxError> {
self.mailbox.snapshot().await
}
/// One body, hardcoded. The seed lane cannot express an answered patch, so
/// a submission meets two independent Draft-only gates in sequence: this
/// method's own phase check, taken against a snapshot read at the moment
/// of submission and bound to that snapshot's revision, refuses every
/// non-Draft submission before the mailbox ever sees it; and, for a patch
/// that declares or admits evidence, `require_answer`'s Active branch
/// refuses it again if the first gate were ever removed. An operations-only
/// patch needs no answer in Active because the owner's hand is legitimate
/// there — `require_answer` does not, and must not, treat every Active
/// patch as unanswerable — so this method's own phase check is what keeps
/// the seed lane itself confined to Draft.
///
/// The snapshot is taken here rather than trusted from the caller: a
/// multi-round session reads its own snapshot long before it has a patch
/// to submit, and binding to that stale revision would only catch a world
/// that moved, not a world that moved to Active without moving its
/// revision incompatibly. Reading fresh at submission time means the
/// phase this method checks is the phase the mailbox will actually see.
pub(super) async fn submit_seed(
&self,
command_id: CommandId,
world_id: WorldId,
patch: WorldPatch,
) -> Result<SubmitReceipt, MailboxError> {
let snapshot = self.mailbox.snapshot().await?;
if snapshot.phase != WorldPhase::Draft {
return Err(MailboxError::Kernel(KernelError::WrongPhase {
expected: WorldPhase::Draft,
actual: snapshot.phase,
}));
}
self.mailbox
.submit_principal(
PrincipalCommandIntent {
id: command_id,
world_id,
expected_revision: snapshot.revision,
body: CommandBody::AdmitPatch {
answers: None,
patch,
},
},
&self.principal,
)
.await
}
}
/// The play table's one door. Minted only by Dungeon, which constructs one
/// `PlayPort` in its `AppState`; exclusivity is that single construction site,
/// pinned by a negative grep, exactly as every other system capability's is.
/// No session evidence backs it: it is a system capability like the clock,
/// not a principal, and it carries no expiry to hold.
#[derive(Clone)]
pub struct PlayPort {
mailbox: WorldMailbox,
}
impl PlayPort {
pub fn new(mailbox: WorldMailbox) -> Self {
Self { mailbox }
}
pub async fn snapshot(&self) -> Result<WorldSnapshot, MailboxError> {
self.mailbox.snapshot().await
}
pub async fn submit_patch(
&self,
command_id: CommandId,
patch: WorldPatch,
) -> Result<SubmitReceipt, MailboxError> {
self.mailbox
.submit_stamped(
command_id,
CallerId::System(SystemCapability::Play),
CommandBody::AdmitPatch {
answers: None,
patch,
},
AuthenticatedCaller::verified_system(SystemCapability::Play),
)
.await
}
pub async fn advance_time(
&self,
command_id: CommandId,
minutes: TickMinutes,
) -> Result<SubmitReceipt, MailboxError> {
self.mailbox
.submit_stamped(
command_id,
CallerId::System(SystemCapability::Play),
CommandBody::AdvanceTime { minutes },
AuthenticatedCaller::verified_system(SystemCapability::Play),
)
.await
}
}
/// The consumer ingress's narrowing of the mailbox: one method. The ingress
/// has no reason to read the world — it selects no answer, pre-validates
/// nothing, and returns a receipt rather than state — so a snapshot method here
/// would be authority granted before the pass that needs it.
#[derive(Clone)]
pub struct ConsumerPort {
mailbox: WorldMailbox,
}
impl ConsumerPort {
pub fn new(mailbox: WorldMailbox) -> Self {
Self { mailbox }
}
pub(super) async fn submit_consumer(
&self,
world_id: WorldId,
expected_revision: u64,
command_id: CommandId,
consumer: ConsumerId,
answers: Option<PatchAnswer>,
patch: WorldPatch,
) -> Result<SubmitReceipt, MailboxError> {
self.mailbox
.submit_consumer(
world_id,
expected_revision,
command_id,
consumer,
answers,
patch,
)
.await
}
}
#[derive(Clone)]
pub struct ControllerPort {
mailbox: WorldMailbox,
}
impl ControllerPort {
pub fn new(mailbox: WorldMailbox) -> Self {
Self { mailbox }
}
pub async fn snapshot(&self) -> Result<WorldSnapshot, MailboxError> {
self.mailbox.snapshot().await
}
pub(crate) async fn controller_receipt(
&self,
command_id: CommandId,
opportunity: &super::DecisionOpportunity,
invocation: &super::DecisionInvocation,
) -> Result<Option<super::CommitReceipt>, MailboxError> {
self.mailbox
.controller_receipt(command_id, opportunity, invocation)
.await
}
pub(crate) async fn controller_decline_receipt(
&self,
command_id: CommandId,
opportunity: &super::DecisionOpportunity,
) -> Result<Option<super::CommitReceipt>, MailboxError> {
self.mailbox
.controller_decline_receipt(command_id, opportunity)
.await
}
pub async fn submit_controller(
&self,
command_id: CommandId,
opportunity: &DecisionOpportunity,
invocation: DecisionInvocation,
) -> Result<SubmitReceipt, MailboxError> {
self.mailbox
.submit_controller(command_id, opportunity, invocation)
.await
}
pub(crate) async fn submit_controller_decline(
&self,
command_id: CommandId,
opportunity: &DecisionOpportunity,
) -> Result<SubmitReceipt, MailboxError> {
self.mailbox
.submit_controller_decline(command_id, opportunity)
.await
}
}
fn mailbox_outcome(error: KernelError) -> MailboxError {
match error {
KernelError::RecoveryRequired { command_id } => MailboxError::OutcomeUnknown { command_id },
other => MailboxError::Kernel(other),
}
}
async fn run_owner(mut owned: OwnedWorld, mut receiver: mpsc::Receiver<Request>) {
while let Some(request) = receiver.recv().await {
match request {
Request::Create {
input,
authenticated,
reply,
} => {
let prepared = match prepare_creation(input, &authenticated) {
Ok(prepared) => prepared,
Err(error) => {
let _ = reply.send(Err(error));
continue;
}
};
if let OwnedWorld::Live(kernel) = &owned {
let result = kernel.retry_creation(&prepared);
let owner_must_stop = result
.as_ref()
.is_err_and(KernelError::requires_owner_restart);
let _ = reply.send(result);
if owner_must_stop {
return;
}
continue;
}
let OwnedWorld::Empty(empty) = owned else {
unreachable!("live owner returned above")
};
match WorldKernel::initialize(empty, prepared) {
Ok((kernel, receipt)) => {
owned = OwnedWorld::Live(kernel);
let _ = reply.send(Ok(receipt));
}
Err(error) => {
// Initialization consumed the sole journal handle. Its
// durability is uncertain, so this owner must release
// the path and make callers reopen explicitly.
let _ = reply.send(Err(error));
return;
}
}
}
Request::Submit {
command,
authenticated,
reply,
} => {
let result = match &mut owned {
OwnedWorld::Empty(_) => Err(KernelError::WorldNotCreated),
OwnedWorld::Live(kernel) => kernel.submit(command, &authenticated),
};
let owner_must_stop = result
.as_ref()
.is_err_and(KernelError::requires_owner_restart);
let _ = reply.send(result);
if owner_must_stop {
return;
}
}
Request::SubmitStamped {
command_id,
caller,
body,
authenticated,
reply,
} => {
let result = match &mut owned {
OwnedWorld::Empty(_) => Err(KernelError::WorldNotCreated),
OwnedWorld::Live(kernel) => {
let command = CommandEnvelope {
id: command_id,
world_id: kernel.state.world_id,
expected_revision: kernel.state.revision,
caller,
body,
};
kernel.submit(command, &authenticated)
}
};
let owner_must_stop = result
.as_ref()
.is_err_and(KernelError::requires_owner_restart);
let _ = reply.send(result);
if owner_must_stop {
return;
}
}
Request::Snapshot { reply } => {
let result = match &owned {
OwnedWorld::Empty(_) => Err(KernelError::WorldNotCreated),
OwnedWorld::Live(kernel) => kernel.snapshot(),
};
let owner_must_stop = result
.as_ref()
.is_err_and(KernelError::requires_owner_restart);
let _ = reply.send(result);
if owner_must_stop {
return;
}
}
Request::OperatorLog { reply } => {
let result = match &owned {
OwnedWorld::Empty(_) => Err(KernelError::WorldNotCreated),
OwnedWorld::Live(kernel) => kernel.operator_log(),
};
let owner_must_stop = result
.as_ref()
.is_err_and(KernelError::requires_owner_restart);
let _ = reply.send(result);
if owner_must_stop {
return;
}
}
Request::AgencyGraph { reply } => {
let result = match &owned {
OwnedWorld::Empty(_) => Err(KernelError::WorldNotCreated),
OwnedWorld::Live(kernel) => kernel.agency_graph(),
};
let owner_must_stop = result
.as_ref()
.is_err_and(KernelError::requires_owner_restart);
let _ = reply.send(result);
if owner_must_stop {
return;
}
}
Request::Opportunities { reply } => {
let result = match &owned {
OwnedWorld::Empty(_) => Err(KernelError::WorldNotCreated),
OwnedWorld::Live(kernel) => kernel.opportunities(),
};
let owner_must_stop = result
.as_ref()
.is_err_and(KernelError::requires_owner_restart);
let _ = reply.send(result);
if owner_must_stop {
return;
}
}
Request::ClockAdvances { reply } => {
let result = match &owned {
OwnedWorld::Empty(_) => Err(KernelError::WorldNotCreated),
OwnedWorld::Live(kernel) => kernel.clock_advances(),
};
let owner_must_stop = result
.as_ref()
.is_err_and(KernelError::requires_owner_restart);
let _ = reply.send(result);
if owner_must_stop {
return;
}
}
Request::ControllerReceipt {
command_id,
opportunity,
invocation,
reply,
} => {
let result = match &owned {
OwnedWorld::Empty(_) => Ok(None),
OwnedWorld::Live(kernel) => {
kernel.controller_receipt(command_id, &opportunity, &invocation)
}
};
let owner_must_stop = result
.as_ref()
.is_err_and(KernelError::requires_owner_restart);
let _ = reply.send(result);
if owner_must_stop {
return;
}
}
Request::ControllerDeclineReceipt {
command_id,
opportunity,
reply,
} => {
let result = match &owned {
OwnedWorld::Empty(_) => Ok(None),
OwnedWorld::Live(kernel) => {
kernel.controller_decline_receipt(command_id, &opportunity)
}
};
let owner_must_stop = result
.as_ref()
.is_err_and(KernelError::requires_owner_restart);
let _ = reply.send(result);
if owner_must_stop {
return;
}
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{
CallerId, CommandBody, Declaration, DraftHandle, EntityDeclaration, EntityKind, Mismatch,
NewController, PrincipalId, SubjectDeclaration, SubjectKind, WorldId,
};
use std::{collections::BTreeSet, path::PathBuf};
use tempfile::TempDir;
fn authenticated_owner() -> AuthenticatedCaller {
AuthenticatedCaller::fixture(CallerId::Principal(PrincipalId::new("owner")))
}
fn creation(id: CommandId, title: &str) -> CreateWorld {
CreateWorld {
lens_weights: crate::tests::stock_weights(),
grammar: None,
id,
owner: PrincipalId::new("owner"),
title: title.into(),
brief: String::new(),
patch: WorldPatch {
declarations: vec![
Declaration::Entity(EntityDeclaration {
handle: DraftHandle::new(GENESIS_PLACE),
label: "The Commons".into(),
kind: EntityKind::Place,
container: None,
}),
Declaration::Subject(SubjectDeclaration {
handle: DraftHandle::new("operator"),
label: "Operator".into(),
kind: SubjectKind::Person,
controller: NewController::Human {
principal: PrincipalId::new("owner"),
},
affordances: kernel_speak_grant(),
position: Some(Ref::Draft(DraftHandle::new(GENESIS_PLACE))),
import_key: None,
}),
],
operations: Vec::new(),
evidence: Vec::new(),
},
scale_intent: WorldScaleIntentRef::default(),
}
}
async fn fixture() -> (
TempDir,
PathBuf,
WorldMailbox,
JoinHandle<()>,
AuthenticatedCaller,
CreateWorld,
CreationReceipt,
) {
let directory = tempfile::tempdir().expect("temporary world directory");
let path = directory.path().join("world.cc");
let authenticated = authenticated_owner();
let input = creation(CommandId::new(), "Mailbox World");
let (mailbox, task) = WorldMailbox::open(&path).expect("open empty world owner");
let receipt = mailbox
.create_fixture(input.clone(), &authenticated)
.await
.expect("create fixture world");
(
directory,
path,
mailbox,
task,
authenticated,
input,
receipt,
)
}
fn approval_command(world_id: WorldId, revision: u64) -> CommandEnvelope {
CommandEnvelope {
id: CommandId::new(),
world_id,
expected_revision: revision,
caller: CallerId::Principal(PrincipalId::new("owner")),
body: CommandBody::ApproveDraft,
}
}
#[tokio::test]
async fn empty_owner_rejects_world_operations_then_accepts_creation() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("world.cc");
let authenticated = authenticated_owner();
let (mailbox, task) = WorldMailbox::open(&path).unwrap();
assert!(matches!(
mailbox.snapshot().await,
Err(MailboxError::Kernel(KernelError::WorldNotCreated))
));
assert!(matches!(
mailbox
.submit_fixture(approval_command(WorldId::issue(), 0), &authenticated)
.await,
Err(MailboxError::Kernel(KernelError::WorldNotCreated))
));
let receipt = mailbox
.create_fixture(creation(CommandId::new(), "Created"), &authenticated)
.await
.unwrap();
assert_eq!(mailbox.snapshot().await.unwrap().world_id, receipt.world_id);
drop(mailbox);
task.await.unwrap();
}
#[tokio::test]
async fn invalid_creation_leaves_the_owner_empty() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("world.cc");
let authenticated = authenticated_owner();
let (mailbox, task) = WorldMailbox::open(&path).unwrap();
let mut invalid = creation(CommandId::new(), "Invalid");
invalid
.patch
.declarations
.push(invalid.patch.declarations[1].clone());
let Err(MailboxError::Kernel(KernelError::PatchRejected(rejected))) =
mailbox.create_fixture(invalid, &authenticated).await
else {
panic!("expected a rejected creation patch");
};
assert_eq!(
rejected,
vec![Mismatch::DuplicateHandle {
handle: DraftHandle::new("operator")
}]
);
assert!(matches!(
mailbox.snapshot().await,
Err(MailboxError::Kernel(KernelError::WorldNotCreated))
));
assert!(
mailbox
.create_fixture(creation(CommandId::new(), "Valid"), &authenticated)
.await
.is_ok()
);
drop(mailbox);
task.await.unwrap();
}
/// A creation patch that declares only entities passes structural and
/// reference resolution, so it must not reach the journal at all: an
/// empty subject set at genesis is a rejected patch, not a corrupt
/// journal that kills the owner actor.
#[tokio::test]
async fn genesis_without_a_subject_is_a_mismatch_not_a_journal_fault() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("world.cc");
let authenticated = authenticated_owner();
let (mailbox, task) = WorldMailbox::open(&path).unwrap();
let mut subjectless = creation(CommandId::new(), "No Subject");
subjectless.patch.declarations = vec![Declaration::Entity(EntityDeclaration {
handle: DraftHandle::new("empty-hall"),
label: "The Empty Hall".into(),
kind: EntityKind::Place,
container: None,
})];
let Err(MailboxError::Kernel(KernelError::PatchRejected(rejected))) =
mailbox.create_fixture(subjectless, &authenticated).await
else {
panic!("expected a rejected creation patch");
};
assert_eq!(rejected, vec![Mismatch::NoDecisionSubject]);
assert!(matches!(
mailbox.snapshot().await,
Err(MailboxError::Kernel(KernelError::WorldNotCreated))
));
// The mailbox actor is still alive: a valid creation on the same
// kernel still succeeds.
assert!(
mailbox
.create_fixture(creation(CommandId::new(), "Valid"), &authenticated)
.await
.is_ok()
);
drop(mailbox);
task.await.unwrap();
}
#[tokio::test]
async fn empty_restart_remains_empty_without_a_sidecar_identity() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("world.cc");
let (mailbox, task) = WorldMailbox::open(&path).unwrap();
assert!(matches!(
mailbox.snapshot().await,
Err(MailboxError::Kernel(KernelError::WorldNotCreated))
));
drop(mailbox);
task.await.unwrap();
let (reopened, reopened_task) = WorldMailbox::open(&path).unwrap();
assert!(matches!(
reopened.snapshot().await,
Err(MailboxError::Kernel(KernelError::WorldNotCreated))
));
drop(reopened);
reopened_task.await.unwrap();
}
#[tokio::test]
async fn exact_creation_retry_survives_live_state_and_restart() {
let (_directory, path, mailbox, task, authenticated, input, receipt) = fixture().await;
assert_eq!(
mailbox
.create_fixture(input.clone(), &authenticated)
.await
.unwrap(),
receipt
);
let before_restart = mailbox.snapshot().await.unwrap();
drop(mailbox);
task.await.unwrap();
let (reopened, reopened_task) = WorldMailbox::open(&path).unwrap();
assert_eq!(reopened.snapshot().await.unwrap(), before_restart);
assert_eq!(
reopened
.create_fixture(input, &authenticated)
.await
.unwrap(),
receipt
);
drop(reopened);
reopened_task.await.unwrap();
}
#[tokio::test]
async fn creation_id_collision_and_second_creation_fail_closed() {
let (_directory, _path, mailbox, task, authenticated, input, _) = fixture().await;
let mut collision = input.clone();
collision.title = "Different payload".into();
assert!(matches!(
mailbox.create_fixture(collision, &authenticated).await,
Err(MailboxError::Kernel(KernelError::CreationConflict))
));
assert!(matches!(
mailbox
.create_fixture(creation(CommandId::new(), "Second world"), &authenticated)
.await,
Err(MailboxError::Kernel(KernelError::CreationTargetOccupied))
));
drop(mailbox);
task.await.unwrap();
}
#[tokio::test]
async fn submit_then_snapshot_share_one_serial_owner() {
let (_directory, _path, mailbox, task, authenticated, _input, receipt) = fixture().await;
let result = mailbox
.submit_fixture(approval_command(receipt.world_id, 0), &authenticated)
.await
.expect("submit through mailbox");
assert!(matches!(result, SubmitReceipt::Applied(_)));
let snapshot = mailbox.snapshot().await.expect("snapshot through mailbox");
assert_eq!(snapshot.revision, 1);
assert_eq!(
snapshot.draft_approvals,
BTreeSet::from([PrincipalId::new("owner")])
);
drop(mailbox);
task.await.expect("owner task exits after last sender");
}
#[tokio::test]
async fn concurrent_same_revision_submissions_cannot_both_commit() {
let (_directory, _path, mailbox, task, authenticated, _input, receipt) = fixture().await;
let left = approval_command(receipt.world_id, 0);
let right = approval_command(receipt.world_id, 0);
let (left_result, right_result) = tokio::join!(
mailbox.submit_fixture(left, &authenticated),
mailbox.submit_fixture(right, &authenticated)
);
let applied = [&left_result, &right_result]
.into_iter()
.filter(|result| matches!(result, Ok(SubmitReceipt::Applied(_))))
.count();
let stale = [&left_result, &right_result]
.into_iter()
.filter(|result| {
matches!(
result,
Err(MailboxError::Kernel(KernelError::RevisionMismatch { .. }))
)
})
.count();
assert_eq!((applied, stale), (1, 1));
drop(mailbox);
task.await.expect("owner task exits after last sender");
}
#[tokio::test]
async fn canceled_submit_reply_does_not_cancel_enqueued_command() {
let (_directory, path, mailbox, task, authenticated, _input, receipt) = fixture().await;
let (reply, response) = oneshot::channel();
mailbox
.sender
.send(Request::Submit {
command: approval_command(receipt.world_id, 0),
authenticated,
reply,
})
.await
.expect("enqueue command");
drop(response);
drop(mailbox);
task.await.expect("owner drains queue before exit");
let (reopened, reopened_task) = WorldMailbox::open(&path).expect("reopen released world");
let snapshot = reopened.snapshot().await.expect("read durable state");
assert_eq!(snapshot.revision, 1);
assert_eq!(
snapshot.draft_approvals,
BTreeSet::from([PrincipalId::new("owner")])
);
drop(reopened);
reopened_task.await.unwrap();
}
#[tokio::test]
async fn submit_reply_loss_is_outcome_unknown() {
let (sender, mut receiver) = mpsc::channel(1);
let mailbox = WorldMailbox { sender };
let owner = tokio::spawn(async move {
if let Some(Request::Submit { reply, .. }) = receiver.recv().await {
drop(reply);
}
});
let result = mailbox
.submit_fixture(
approval_command(WorldId::issue(), 0),
&authenticated_owner(),
)
.await;
assert!(matches!(result, Err(MailboxError::OutcomeUnknown { .. })));
owner.await.expect("test owner exits");
}
#[tokio::test]
async fn create_reply_loss_is_outcome_unknown() {
let (sender, mut receiver) = mpsc::channel(1);
let mailbox = WorldMailbox { sender };
let owner = tokio::spawn(async move {
if let Some(Request::Create { reply, .. }) = receiver.recv().await {
drop(reply);
}
});
let result = mailbox
.create_fixture(
creation(CommandId::new(), "Uncertain"),
&authenticated_owner(),
)
.await;
assert!(matches!(result, Err(MailboxError::OutcomeUnknown { .. })));
owner.await.expect("test owner exits");
}
#[tokio::test]
async fn snapshot_reply_loss_is_unavailable() {
let (sender, mut receiver) = mpsc::channel(1);
let mailbox = WorldMailbox { sender };
let owner = tokio::spawn(async move {
if let Some(Request::Snapshot { reply }) = receiver.recv().await {
drop(reply);
}
});
let result = mailbox.snapshot().await;
assert!(matches!(result, Err(MailboxError::Unavailable)));
owner.await.expect("test owner exits");
}
#[tokio::test]
async fn closed_mailbox_is_unavailable_before_enqueue() {
let (sender, receiver) = mpsc::channel(1);
drop(receiver);
let mailbox = WorldMailbox { sender };
let result = mailbox
.submit_fixture(
approval_command(WorldId::issue(), 0),
&authenticated_owner(),
)
.await;
assert!(matches!(result, Err(MailboxError::Unavailable)));
}
/// Soul falsification: the envelope revision is stamped inside the owner
/// task, so a controller turn bound at revision N still commits after an
/// unrelated commit moved the world to N+1. This exercises the mailbox
/// path, not the kernel gate a hand-built envelope would reach.
#[tokio::test]
async fn soul_a_bound_opportunity_commits_through_the_mailbox_after_an_unrelated_commit() {
let directory = tempfile::tempdir().unwrap();
let (mailbox, _task) = WorldMailbox::open(directory.path().join("world.cc")).unwrap();
let owner = PrincipalId::new("owner");
let authenticated = authenticated_owner();
// Two rooms, not one: a telling reaches its own room, so the bound
// subject must stand somewhere the unrelated speaker does not.
let declare = |handle: &str, label: &str, controller: NewController| {
Declaration::Subject(SubjectDeclaration {
handle: DraftHandle::new(handle),
label: label.into(),
kind: SubjectKind::Person,
controller,
affordances: kernel_speak_grant(),
position: Some(Ref::Draft(DraftHandle::new(format!("room-{handle}")))),
import_key: None,
})
};
let room = |handle: &str| {
Declaration::Entity(EntityDeclaration {
handle: DraftHandle::new(format!("room-{handle}")),
label: format!("The {handle} room"),
kind: EntityKind::Place,
container: None,
})
};
let created = mailbox
.create_fixture(
CreateWorld {
lens_weights: crate::tests::stock_weights(),
id: CommandId::new(),
owner: owner.clone(),
title: "Soul Stamping".into(),
brief: String::new(),
patch: WorldPatch {
declarations: vec![
room("witness"),
room("council"),
declare("witness", "The Witness", NewController::NarrativePersona),
declare("council", "The Council", NewController::OperationalAgent),
],
operations: Vec::new(),
evidence: Vec::new(),
},
scale_intent: WorldScaleIntentRef::default(),
grammar: None,
},
&authenticated,
)
.await
.unwrap();
let mut snapshot = mailbox.snapshot().await.unwrap();
for body in [CommandBody::ApproveDraft, CommandBody::ActivateWorld] {
mailbox
.submit_fixture(
CommandEnvelope {
id: CommandId::new(),
world_id: created.world_id,
expected_revision: snapshot.revision,
caller: CallerId::Principal(owner.clone()),
body,
},
&authenticated,
)
.await
.unwrap();
snapshot = mailbox.snapshot().await.unwrap();
}
let pick = |mode: crate::ControllerMode| {
snapshot
.opportunities
.iter()
.find(|value| value.controller_mode == mode)
.expect("an active opportunity")
.clone()
};
let bound = pick(crate::ControllerMode::OperationalAgent);
let unrelated = pick(crate::ControllerMode::NarrativePersona);
let speak = |opportunity: &DecisionOpportunity, text: &str| DecisionInvocation {
affordance: opportunity.affordance_ids[0],
bindings: Vec::new(),
proposed: Vec::new(),
speech: Some(crate::Statement::new(text).unwrap()),
display: None,
};
mailbox
.submit_controller(
CommandId::new(),
&unrelated,
speak(&unrelated, "Somebody else moves."),
)
.await
.unwrap();
let moved = mailbox.snapshot().await.unwrap();
assert_eq!(moved.revision, bound.revision + 1);
let receipt = mailbox
.submit_controller(CommandId::new(), &bound, speak(&bound, "Still mine."))
.await
.expect("a bound turn must not die at the envelope CAS");
assert!(matches!(receipt, SubmitReceipt::Applied(_)));
assert_eq!(
mailbox.snapshot().await.unwrap().revision,
bound.revision + 2
);
}
/// Soul falsification: stamping the revision inside the owner must not open
/// a hole. A stamped body still fails closed when the world derives no such
/// opportunity.
#[tokio::test]
async fn soul_a_stamped_submission_still_fails_closed_on_a_foreign_scope() {
let (_directory, _path, mailbox, _task, authenticated, _input, created) = fixture().await;
let mut snapshot = mailbox.snapshot().await.unwrap();
for body in [CommandBody::ApproveDraft, CommandBody::ActivateWorld] {
mailbox
.submit_fixture(
CommandEnvelope {
id: CommandId::new(),
world_id: created.world_id,
expected_revision: snapshot.revision,
caller: CallerId::Principal(PrincipalId::new("owner")),
body,
},
&authenticated,
)
.await
.unwrap();
snapshot = mailbox.snapshot().await.unwrap();
}
assert_eq!(snapshot.phase, crate::WorldPhase::Active);
let forged = DecisionOpportunity {
world_id: WorldId::issue(),
revision: 0,
scope_digest: crate::ScopeDigest::fixture("sha256:not-a-scope"),
scope: crate::DecisionScope {
subject_id: crate::SubjectId::issue(),
},
controller_id: crate::ControllerId::issue(),
controller_mode: crate::ControllerMode::OperationalAgent,
affordance_ids: vec![crate::AffordanceId::issue()],
};
let result = mailbox
.submit_controller(
CommandId::new(),
&forged,
DecisionInvocation {
affordance: forged.affordance_ids[0],
bindings: Vec::new(),
proposed: Vec::new(),
speech: Some(crate::Statement::new("Let me in.").unwrap()),
display: None,
},
)
.await;
// The owner stamps `world_id` as well as `expected_revision`, so the
// envelope's own `WorldMismatch` check is unreachable for these two
// bodies. `exact_opportunity` is what refuses the foreign world.
assert!(
matches!(
result,
Err(MailboxError::Kernel(KernelError::OpportunityMismatch))
),
"a foreign scope was not refused: {result:?}"
);
}
}