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.

GoneRow 🔒

A device that no longer counts here and still has files in the folder, as Settings lists 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.

WithheldShown 🔒

Notes or papers gone many at once here and held (share::withheld), in words: what went, from where and when; when they leave your other devices by themselves; the view flag that says the Porch said it once.

Enums

Begun 🔒

How sharing began on a server (begin_on_server): joined, another device sharing through that folder already; or started there, new.

News 🔒

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

Constants

FIRST_READING 🔒

How long the window’s first exchange waits for the first reading of the connection’s cost (metered).

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).

WITHHELD 🔒

The notes and papers gone many at once here and held, as the last exchange left them (share::Outcome::withheld); none before one did.

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.

after_exchange 🔒

work begun once the exchange of this Sioul running (told to hurry: its notes and papers wait for the next) is done, and run without holding the window’s exchanges back, a dose’s alarm first: for work that takes the exchanges’ lock itself, a short hold at a time (share::remove_device_files), between which a dose’s exchange goes, or only to put in place what it opened outside it (share::put_back). Under quietly, a dose’s alarm waited for the whole of it.

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”.

begin_on_server 🔒

Sharing begun through place among login’s files, Sioul keeping the folder itself (remote::MIRROR): joined when another device shares through it already (its seal, the passphrase chosen there, typed once and checked against it), else, when may_start, made there and sealed (the passphrase typed twice); a join that finds no seal there, nothing made. signed_in: login is the server’s own sign-in’s (loginflow), the folder kept with it (remote::begin_signed_in). On the calling thread, never the window’s: which, or why not, in words.

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”).

configured 🔒

Whether sharing is set up here (a folder chosen), its key read or not.

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.

day 🔒

A day in words: “Friday 17 October”.

device_files 🔒

What “Remove its files” would take out for a device, and what stays, in words, said before you press (share::device_files): { text, live }.

device_named 🔒

A device’s name as its last entry said it: “The phone (Model 7)”, a computer’s name, else “A device”.

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_at_once 🔒

An exchange now, on the calling thread (never the window’s), as the minute’s runs it (exchange_now): Sioul keeping the folder itself, the server looked through first, what this device wrote sent after. A device joining waits for it, to say what came (join).

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; Sioul keeping the folder itself, mirror_sealed); the window’s exchange writes them, offline too. 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.

gone_rows 🔒

The devices that no longer count here (they left, you forgot them, another replaces them) and whose files are still in the folder.

heard_lately 🔒

Whether a device was heard of within a day, as “Forget it now” judges it: the later of when this device saw its entry change and its own last word (health::quiet_since), and its last sealed word (heard, milliseconds).

heard_of 🔒

When device was last heard of here (share::heard_of), in milliseconds; 0 when sharing is off or nothing is known.

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.

keeps_itself 🔒

Sioul keeping the folder in step with the server itself here (remote::MIRROR): its state. Whether Sioul keeps the sharing’s folder itself (no sync app).

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), as the system’s reading thread last read it (devices::watch_system, every thirty seconds): never asked here, so that an exchange never waits on the system’s bus (review of battery part C, G1). Before this process’s first reading (the window’s first exchange, a moment after its start), that reading is waited for FIRST_READING at most, once, and none come by then, the connection counts as metered: a phone’s hotspot is not spent on a full round at each start (L3). Read once, a reading too old to keep says nothing: not metered. 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_sealed 🔒

Sioul keeping the folder itself: the others’ sealed notes, papers and tables (sioul_sync::remote::sealed_step), after a step and never in one, so that a dose’s alarm never waits for them; one at a time in this process (another process’s waits for it). Said in a phone’s log, counts and a code only. How many came.

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 🔒

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.

put_back_withheld 🔒

“Put them back”: the notes or papers held after going many at once from store (“files/notes/”) written back where they were, from their sealed contents, a few hundred at a time (share::put_back_withheld: the exchanges go between); what it says (put_back_words). Off the window’s thread (the bridge’s share_put_back_withheld).

put_back_words 🔒

What “Put them back” says: nothing when every one came back, or when nothing was held any more (pressed again after they came, or after they left: review of 18 October 2026, I-3); how many came back when some did not, never said as done (M-1); why, when none did.

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): those lost or broken here are read again from every device’s records, nothing of them taken out elsewhere.

rebuild_dose_reminders 🔒

The same for what each device did to remind each dose (sioul_core::dose_reminders): one lost or broken here is read again from every device’s, 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, and then (the record set aside) done before any exchange can run: one lost or broken here, started again empty, takes nothing out elsewhere. One step, under the window’s exchanges (BUSY) and the exchanges’ lock: an exchange between the two filled the record again, which then went aside, and the next mark took every other mark out on every device (review of 15 October 2026, P1). Waits for an exchange running. Returns what then gave, or what went wrong.

rebuild_then 🔒

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.

removal_words 🔒

The sentences said before “Remove its files” (share::DeviceFiles): whether it may be in use (heard of within a day: lately); what goes, with its size; what stays; who has not read all of it.

remove_device_files 🔒

“Remove its files” pressed. The doses first: a device silent a day or more stops counting for them exactly as a forgotten one (its claims go with its files; a device that still counts here is forgotten by the sharing too, as “Forget it now” does); one heard of within a day may be in use, and keeps counting for them, its doubt said, until it has been silent a day (heard_lately; review of 17 October 2026, L7): the sharing alone forgets it. Then everything it wrote in the folder goes (share::remove_device_files). “” when it went, else why not.

renews 🔒

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

replies_copies 🔒

Where the other devices’ replies to send are found beside the records’ copy: the sharing folder’s small files (phone-messages/ask/<id>.jsonl), and those fetched from its server (remote::overlay). Each a root holding ask/, as phonemsgs::folder is.

replies_now 🔒

A reply was just written to send (replies): its small file placed and sent now, beside the texts’, off the caller’s thread.

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 and replies to send copied into the sharing folder as small files of their own, when their parts are shared here (“texts”; “Messages from your phone”), 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_login 🔒

The login the server’s folder is reached with: joined through the server’s own sign-in (State::user), that login and its app password from the keyring (loginflow::kept), whatever account the contacts and calendars use; else the account’s, by its id, with its password. None without either. The password for the requests only, never kept nor said.

server_place 🔒

Where the sharing folder is on a Nextcloud, as this device knows it: the server’s name and the folder’s place among its files (“murena.io”, “Documents/Sioul”), Sioul keeping it itself or the backup having found it there beside the sync app; none otherwise (another sync app’s folder).

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="…">.

take_out_withheld 🔒

“Take them out now”: the notes or papers held after going many at once from store taken out everywhere at the next exchange, those alone (share::confirm_withheld); “” when said, else why not.

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”.

withheld 🔒

What the Porch and Settings say of the notes and papers held here after going many at once (docs/database.md, “Removed notes”): once on the Porch, calmly, with “Put them back” and “Take them out now”; nothing has to be pressed. The folders each by its place here (“~/Notes/Archives”).

withheld_now 🔒

The notes and papers held here as the last exchange left them (share::Outcome::withheld); read from the sharing’s memory the first time when read (Settings), never on the Porch’s own thread.

withheld_words 🔒

A bulk of notes or papers held, in words (withheld): the folders by their place under root (“~/Notes/Archives”), the notes folder itself for those at its top.

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.