Struct Step 

struct Step<'a> {
    here: &'a str,
    seal: &'a Seal,
    region: Option<&'static Region>,
    root: PathBuf,
    private: PathBuf,
    copies: Vec<PathBuf>,
    memory: PathBuf,
    vault: Option<&'a (PathBuf, [u8; 32])>,
    android: &'a dyn Android,
    standing: &'a dyn Fn(&str) -> Standing,
}

What the phone’s quick step works with: where it reads and writes (the data folder’s texts, the private texts folder, the other copies of the requests, the sharing’s memory), the sharing’s folder and key, Android (a stand-in in tests).

Fields

here: &'a str

seal: &'a Seal

region: Option<&'static Region>

root: PathBuf

private: PathBuf

copies: Vec<PathBuf>

memory: PathBuf

vault: Option<&'a (PathBuf, [u8; 32])>

android: &'a dyn Android

standing: &'a dyn Fn(&str) -> Standing

Where a device that asks stands in the sharing now (standing_of): a request is sent only for one counted, refused for one gone, left to wait for one not known yet (texts::verdict).

Implementations

impl Step<'_>

fn here<'a>( here: &'a str, seal: &'a Seal, region: Option<&'static Region>, vault: Option<&'a (PathBuf, [u8; 32])>, standing: &'a dyn Fn(&str) -> Standing, ) -> Step<'a>

This phone’s.

fn say(&self, outcomes: &[Outcome]) -> bool

Outcomes added to this phone’s own file, each (key, state) once.

fn record(&self, claim: &Claim)

fn pdu_path(&self, key: &str) -> PathBuf

Where a multimedia message waits for Android, written before its claim: Android reads it by its address (Sioul’s file provider), and it goes once its outcome is written.

fn copy_results(&self, now: i64) -> bool

Java’s results copied into this phone’s outcomes, each row named (name_rows: those not said yet), and the ledger told. A multimedia message Android took with no answer of the carrier’s is looked for in the sent box: there, sent; else not sent (Android filed it among the failed, which Sioul cannot see). A multimedia message’s file goes once its outcome is written.

fn prepare(&self, r: &Request, log: &OnceCell<Vec<Text>>, now: i64) -> Prepared

A multimedia message made ready before its claim (decision 12 and 13): its media looked for first, by their files alone (one not here yet asked for by its name, nothing else done, nothing claimed); then opened from the sharing, each checked against its hash; its message built (sioul_core::mms::encode) and measured against what its SIM’s carrier takes now (Android’s live value, never one raised: larger, refused in words, never left to Android’s code 5); written and flushed where Android will read it. The SIM: as asked, else the conversation’s last (sim_for).

fn sim_for(&self, r: &Request, log: &OnceCell<Vec<Text>>) -> i32

The SIM a request about to go leaves from: as asked, else the conversation’s last on this phone, its log read then and once a step at most (log): never for requests decided already, which a step meets at every exchange and inside a dose’s alarm (the review of 18 October 2026, M-1).

fn want(&self, media: &[Medium], missing: &[Medium])

A multimedia message’s media asked for by their names (blobs::Wanted::media, which the pull’s fetch brings from the server, and Sioul keeping the folder itself too): those missing; those here no longer.

fn decide(&self, now: i64) -> bool

Each request decided once, under the ledger’s lock (both processes of the phone may step): claimed and flushed before Android is asked; the others said (expired, refused, clocks apart) and written in the ledger, so that they are decided once too. A multimedia message is made ready first (prepare), and claimed only once every medium is here and checked: until then nothing is claimed, and at its expiry it is said that its media did not come. Whether an outcome was written.

fn look_for_lost(&self, now: i64) -> bool

A claim left without Android’s word (Sioul stopped between the claim and the hand-off, or a phone restarted while Android waited): a text’s looked for among the texts Sioul sent since, by its number and its words’ hash, two minutes on; a multimedia message’s by its key (the provider’s tr_id), handed or not, at each step from LOOK_AFTER_MMS_MS on, until Android’s last word (MMS_LAST_WORD_MS: it may still go until then). Found, sent; else in doubt. Never sent again.

fn publish_limits(&self, now: i64) -> bool

What each SIM’s carrier lets this phone send, said in its outcomes (decision 5: a computer offers Attach… only for a phone that said it, and reduces to it): when it changed, else once a day. Numbers only, never a carrier’s name.

fn sweep_outgoing(&self, now: i64)

A multimedia message’s file left behind (a crash before its claim, an outcome written by another way): gone once its key is done, or an hour old with no claim.