Module share 

Sharing with your other computers, for the window (docs/database.md): set up on the Parameters page, one exchange a minute off the window’s thread, the pages read again when another computer’s changes came in. Each part switched on or off on this device; the versions kept before other devices’ changes listed, and put back.

Structs

Backup 🔒

Fetched from the server too, as the panel shows it.

Kept 🔒

A version kept, as the window lists it.

KeptFile 🔒

KeptVersion 🔒

Others 🔒

What this device reads of the others, for the doses (health::know).

Part 🔒

A part of what is shared, as this device has it.

ServerAccount 🔒

An account Sioul can keep the folder with, for the panel: its id, and how to say it.

Status 🔒

Vanished 🔒

Files gone at once from a folder of notes or papers, held until you say.

Enums

News 🔒

How an exchange here waits for the other devices’ news first (exchange_here).

Constants

NEWS_MISSED 🔒

An alarm on this thread whose pull did not go through since it began (remote::AlarmNews::SyncApp): when it began (Unix seconds), and the devices whose entry or health claim says more since.

PARTS 🔒

The parts this computer claims (keeper): closed together.

STORAGE 🔒

A phone’s shared storage.

Statics

ALONE 🔒

When nudge last did its work while Sioul’s own pull brings the news, the sync app not asked (Unix seconds).

BUSY 🔒

One exchange at a time.

CLAIMING 🔒

Claims renewed or closed one at a time: a phone put away and back at once never ends with a “closed” written after it came back.

FETCHING 🔒

One look or fetch at a time in this process: two exchanges’ threads never fetch at once.

HERE 🔒

This device’s sharing file written one change at a time.

HURRY 🔒

Set while a hurried exchange (a dose’s alarm, a button pressed, a switch changed) waits for the one running: its work on notes and papers stops where it is, and goes on at the next.

KEY 🔒

The key made from the passphrase, once read from the keyring.

LAST 🔒

The last exchange: when it ended (Unix seconds), what went wrong.

NUDGED 🔒

When the sync app was last asked to look (Unix seconds), and whether Sioul is on the screen.

SAID 🔒

What an exchange did that you should know for longer than a minute, said for a day: files two devices changed, both versions kept (Unix seconds, the problem).

SHOWN 🔒

SOON 🔒

What wants an exchange (sioul_sync::trigger::Soon), and the worker waiting on it.

SOON_WAKE 🔒

WATCHED 🔒

The shared files as the watcher last saw them (sioul_sync::trigger::Stamps).

WORKER 🔒

The window’s handles, once an exchange was first asked: the worker and the watcher run from then on.

Functions

account_item 🔒

Where an item of your calendars or contacts set aside belongs, from its name among the earlier versions (data/calendars/<account>/…): inside Sioul’s calendars and address books only.

again_line 🔒

What “Send everything again” did, in words: “Sent 14 files to cloud.example.org at 10:42.”, or why not.

ask_carriers 🔒

Every known sync app asked to look now (CARRIERS); elsewhere than a phone, nothing.

ask_carriers_only 🔒

The sync apps asked to look now, and nothing else.

ask_carriers_with 🔒

ask_carriers; with always, the sync app asked even while Sioul’s own pull works (a dose’s alarm whose pull did not go through falls back to it).

ask_sync_app 🔒

The sync app asked to bring the others’ news, as before Sioul’s own pull, and how long its twenty seconds still run: asked a moment ago already (two doses due at once), only what is left of them. Only where it is really asked is it said asked (NUDGED).

attached 🔒

The sharing folder, and what was fetched from its server read beside it from now on in this process (sioul_sync::remote::attach): cheap, no network.

backup 🔒

backup_line 🔒

Where the backup stands, in words: from where, and since when, or why not.

backup_words 🔒

A backup’s code (State::said) in plain words, for the log: “network:murena.io” → “murena.io: could not be reached”.

beside_documents 🔒

A folder a sync carries, outside the Documents folder that sync has: a phone may not see it.

between_exchanges 🔒

The same, while no exchange runs on this computer at all (another Sioul, the command line): share::exchange_lock held too. Never around what takes that lock itself.

candidates 🔒

Folders already shared through, by this device’s other devices: those holding a seal (seal.toml) in the folders a sync carries here, or on Android in your files (where the sync app, eDrive, Syncthing, puts them). A few levels down, the big ones skipped.

carried 🔒

carried_on_phone 🔒

On a phone: what you said, else the guess.

closing 🔒

Sioul closes, or is put away on a phone: what was marked goes out at once (an exchange, waiting for one running), then its claims say it closed and how far it wrote, so the others know it marks nothing until it is back (docs/health.md, “Knowing”).

confirm_gone 🔒

Files gone at once from a folder of notes or papers (“files/notes/”) taken out everywhere at the next exchange, as you said; “” when kept, else why not.

dropbox_folders 🔒

The folders Dropbox’s info.json names: {"personal": {"path": …}, "business": {"path": …}}.

estimate 🔒

What switching Notes or Papers on would send from here, as JSON {“part”, “text”}: how many files, how big, how many stay (too big).

exchange 🔒

An exchange wanted now (a button, a dose answered, a switch, the minute’s tick), run by the one worker off the window’s thread (worker); asked while one runs, another follows it. A shared file saved, seen by the watcher (watcher), wants one too, after a pause.

exchange_here 🔒

An exchange, when sharing is on: off the window’s thread; the pages read again when changes came in. One exchange here and now, on the calling thread, without the window (an Android alarm wakes Sioul with nothing on the screen): with fetch_first, what the other devices wrote is waited for first (news): Sioul’s own pull alone while it works, else the sync app asked and given twenty seconds. None when sharing is off. Waits for an exchange running.

exchange_now 🔒

One exchange, on the worker’s thread: the server’s news first (Sioul keeping the folder, or the backup), then the exchange, then this device’s files sent to the server (Sioul keeping the folder, or beside the sync app), the pages read again when changes came in.

exchange_tick 🔒

The minute’s scheduled exchange: left out when one started less than 50 seconds ago (a save’s), which did its work (trigger::Soon::tick).

failure_line 🔒

A failed send in detail, in words: “Your records did not go at 19:24: 1.1 MB of 2.5 MB went in 216 s, slower than Sioul waits for. Tried again at 19:39.”

failure_words 🔒

A send’s failure in words for the log (English, as the log is): “records: timeout after 216 s, 1081344 of 2530934 bytes sent (timeout: global)”.

fetch_from_server 🔒

The other devices’ files fetched from the server too (docs/database.md, “Fetched from the server too”), when the sharing folder is found on one of your accounts’ servers under the same seal, and a pull is due (sioul_sync::remote::due: the first at once, then at the pace of how this device stands). Looked for at once when asked, else every six hours. Never on the window’s thread; the switch off, not a request. Each look and each pull said in a phone’s log.

fetch_wanted 🔒

The others’ sealed notes and papers an exchange found not here yet, neither brought by the sync app nor fetched (sioul_sync::blobs::Wanted), fetched by their names from the folder’s server when the folder is found there (sioul_sync::remote::fetch_wanted): the next exchange writes them (docs/database.md, “Sealed files fetched when waited for”). Never on the window’s thread, nor while an exchange runs: a dose’s alarm never waits for it. Said in a phone’s log. How many came.

fetch_wanted_here 🔒

The background step’s (steps::step, after its exchange): the sealed files of notes and papers waited for, fetched (fetch_wanted); the window’s exchange, or the next step, writes them. Nothing asked, not even the key, while nothing waits.

files_readable 🔒

Whether notes and papers can be read whole here: on Android, only with “All files access” (without it, a folder lists only what Sioul made, and the rest would seem taken out).

folders_in 🔒

A folder’s own folders, for Sioul’s folder browser (Android’s picker refuses the phone’s storage, Murena’s among others): {“path”, “parent”, “folders”: [{“name”, “path”, “sealed”}], “readable”}. Hidden folders left out; “” starts in the phone’s storage (Android), else your home.

forget_device 🔒

A device you said is gone (Forget this device), for the sharing too: it no longer holds the newer form back (share::forget_device), until it says anything newer. Sharing off: nothing to do.

frugal_now 🔒

The connection metered or measured slow: the sharing’s full rounds wait (share::set_frugal), large files go at most every ten minutes.

give_back_memory 🔒

What an exchange held a moment (the memory of every line it knows, read and parsed: tens of megabytes with thousands of texts) given back to the system after it, where the C library keeps freed memory for itself (glibc): the window’s footprint stays its own, not its largest exchange’s.

here 🔒

This device’s sharing (share::Here). The projects’ switch was a setting every device followed (share_projects): the first time sharing is on here, what it said becomes this device’s own choice.

hex 🔒

history 🔒

The versions kept here before other devices’ changes (sioul_sync::history), as JSON: each part’s files whose name holds filter (any case), the one changed last first, a hundred at most (the others said), their versions.

holds_doses 🔒

Whether the doses’ part is held here, met in a newer format than this Sioul reads (share::holds, from the sharing’s memory on the disk: the same after a restart).

in_documents 🔒

Whether a folder is inside one named Documents, which phones’ sync apps carry: Murena’s eDrive carries it, and not the rest of the cloud.

keeper 🔒

Who keeps a part of the work among your computers (sioul_sync::lease), this computer’s claim renewed; active is when you were last at it, take takes the part here on purpose. Sharing off: this computer alone. The second value: the folder could not be written, so the others may not know.

kept_a_day 🔒

What is said for a day, not only until the next exchange: files two devices changed, an older copy put back by hand.

key 🔒

last_exchange 🔒

The last exchange, when one ran since Sioul started: when (Unix seconds), and whether it went well.

log_backup 🔒

The backup’s words for a phone’s log (adb logcat -s sioul): what it did or why not, and when; never a password, a name of yours, an address or a content. A line the same as the last one is not said again.

log_send 🔒

A send’s words in the log, on every system (a computer’s too: its journal): what went, or why not, the same line never twice in a row.

login_of 🔒

logins 🔒

The contacts-and-calendars accounts whose server may keep files Nextcloud’s way (found under /remote.php/: Nextcloud, Murena, ownCloud), each with its password from the keyring as their sync has it. Google’s never.

look_for_seals 🔒

looked 🔒

Who keeps a part, as the claims read now, without claiming it. Sharing off: this computer alone.

memory_path 🔒

metered 🔒

The connection is metered (NetworkManager: yes, or guessed yes), asked at most every five minutes; on a phone, not known here (measured instead: Sending::slow).

mirror_line 🔒

Where Sioul keeping the folder itself stands, in words: when last in step, or why not.

mirror_step 🔒

A step of Sioul keeping the folder itself (sioul_sync::remote::step): whole, the server looked through first and what is new there brought (at most every twenty seconds, unless urgent); then what changed here sent. Never on the window’s thread.

mirror_step_for 🔒

mirrored 🔒

Sioul keeping the folder in step with the server itself here (remote::MIRROR): its state.

news 🔒

How an exchange waits for the others’ news, as it is asked (fetch_first: the background step, or an alarm, a dose’s or a waking’s) on this device: its pull working (pulls_well), or the folder found on the server at least (found: an alarm tries a pull all the same).

news_missed 🔒

Whether the last alarm’s exchange on this thread (exchange_here(true)) had no pull go through since it began: then since when, and the devices of which news came all the same (their entry or health claim, later by its own times, brought by the sync app). Of the others, what was read before is not taken as knowledge (sioul_core::health::doubts_unread).

nextcloud_configs 🔒

What the Nextcloud client says it carries, on a computer: its nextcloud.cfg.

notes_carried 🔒

The notes folder, when a sync app carries it already: notes and papers then never travel through the sharing too, the two carriers would undo each other’s changes. On a computer, from the sync apps’ own settings and the folders named like theirs. On a phone, whose sync apps’ settings Sioul cannot read, as you said there (Here::notes_carried, asked before notes or papers are switched on); until then guessed: a notes folder in the same top folder of its storage as the sharing folder (Documents…), which eDrive carries whole, whatever name the storage goes by.

now_ms 🔒

nudge 🔒

On a phone: the sync app asked to look now rather than at its own pace (ask_carriers), at most once in every seconds (once a minute at least); with then_read, an exchange twenty seconds later reads what came down. Elsewhere, nothing: the desktop’s sync apps look by themselves within seconds.

nudge_carriers 🔒

The sync app asked to look now (CARRIERS), on a phone: after a reminder’s session went down, so that its lowered entry goes up (devices::receiver).

nudge_tick 🔒

Each minute: while Sioul is shown on a phone, the sync app asked to look every five minutes.

on 🔒

Whether sharing is on here: a folder and its key.

on_storage 🔒

A path of a phone’s shared storage under its one name: “/sdcard/…”, “/storage/self/primary/…”, “/mnt/sdcard/…” are “/storage/emulated/0/…”.

others_on_health 🔒

The others’ claims on the doses, their entries in the devices’ registry, and what was read of their records: what this device knows of the doses they marked (health::know). None when sharing is off.

part_words 🔒

A part’s name and what it carries, in a line.

problem_text 🔒

pulls_alone 🔒

On a phone, beside a sync app, Sioul’s own pull from the server working (remote::State::pulls_well: the backup on, the folder confirmed there, the last pull through): the other devices’ news come from it alone, the sync app neither asked to look nor waited for, before or after a send (docs/android.md, “In the background”). A pull that fails, or the backup switched off, and the sync app is asked as before.

put_back 🔒

A file put back as it was (stamp), the one there now kept in the list too; the next exchange sends it. Waits for an exchange running. Returns what went wrong, else “”.

put_back_item 🔒

A calendar’s item or a contact set aside put back (history::ACCOUNTS): its version written over the item, the item as it is then kept first; its account’s sync sends it, over the server’s version. Returns the account to sync, or what went wrong.

put_back_preview 🔒

What putting back would do, said before it is done (share::put_back_preview).

put_back_said 🔒

What putting back did, for the status line: the file, and when the version was kept.

quietly 🔒

work run while no exchange of this Sioul runs: the one running told to hurry (its notes and papers wait for the next), then waited for.

rebuild_dose_records 🔒

The same for the doses’ records (sioul_core::doses): one lost or broken here is read again from every device’s records, nothing of it taken out elsewhere.

rebuild_health_record 🔒

The doses’ record read again from every computer’s records at the next exchange, this computer forgetting it held it: one lost or broken here, started again empty, takes nothing out elsewhere. Waits for an exchange running. Returns what went wrong, else “”.

refused 🔒

Why a part cannot be shared from here, when it cannot: notes and papers while a sync app carries the notes folder.

remember 🔒

Files two devices changed, both kept: said for a day, not only until the next exchange.

renews 🔒

Whether this device’s claims are renewed now: always, but on a phone with Sioul put away.

same_top 🔒

Two folders inside one folder at the top of storage.

sealed 🔒

The sharing folder and its key, the key asked of the keyring only once a folder is set up: a device that does not share never asks it (on Linux a D-Bus call each time; the demo profile started the Secret Service at each start, review of 6 October 2026).

send_again 🔒

“Send everything again” (Settings ▸ Your folder and sharing): this device’s files sent to the server again, each one the server lacks or holds otherwise, whatever was sent before; then the others’ news fetched, and an exchange. For when a sync app was late, or the server lost files. Off the window’s thread; what it did is said in the panel (Status::again).

send_line 🔒

Where sending this device’s files beside the sync app stands, in words.

send_texts 🔒

This device’s texts to send copied into the sharing folder as a small file of their own, when the part “texts” is shared here, then sent to the server on their own lane (Sioul keeping the folder itself, or beside the sync app): a request reaches the phone within its quarter of an hour whatever the records’ size (docs/database.md, “Sent to the server too”).

send_to_server 🔒

This device’s own files sent to the server beside the sync app (sioul_sync::remote::send, docs/database.md, “Sent to the server too”): those changed since they went, each over what is there; with again, each compared with the server’s copy, whatever was sent before. Never on the window’s thread. Said in a phone’s log, counts and a code only.

sending_on 🔒

Sending this device’s own files beside the sync app is on here: the backup found the folder on a server, and neither switch is off.

server_accounts 🔒

The contacts-and-calendars accounts whose server keeps files Nextcloud’s way, without their passwords (read on the window’s thread: no keyring).

server_problem 🔒

A start or a join that did not go, in words.

set_backup 🔒

The other devices’ files fetched from the server too, or not: this device’s own choice, never shared. “” when kept, else why not.

set_backup_place 🔒

The sharing folder’s place on the server, given by hand (“Documents/Sioul”, or its address; “” to look for it by itself): looked at with the next exchange, that place alone. “” when kept, else why not.

set_notes_carried 🔒

What you say of the notes folder on a phone: a sync app carries it, or none does (Here::notes_carried). Carried: notes and papers stop travelling through the sharing here. Returns what went wrong, else “”.

set_part 🔒

A part shared from this device, or not (share::PARTS): this device’s own choice, never shared. Notes and papers are refused while a sync app carries the notes folder. “” when kept, else why not.

set_projects 🔒

Projects and money shared from this device, or not; “” when kept, else why not.

set_send 🔒

This device’s own files sent to the server beside the sync app, or not: this device’s own choice, never shared. “” when kept, else why not.

set_shown 🔒

Sioul on the phone’s screen, or put away: the sync app is asked to look only while it is shown.

shares 🔒

Whether this device shares a part (share::PARTS), as chosen here.

shorten 🔒

A path with your home written ~.

shown_kept 🔒

A file of the earlier versions, as the list names it: a calendar’s event or a contact set aside by what it is (“Dentist”, “Jane Doe”), from its newest version; any other by its name.

start 🔒

Starts sharing through a folder; “” when it did, else why not.

start_on_server 🔒

Starts sharing through a folder of an account’s files that Sioul keeps in step itself (remote::MIRROR): joined when another device shares through it already (its seal, the passphrase chosen there), else made there and sealed (the passphrase typed twice). Off the window’s thread: the result comes through share_started (“” when it did, else why not).

start_worker 🔒

The worker and the watcher, started once, with the window’s handles.

status 🔒

What the Parameters page shows, as JSON; folder is the one being chosen, if any.

stop 🔒

Stops sharing here: the key forgotten, the folder left as it is for the others.

store_of 🔒

The store a file of the records is in, by name (“files/notes/”, “config/config.toml”): for the pages to read again.

stores_here 🔒

What this device shares: each part as switched here, else as before parts had switches.

suggested 🔒

Where to share by default: inside a Documents folder a sync carries when there is one, since a phone’s sync app may carry only some folders (Murena’s eDrive: Documents, Pictures, Music…, not the cloud’s root); else in the notes folder when a sync carries it, else in a synced folder.

synced_roots 🔒

Folders a sync carries: those named so in your home, and Nextcloud’s own list.

syncthing_folders 🔒

The folders a Syncthing configuration carries: each <folder … path="…">.

texts_copies 🔒

Where the other devices’ texts to send are found beside the records’ copy: the sharing folder’s small files (texts/send/<id>.jsonl, carried by the sync app, or kept in step by Sioul itself), and those fetched from its server (remote::overlay). Each a root holding send/.

texts_now 🔒

A text was just written to send (texts): its small file placed and sent now, off the caller’s thread, not at the next exchange.

unhex 🔒

vanished_of 🔒

share-vanished:<folder>:<count>, said with a button: the folder of notes or papers it is in, and the sentence.

vault 🔒

This device’s id, and the folder and key when sharing is on: where its entry in the devices’ registry goes (devices).

waits_said 🔒

Why notes and papers received wait, for the log: “ (unknown 2, backoff 1)“, “” when none.

want 🔒

An exchange wanted, as change says (asked now, or a save seen): the worker woken.

watcher 🔒

Every two seconds, the shared files looked at (their size and time, the notes and papers folders left out): one changed since, by whatever wrote it, wants an exchange after a pause. Not while an exchange runs (what it writes is taken in after it, exchange_now); on a phone, only while Sioul is on its screen: in the background, what writes exchanges itself (exchange_here).

when 🔒

A moment, said shortly: “14:05” today, “Fri 2 Oct 14:05” before.

why_words 🔒

A send’s code in words, for the panel: “network” → “the server could not be reached”.

worker 🔒

The one thread that runs the window’s exchanges, each when it is due (docs/database.md, “Sent as soon as it is saved”): asked, at once; saves seen, two seconds after the last, five after the first at most. What is wanted while one runs makes the next. One that fails (a panic) never stops the next ones.

writes_format_2 🔒

Whether this device’s sharing writes format 2 (share::FORMAT), where each pinned site travels apart, and their order as its own setting.