Struct Sender 

struct Sender<'a> {

    server: &'a Server,
    folder: &'a Path,
    memory: &'a Path,
    own: &'a str,
    url: &'a str,
    sealed: &'a BTreeMap<String, u64>,
    sending: &'a mut Sending,
    pulled: &'a mut Pulled,
    now: i64,
    frugal: bool,
    lane: Lane,
    past: Option<u32>,
    departed: Departed,
    known: &'a BTreeMap<String, Fetched>,
    unlisted: BTreeSet<String>,
}

One send beside the sync app.

Fields

server: &'a Server

folder: &'a Path

memory: &'a Path

The sharing’s memory (share::rounds_past reads where its rounds stand).

own: &'a str

url: &'a str

The folder there, an address ending with “/”.

sealed: &'a BTreeMap<String, u64>

sending: &'a mut Sending

pulled: &'a mut Pulled

now: i64

frugal: bool

lane: Lane

past: Option<u32>

With a listing: this device’s rounds below this one are past their time (share::rounds_past), taken out there when still listed.

departed: Departed

With a listing: what this device took out here of the devices that no longer count (Departed), taken out there too.

known: &'a BTreeMap<String, Fetched>

The others’ files as the pull last saw them there (State::files): a removed device’s file is taken out only while still as seen.

unlisted: BTreeSet<String>

The folders a check could not list (list_own).

Implementations

impl Sender<'_>

fn url(&self, relative: &str) -> String

fn run( &mut self, files: &[String], check: bool, again: bool, ) -> Result<(), Stop>

files in their order (records first, by round, then the notes to the others, the claims, the entry, the sealed files last): nothing large holds back what the others wait for. A records file held back holds the next ones (records go in order); the other files still go.

fn list_own(&mut self) -> Result<BTreeMap<String, Item>, Stop>

The server’s copies of this device’s files, by their path in the folder: the folder itself, devices/, each part’s claims, blobs/ (when this device sealed any), texts/send/, phone-messages/ask/. A folder not there holds none.

fn same( &self, relative: &str, there: &Item, bytes: &[u8], sha1: &str, ) -> Result<bool, Stop>

Whether the server’s copy is this file as it is here: a sealed file by its size (its name is its content’s); records by their size (they only grow, one writer) and their checksum when the server keeps one; the rest by their checksum, else read there and compared.

fn one( &mut self, relative: &str, listed: Option<Option<Item>>, again: bool, look: bool, ) -> Result<Went, Stop>

One of this device’s files, sent when it changed here since it went (or, there listed, when the server’s copy is not this one), over what is there as it was seen. Refused because it changed there meanwhile (412): the server’s copy looked at; the same as here (the sync app sent it), nothing more; else sent over it. A folder missing there (409), made first. Too slow or cut: held back (backoff). look: “Send everything again” while its folder could not be listed: what is there asked of the server itself, never taken as unchanged (review of 18 October 2026, L-7).

fn failed(&mut self, relative: &str, failed: PutFailed) -> Result<Went, Stop>

A file that did not go, said in detail (Sending::failure). Too slow or cut on its way (the connection made, its bytes moving): that file held back (backoff), the others still going. Else (the server unreachable, refused, out of time): the send stops.

fn make_folders(&mut self, relative: &str) -> Result<(), Stop>

The folders a file’s path goes through, made there (MKCOL) when missing.

fn take_out_gone(&mut self, check: bool) -> Result<(), Stop>

What this device sent and let go here, taken out there as it was sent (If-Match): its records past their time (removed here once every device read past them), never its last round, and nothing while none of its records is here; the sealed files it swept. Gone there already: forgotten. Changed there since (412): looked at there, and taken out when it is still what this device sent (again_after_412). Any other answer (423 while a sync app sends that very file again, a server’s error, 403), or a look that fails: left there, the send going on, never held back for it; a round forgotten here and looked for again at the next listing (take_out_past), a sealed file kept here and tried again at the next listing (Sending::refused; check: this send lists). Until the final review of 15 October 2026 (RES-1) such an answer failed the whole send, after its files went, and held the next sends back, the records with them. Another file gone here (a claim of a part no longer kept) is forgotten, left there.

fn again_after_412( &mut self, relative: &str, sent: &Sent, records: bool, ) -> bool

One of this device’s files to take out there, refused as changed there since it went (412). A sync app sends the same file again: eDrive sends each file Sioul sent, the same bytes, and Nextcloud gives it a new ETag. Until 15 October 2026 such a file was forgotten here and stayed on the server for good (a phone’s past full rounds, 47 MB on the owner’s). Looked at there now: of the size this device sent (records only grow and only this device writes them; a sealed file’s name is its content’s), and for a sealed file still dated as this device sent it, it is taken out, over its ETag there now. A sealed file dated otherwise was sent there again by another device that uses that content again (blobs::put makes it fresh, and its sync app sends the new time): its use, never taken out. Of another size there (a round grown there): left there, forgotten here; this device’s past rounds are looked for again at each listing (take_out_past). Refused again, or any other answer, a failure too (a server’s error, a timeout): left there, the send going on and not held back (review of 15 October 2026, L1), a round forgotten here as above, a sealed file kept here and tried again at the next listing (Sending::refused). Whether it is settled: taken out, gone there, or not this device’s to take out.

fn take_out_past( &mut self, listed: &BTreeMap<String, Item>, past: u32, ) -> Result<(), Stop>

This device’s records past their time still listed there (below past, share::rounds_past: every device heard lately read past them, and none is its last full round or one continuing it) and gone here: taken out over their ETag there, whatever sent them, so that those a sync app left there (eDrive passes no deletion on), or that were forgotten here before 15 October 2026, go too. Only files named as this device’s records, never another device’s file; nothing while none of its records is here. Refused, or any other answer: left for the next listing, the send going on.

fn take_out_departed(&mut self, listed: &BTreeMap<String, Item>)

What this device took out here of the devices that no longer count (Departed), still listed there and gone here (from the folder and from what was fetched beside it): their past rounds over the ETag listed, the sealed files swept when still as old there (take_out_swept). Any device that counts does the same; a file another took out first is gone (404), one sent again since is changed (412): left, as any other answer or failure, for the next listing, the send going on.