Module remote 

The other devices’ files fetched from the server too (docs/database.md, “Fetched from the server too”). The sharing folder stays the one a sync app carries, whichever it is; when that folder lives on a WebDAV server Sioul has an account for (Nextcloud, Murena, ownCloud), Sioul also reads it there, in case the sync app is late bringing the others’ files, or stops: Murena’s eDrive was seen bringing a computer’s records an hour and a half late, and its entry among the devices never.

• Found on the servers of the contacts-and-calendars accounts that keep files Nextcloud’s way (…/remote.php/dav/files/<user>/, the user as the server names it): the place given by hand, else the folder’s path from a phone’s storage (eDrive carries it as the cloud’s root), from a folder the Nextcloud client carries (localPath → targetPath), or its last names.
• Confirmed only where the server’s seal.toml is this folder’s, byte for byte: a folder sealed otherwise is never read. Read again when it changes there, and every six hours.
• Fetched when the window or the phone’s background step asks (pull): PROPFIND (Depth: 1) on the folder, devices/, leases/ and each part’s claims, a folder whose ETag did not change skipped for ten minutes; of the other devices’ files, only those newer than both the synced folder’s copy and what was fetched before come down, into this device’s own state ($XDG_STATE_HOME/sioul/share/remote/, their paths as in the folder): records from where the copy here ends (its last line asked again and checked: a copy that does not join comes whole), only whole lines kept; the rest whole, a few hundred bytes each, kept only when it came whole. Ten seconds for each wait of the network, thirty for a pull.
• Read (overlay): the sharing reads, for each other device’s file, the newer of the two copies: records the longer (they only grow), notes to each other, entries and claims by the times they hold. The folder’s copy wins a tie. What was fetched goes once the folder’s copy caught up.
• Sent too (send, docs/database.md, “Sent to the server too”): this device’s own files, beside the sync app, each over what is there as it was seen; found there the same (the sync app sent it), not sent twice; records never shorter; never another device’s file.
• Never: another device’s file written, moved or deleted on the server; anything written into the synced folder; this device’s own files fetched or read from there; plain HTTP (a test’s own stand-in apart); the password kept or said (it comes from the keyring, as the calendars’ sync has it, for the requests only).

Structs

Again

What “Send everything again” did: when (Unix seconds), how many files went, how many were there already as they are here, and why it stopped (“” when it went through).

AlarmTimes

How long a dose’s or a waking’s alarm waits for the others’ news (alarm_news).

Counted 🔒

A body read from memory, counting what went: what a failure says it sent.

Departed 🔒

What a device took out of its folder of the devices that no longer count by a sealed fact (they left, you forgot them, another device replaces them), as its last exchange said (share::departed_past, share::swept_theirs): each one’s rounds below a round, and the sealed files it wrote that no record names any more, swept, with when. Never fetched here again; taken out of the server at a listing (beside a sync app, Sender; Sioul keeping the folder itself, Puller::push), each over what is there as it is now (If-Match): a sync app, or another device doing the same, makes it gone (404) or changed (412), and it is left.

Failure

A failed send, in detail: what the panel and the log say of it.

Fetched

A file of the server, as last fetched: its ETag and size there.

Got 🔒

What came of a file asked from a place in it: where it starts, its bytes, whether all came, and why not.

Held

A file held back after it failed: tries in a row, and when to try again (Unix seconds).

Item 🔒

Limits 🔒

How long the network may take: each wait (to connect, for the next bytes); a listing or a small file in all; a records’ file in all, as long as it moves; a whole pull.

Listing 🔒

A folder of the server, as listed: its own ETag, and what it holds by name.

Login

An account to fetch with: its id in the configuration, where its server was found (Account::url), its login, and its password from the keyring (none kept there): used for the requests only, never kept nor said.

Looked

A folder of the server, as last looked through: its ETag, and when (Unix seconds).

Opened

A folder of an account’s files as Sioul keeping it itself finds it: its address, where it is among the files, and its seal when it has one (another device shares through it: joining), else none (a new sharing).

Pace

How a device stands, for the pace of its pulls (due).

Pulled

What a pull did.

Puller 🔒

One pull: the server’s folder looked through, what is newer there fetched.

PutFailed 🔒

A file that did not go (Server::put_file): the error, what kind of failure (“timeout”, “stalled”, “unreachable”, “tls”, “login”, “network”), how long the try lasted (seconds), how many of its bytes went, of how many.

Sender 🔒

One send beside the sync app.

Sending

What sending this device’s own files beside the sync app knows (send): share/sending.toml (share/sending-urgent.toml for the urgent lane), never shared, apart from the backup’s state, so that a pull and a send never write over each other’s.

Sent

One of this device’s own files as it last went up (MIRROR): its size and time here (nanoseconds), its ETag there (“” when the server did not say).

Server 🔒

One server, signed in: requests with the account’s login, over TLS (plain HTTP only to a test’s own stand-in, dav::allowed), never redirected. Its requests go through the process’s one agent (dav::shared_agent): a pull, the sends after it and the next pull reuse one connection while it is open, each request with its own budget (limits).

Sought

What the look for the sharing folder found (seek): the places holding a seal of Sioul’s, in the order looked at, and whether every place it looks at was looked at (complete): a listing or a seal that could not be read, or the time running out, leaves it incomplete, and then “none found” is never said, nor a new sharing offered (the review of the join, M3).

State

What the backup knows, kept privately beside the sharing’s memory (remote.toml), never shared. on, given and asked are yours, written only through State::choose; the rest is the backup’s.

Enums

AlarmNews

Where an alarm’s news came from (alarm_news).

Kind 🔒

What a file of the folder is, by its path, and whose: a device’s records (<id>-<n>.jsonl), its notes to the others (<id>.toml), its entry (devices/<id>.device), a claim (leases/<part>/<id>.lease).

Lane 🔒

The two ways this device’s files go (send, send_urgent), each with its own lock and its own memory, so that a large file on a slow line, going up for minutes, never holds back a text to send.

Stop 🔒

Why a pull stopped: the network or the server, or the folder no longer confirmed.

Went 🔒

What came of one file: gone or the same there, left (unchanged, paced, longer there), or held back after a failure.

Constants

ALARM_TIMES

An alarm’s waits, as they are on a phone.

BLOBS_AGAIN 🔒

Sioul keeping the folder itself: blobs/ is listed again at most this long after its last listing, once its ETag changed (seconds): it is for letting go of what the server no longer has, and sending again what it lost of this device’s; what is waited for comes by name.

BLOB_LIMIT 🔒

A sealed file is never fetched past this: the largest note’s, sealed.

CHECK_AGAIN 🔒

A full check of what the server holds of this device’s files, beside the quick sends (each a few requests): every six hours, and when asked (“Send everything again”).

FLOOR

The slowest upload Sioul waits for (bytes a second): a phone’s mobile data on 3G sends faster. A 2.5 MB file is given 60 s and 156 s more.

LARGEST 🔒

A records’ file is never fetched past this.

LARGE_FILE

A file past this size (bytes) is a large one: on a metered or slow connection (Sending::frugal), sent at most every PACE seconds.

LIMITS 🔒

LIST 🔒

LISTING 🔒

A listing is never read past this: some 130,000 names, read a response at a time (read_listing), never held whole. Until 17 October 2026 a listing was read whole up to 4 MiB, and blobs/ past some 8,700 sealed files failed every step (review of 17 October 2026, M4).

LIST_AGAIN 🔒

A folder whose ETag did not change is looked through again after this long all the same (seconds).

LOOK_AGAIN

Looked for again this long after the last look, when not found (seconds).

MIRROR

The mode where Sioul keeps the folder in step with the server itself, no sync app at all (docs/database.md, “Kept in step by Sioul itself”): the folder here is its own copy (mirror_of), the server’s the one the devices share, a device beside a sync app reading the same.

MIRROR_WANTED_BYTES 🔒

Sioul keeping the folder itself: the sealed files waited for that come down in one step, at most (the first whatever its size).

OC 🔒

Nextcloud’s own properties: the checksums a file was sent with (oc:checksums).

OVERLAP 🔒

The last line asked again, to check the copy here joins what is there, when shorter than this.

PACE 🔒

PLACED_AT_ONCE 🔒

How many sealed files that came are put in place under one hold of the step’s lock, one writing of the state for them all (review of 18 October 2026, L-4: once per file, thousands of them rewrote a large state as many times).

PRINCIPAL 🔒

SEAL_AGAIN 🔒

The server’s seal read again this long after the last time, even unchanged (seconds).

SEND_LIMITS 🔒

Sending this device’s files (send): a step that sends a large file on a slow line is not cut after thirty seconds, as a pull is; each file is given the time its size asks (FLOOR).

SLOW

Under this rate (bytes a second), measured on a file sent of 64 KiB at least, the connection counts as slow: paced as a metered one.

SMALL_WANTED

A file waited for under this size (a note, bytes) comes at once, the connection metered or slow too; a larger one (a paper) at most every ten minutes then.

SOUGHT

Where a device joining through its Nextcloud’s sign-in looks for the sharing folder first (seek): Sioul’s own place, then the top of the files.

SOUGHT_UNDER 🔒

The folders one level under Documents looked at, at most (by name).

STAT 🔒

One file’s properties (Server::stat): a listing’s, and its time there.

TEXTS_LARGEST 🔒

A device’s urgent small files (its texts to send, texts/send/<id>.jsonl; its replies to send, phone-messages/ask/<id>.jsonl) are never fetched past this.

URGENT 🔒

The folders of the urgent small files, each device’s own file there (<top>/<sub>/<id>.jsonl): its texts to send, its replies to send.

WANTED_AGAIN 🔒

A sealed file waited for and not on the server yet (or cut on the way) is asked again within this long (seconds): it comes as soon as it is there.

WANTED_BYTES 🔒

and this many bytes of them, the first whatever its size.

WANTED_FILES 🔒

A step fetches at most this many sealed files waited for (fetch_wanted),

WANTED_KEPT_DAYS 🔒

A sealed file fetched for a note waiting is kept this long at most (days), in case it was not written meanwhile (tidy_cache).

XML 🔒

Statics

ATTACHED 🔒

PULLED 🔒

The last pull of each memory gone through in this process: when it began on the process’s own steady clock, and its time as saved (State::last). A clock set back makes a pull’s saved time later than the moment; an alarm in this process tells by this one whether that pull began before it.

Functions

again_mirror

Sioul keeping the folder itself (MIRROR): “Send everything again”. What it remembers of sending this device’s own files is forgotten (its sealed files apart, which tell its own from the others’), and the server’s folders are looked through again: each own file goes over what is there now, the others’ newer files come. Said as Sending::again says it.

again_mirror_with 🔒

alarm_news

What a dose’s or a waking’s alarm reads before it decides, since its start (Unix seconds), on a phone whose folder is found on the server (State::fetching; docs/android.md, “Doses while Sioul is away”). Sioul’s own pull alone is trusted only once a pull begun since the alarm went through (State::went_through_since; in this process, by its steady clock: PULLED): this one, or another’s that ran meanwhile in this process (lock, one pull at a time: another alarm’s, the window’s), waited for, never passed over. A pull that fails, or has not gone through within times.alone: the sync app asked as before (ask, which asks it and says how long its wait still runs: twenty seconds, less when another alarm asked it a moment ago), and waited for, that wait ended as soon as a pull since the alarm goes through; times.most in all at most. clock gives the time now (Unix seconds); key opens the others’ entries and claims.

alarm_news_with 🔒

asks_file

Where a device’s replies to send are, in the sharing folder (or a copy fetched from its server).

attach

The copy fetched for the sharing folder folder, read beside it from now on in this process (overlay), when there is one for it: its state names this folder, and what was fetched was fetched under this folder’s seal (the cache’s seal.toml, written when the server’s was found the same). Cheap when nothing changed; nothing of it needs the network. Returns it.

backoff

How long a failed send waits before it is tried again, by how many failed in a row: a minute, two, five, a quarter of an hour, half an hour, an hour.

begin

From now on Sioul keeps folder in step with opened itself (MIRROR), with login’s account: what the backup knew goes.

begin_as 🔒

begin_signed_in

The same, joined through the server’s own sign-in (loginflow): the folder kept with that login (State::user), its app password from the keyring under that login, whatever account the contacts and calendars use; login.account names the account of this server and login, made or found here.

blobs_looked 🔒

What a listing of blobs/ tells (sealed_step): this device’s own sealed files sent before it and gone there go up again at the next push (forgotten as sent); the others’ its copy fetched before it that the server no longer lists are let go here (their writer swept them), but those this device still needs (keep: changes waiting name them, a version kept here by reference may, its own); none while this device’s memory does not say what it needs (keep none: an older Sioul’s, until this one’s first exchange). Until 17 October 2026 the copy kept every sealed file it ever fetched (the review’s finding 1).

cache_of

Where the backup keeps what it fetched, beside the sharing’s memory: <state>/share/remote/.

cached_files 🔒

The files of the cache, by their path in the folder: the folder’s own, devices/, leases/<part>/.

checksums 🔒

The checksums a multistatus says (oc:checksums, Nextcloud’s), by the path of each response: “SHA1:… MD5:… ADLER32:…”.

code 🔒

Why, in a code the window says in words: “login:murena.io”.

confirm 🔒

The folder found at url: confirmed, its seal kept in the cache, which holds what was fetched under that seal only.

create

A new sharing there: each missing folder of its place made (MKCOL), then folder’s seal sent only if none is there yet (If-None-Match: *): two devices starting at once never seal it twice (“sealed-meanwhile”).

create_with 🔒

dir_of 🔒

The folder a file of the folder is in, as the server’s listings are kept: “” the folder itself, “devices/”, “leases/health/”.

due

Whether a pull is due now. The first after the folder is found, at once, whatever the hour: until it comes, this device knows the others only from the folder the sync app left stale, so whether another one is in use cannot be told (6 October 2026, 23:30: found on the phone at night, never pulled, the desk in use taken for closed hours before). Then a computer, a phone with Sioul on its screen or another device in use, once a minute; a phone in the background otherwise at its step’s pace, the night’s included: a device opened at night is noticed within its fifteen minutes. Asked for news, twenty seconds after the last.

encode_path 🔒

A path in a folder of the server as an address’s: each name percent-encoded (“Mes documents/Sioul” → “Mes%20documents/Sioul”).

end_tag 🔒

Where the first end tag of name in buf ends (</name>, </d:name>, spaces allowed before its >, as XML allows: </d:response >); none until all of one came.

failed 🔒

fetch_wanted

The sealed files of the others’ notes and papers this device waits for (blobs::Wanted: their records came, the files they name did not), fetched from the folder’s server by their names, beside the synced folder (overlay’s blobs/, read by blobs::get), when the backup is found there under the same seal (docs/database.md, “Sealed files fetched when waited for”). Only those neither in the folder nor fetched yet, the smallest first, at most WANTED_FILES and WANTED_BYTES a step (the first whatever its size). On a metered or slow connection (frugal), the pace of what is sent (send): one of SMALL_WANTED or more at most every ten minutes, a note’s at once. Each kept only once it opens whole to its content (blobs::check): one that does not is asked again after a while (backoff, up to an hour); one not on the server yet, within five minutes. No listing of the server’s blobs/: the records name them. Never on the window’s thread; one fetch at a time on this device.

fetch_wanted_into_copy 🔒

The sealed files this device waits for (wanted_in_copy), fetched by their names into its copy (sealed_step): the smallest first, 64 MiB at most a step (the first whatever its size), as long as the step’s time lasts; on a metered or slow connection (frugal), one of SMALL_WANTED or more at most every ten minutes. Each kept only once it opens whole to its content (blobs::check), put in its place under the step’s lock some at a time (place_fetched). One not there, cut, or that does not open, asked again after its backoff: within five minutes in its first hour (a sync app still sending it), then less and less often. who: this device’s id, and the account.

fetch_wanted_with 🔒

file_kind 🔒

A file of the folder, by its kind, for what is said: never its name.

file_names 🔒

The files of a folder, by name, hidden ones left out.

files_root 🔒

Where an account’s files are on its server, Nextcloud’s way (…/remote.php/dav/files/<user>/, the user as the server names it in its principal), from the address its calendars were found at; none for a server of another kind. On that server only: a principal named on another is refused (SyncError::Elsewhere), since every request there would carry the account’s login.

find

Looks for the sharing folder on the accounts’ servers: the place given by hand alone when there is one (State::given), else places under each account’s files. Confirmed only where the server’s seal.toml is this folder’s, byte for byte; a folder sealed otherwise is never used. The state, saved, says what was found, or why nothing was.

find_with 🔒

first_element 🔒

The namespaces an answer’s first element declares ( xmlns:d="DAV:"…, as written), and where that element’s opening ends; none until it all came.

forget

Sharing stopped here: what was fetched and known goes, and nothing is read beside the folder.

header 🔒

heard_since 🔒

The devices whose entry or health claim says more than before: later by its own times. Another part’s claim (notices, invoices) is no news of a session for the doses; a file touched with the same bytes, or an older copy put back, is none either.

host_of

A server’s name, to say where: “murena.io”.

in_step 🔒

A change to the state under the step’s lock (mirror.step), over the state as it is then, saved: no step runs meanwhile, nor saves over it. None, nothing changed, when Sioul no longer keeps that folder with that account.

is_id 🔒

is_zero_i64 🔒

is_zero_u32 🔒

kind_of 🔒

kind_of_error 🔒

A failure’s kind, from its error alone (no file under way).

listing_due 🔒

blobs/ listed again (sealed_step): once its ETag changed since its last listing, an hour at least after it; every six hours whatever (a server whose folders’ ETags lag); never while a failed one waits its backoff, nor while no look through the folder saw it there.

mirror_of

Sioul’s own copy of the folder in that mode: <state>/share/mirror/.

newline_before 🔒

Where the last line break before before is, read back a piece at a time.

nextcloud_places 🔒

The places a Nextcloud client’s configuration gives a folder: under one of its localPath, the same under that folder’s targetPath (“0\Folders\1\localPath=/home/me/Nextcloud/”, “0\Folders\1\targetPath=/”).

open

Where place (“Documents/Sioul”) is among login’s files, and what it holds; why not, in a code as State::said has them.

open_with 🔒

overlay

The copy fetched for folder, when one is attached in this process: the sharing reads, for each other device’s file, the newer of the two.

own_files 🔒

This device’s own files in the folder (MIRROR), by their path in it, in the order they go up: its records, its notes to the others, its claims, its entry (it says how far its records went), then the sealed files it made (in blobs/, not fetched). A large sealed file on a slow line never holds back the records, the doses’ answers among them; a record naming a sealed file not there yet is read as a sync app’s late copy is: the others wait for it (docs/database.md, “Coming in”).

own_latest 🔒

The highest round of this device’s records in the folder here; none when it holds none.

own_plain 🔒

This device’s own files in the folder but its sealed ones, in the order they go up: its records, its notes to the others, its claims, its entry.

own_urgent 🔒

This device’s urgent files in the folder: its texts and its replies to send.

place_asks

This device’s replies to send copied into the sharing folder as a small file of its own, phone-messages/ask/<id>.jsonl (source: its own file of the phone’s messages’ requests, every line sealed already), as its texts to send are (place_texts). Whether it changed.

place_fetched 🔒

Sealed files that came (ready: each one’s place in the folder, the name it came under, its size), put in their places in the copy under the step’s lock once the state says they were fetched (State::files): a step never sees one there before, and never takes it for one of this device’s own. Never over a file there (sealed here meanwhile: the same content). Whether each was put there.

place_texts

This device’s texts to send copied into the sharing folder as a small file of its own, texts/send/<id>.jsonl (source: its own file of the part “texts”, every line sealed already): the sync app carries it, Sioul sends it first (send_urgent), the others read it beside the records’ copy, so that a request reaches the phone within its quarter of an hour whatever the records’ size. None here, none there. Whether it changed.

place_urgent 🔒

An urgent small file put in the sharing folder (target) as its source holds it: none there when none here.

places

Where a folder may be on a server, as paths in an account’s files, the likeliest first: on a phone, its path from the storage, which eDrive carries as the cloud’s root (/storage/emulated/0/Documents/Sioul → Documents/Sioul), or from the Nextcloud app’s own folder; under a folder the Nextcloud client carries (nextcloud: its nextcloud.cfg, as text), the same under its targetPath; then its last one, two and three names.

pull

The other devices’ files newer on the server than here, fetched beside the synced folder (see the module’s words); own is this device’s id, whose files are never fetched. Nothing when the folder is not confirmed, or its seal here is no longer the one fetched under. Never on the window’s thread.

pull_since_with 🔒

A pull begun since the alarm (since, Unix seconds; begun, this process’s steady clock) gone through: one that ran meanwhile, waited for (lock: one pull at a time in this process), else this one, begun before until. False when a pull begun since failed, or none could begin in time.

pull_with 🔒

read_listing 🔒

A folder’s listing read as it comes, a response at a time: each <response> taken out of what came, read on its own (wrapped in the namespaces the answer’s first element declares), then dropped; what is kept per name is its ETag, size and checksums. Its bytes too. Never more than one response and a read’s piece held at once, whatever the size of the folder (review of 17 October 2026, M4). Whole only with the folder’s own response and the answer’s last element closed: a listing that leaves the folder out, or ends early, is no listing (review of 18 October 2026, L-1 and L-6).

read_range 🔒

response_end 🔒

Where the first whole <response> of what came ends (after its closing tag, whatever its prefix: </d:response>, </D:response>, </response>).

round_cap 🔒

The longest of another device’s records a pull brings (LARGEST); a test’s own, in its thread.

round_of 🔒

A round’s number, from its file’s name (<id>-<round>.jsonl).

said_by_each 🔒

seal_of 🔒

The seal of a folder, its bytes: at most a small file’s.

sealed_due

Whether sealed_step has something to do now: blobs/ due to be listed, or a sealed file waited for and due. Cheap: nothing of the network, nor of the key.

sealed_step

Sioul keeping the folder itself (MIRROR): the others’ sealed files, after the steps, on a thread of their own (the window’s worker after its exchange, the phone’s background step beside its mail), never in a step: a dose’s alarm never waits for them, and a step waits a moment at most (the step’s lock is taken only to note a listing and to put in place what came, place_fetched). First blobs/, listed when due (listing_due): this device’s own sealed files gone there go up again at the next push; the others’ its copy fetched that the server no longer lists are let go, but those this device still needs (blobs_looked). Then those waited for (blobs::Wanted), by their names, the smallest first, 64 MiB at most a step (the first whatever its size), as long as the step’s time lasts, each kept only once it opens whole to its content (blobs::check); one not there, cut, or that does not open is asked again after its backoff. On a metered or slow connection (frugal), one of a megabyte or more at most every ten minutes, as the sending paces them. One at a time on this device.

sealed_step_with 🔒

seek

Where the sharing folder is among login’s files, for a device joining with nothing set up (docs/database.md, “Joining through your Nextcloud’s sign-in”): each of SOUGHT first, then each folder one level under Documents (the first 40 by name, hidden ones left out), that holds a seal of Sioul’s (share::is_seal), in that order. Only PROPFIND and GET of seal.toml files, on the account’s own server. A listing of Documents that fails only ends the extra places; one place that cannot be read leaves the others looked at; the time running out ends the look with what was found: each makes the look incomplete (Sought). Why it could not look at all, in a code as open has them (“login:murena.io”, “no-files:murena.io”): a refused login, a certificate, the files not found.

seek_with 🔒

send

This device’s own files sent to the server beside the sync app that carries the folder (docs/database.md, “Sent to the server too”), once the backup found the folder there under the same seal. Only its own files (own_plain, and the sealed files it made, sealed: their name and the size it sealed, sent whole only), each over what is there as it was seen; a file found there as it is here is not sent again (the sync app sent it, or will find it there as its own); records only grow (never one shorter than what went, or than the server’s), and go in order; never another device’s file. Each file is given the time its size asks (FLOOR); one that does not go is held back (backoff), never tried sooner, the next records with it, the other files still going. The server unreachable, nothing is tried before its backoff. With frugal (a metered connection), or the connection measured slow, a large file goes at most every ten minutes. With again, or every six hours, or the first time, the server’s folders are listed and every file compared: one lost there is sent again. This device’s records past their time and the sealed files it swept are taken out there. One send at a time on this device, whichever process runs it.

send_lane 🔒

send_urgent

This device’s texts and replies to send (texts/send/<id>.jsonl, place_texts; phone-messages/ask/<id>.jsonl, place_asks), on a lane of their own: small files, sent first and alone, never waiting behind a large one going up on a slow line; Sioul keeping the folder itself too (MIRROR). A multimedia message’s media go first on it (media: their sealed files’ names in blobs/, and the size each was sealed at), so that the phone finds them there by the time it reads the request; each asked of the server by its own name, never the whole of blobs/ listed.

sha1_hex 🔒

A content’s SHA-1, in lower case hexadecimal, as OC-Checksum says it.

sha1_of 🔒

The SHA-1 among checksums as a server says them (“SHA1:ab12… MD5:…”), in lower case.

shown 🔒

sought

Whether place is one the look goes through by itself (seek): one of SOUGHT, or a folder one level under Documents.

stamp_of 🔒

state_path 🔒

What the backup knows, beside it: <state>/share/remote.toml.

step

One step of Sioul keeping the folder itself (MIRROR): with whole, the server’s folder looked through first and the other devices’ newer files brought into the copy here, as pull brings them beside a synced folder; then this device’s own files changed since they went up, or changed there since, sent (Puller::push), its records first, its sealed files last; the others’ sealed notes, papers and spam filter’s tables come after the steps, by their names (sealed_step). A large sealed file on a slow line, going up, never holds back the records: the doses’ answers go first. Never another device’s file written; nothing here lost when the server refuses. One step at a time on this device, whichever process runs it.

step_with 🔒

take_out_swept 🔒

A sealed file this device swept as written by a device that no longer counts (Departed::blobs), taken out there when it is still as old there as it was here (its time there, getlastmodified, two weeks at least before it was swept: another device that uses that content again makes it fresh, blobs::put, and its sync app sends the new time), over its ETag there now. Whether it went. Any failure, any other answer: left there.

texts_file

Where a device’s texts to send are, in the sharing folder (or a copy fetched from its server).

through_since 🔒

Whether a pull begun since the alarm (since, Unix seconds; begun, on this process’s steady clock) went through. The last one gone through in this process, when it is the one the state says, is judged by the steady clock (PULLED), which no setting of the clock moves; another process’s by its saved time, within since and now.

tidy

What is no longer needed in the cache, gone, without the network: this device’s own files (never fetched, never read from there), records the synced folder caught up with, entries and notes the same as the folder’s and, the backup switched off, all of them; records longer than the folder’s stay until it catches up (read past its end here, a records’ file gone would read as cut, and the doses would doubt for hours). Sealed files fetched for a note waiting (fetch_wanted) go once it is written, once the synced folder holds them, or after a few days.

tidy_cache 🔒

usable 🔒

What was fetched for this folder may be read: fetched for it, under its seal.

wanted_due

Whether a sealed file waited for is due to be fetched (fetch_wanted): cheap, nothing of the network; none while nothing waits.

wanted_in_copy 🔒

The sealed files waited for (blobs::Wanted: the others’ records name them; a computer lacks a text’s medium) not in the copy and due, never one swept here as a departed device’s (Departed).

wanted_now 🔒

The sealed files waited for that are neither in the folder nor fetched (into), and not asked lately in vain: those the records wait for, and the texts’ media asked by name (blobs::Wanted::media: a computer’s lacking, a multimedia message’s that its phone waits for), each asked WANTED_KEPT_DAYS at most.

whole_end 🔒

Where a file’s last whole line ends, and where it starts: (0, 0) when it holds none.

Type Aliases

Said 🔒

What each other device says of itself as the doses read it (health::know): its entry (devices) and its claim on the health part (lease), the later of the folder’s copy and the one fetched beside it, each by its own times (devices::written; the claim’s renewal and its end).

Stamp 🔒

The cache attached to each sharing folder in this process (attach), and what that was decided on: the backup’s state, this folder’s seal, the cache’s (their sizes and times).