Module share

Expand description

What only this computer keeps, shared with your other computers through a folder your sync already carries: Nextcloud, Dropbox, Syncthing (docs/database.md, “The log”).

Mail, contacts, the agenda and tasks travel by their servers; projects and notes by the folder that holds them. The rest lives in small files here: settings, who may write to you, ties, time, drafts, health, lists kept on this computer. Each computer has a name, a UUID made once, and appends each change it finds in them, as one sealed record, to its own file in the folder (<computer>-<round>.jsonl): one writer per file, so the sync never makes conflicted copies.

Files stay the truth: Sioul reads and writes them as before. A change is found by comparing them with what they held at the last look; a record from another computer is written into them. For each entry (a setting, a line of a list, a session, a whole file) the record with the later clock wins: a hybrid logical clock, the time made strictly increasing here and never behind a record already read. A change is dated by its file’s time, so a change made here before another computer’s, but found after, still loses.

Sealed: each record is encrypted here (XChaCha20-Poly1305) with a key made from a passphrase (Argon2id) and kept in each computer’s keyring. The folder and its server see which computer wrote, when and how much, never what.

What is shared comes in parts (PARTS: settings, senders, the spam filter’s table and label logs, health, time, drafts, projects, lists, notes, papers), each switched on or off on each device. Notes and papers travel one file at a time, each sealed apart in the folder (blobs), their records saying which content each file holds; two devices changing one file keep both versions. The spam filter’s table is sealed apart too: one file of a few megabytes, read in every exchange (SPAM_TABLE). Before another device’s change is written into a file here, the file as it was is kept on this device (history), to be put back.

Structs§

Awaited 🔒: A round waiting for the end of the round before (Memory::waiting_for).
Back: What putting a version back would change, said before it is done (put_back_preview).
Change 🔒: A change, sealed in a line: the entry and its new value, none once taken out.
FileStamp 🔒: A file as it stands: its inode (on Unix; a file written anew and renamed into place is another), its size and its time (nanoseconds).
Floor 🔒: What a format-1 entry renamed by format 2 last said, kept once this device writes format 2 (Memory::floors): a record of format 1 under that entry read again (a store joining, a record rebuilt, an older copy of a round put back) at or below it is passed over, so that nothing format 1 already said comes back.
Formats: What this device knows of the sharing’s formats, for the window (Settings ▸ Your folder and sharing, the status line): the format it writes, the parts met in a newer format than it knows (their format, the build that wrote it), and, while it writes format 1, the devices that hold format 2 back and why.
Found 🔒: What the files hold now, entry by entry.
Heard: What this computer read of the others’ records.
Here: This computer, as sharing knows it: its name, the machine it was made on (a copied configuration on another machine gets a name of its own), the folder it shares through.
Kept 🔒: The memory as the last exchange in this process saved it (Memory::keep), with memory.json as written and both files’ stamps: the next exchange, or a send asking what this device sealed (own_sealed), takes it while neither file changed, rather than reading them again. A phone’s background service exchanges every few minutes, and its files.json holds tens of thousands of entries (the texts’ lines): megabytes read at each.
Keyed: A list whose elements are entries, each named by some of its fields (none: the element itself), less the fields that stay on each computer.
Known 🔒
Line 🔒: One line of a computer’s file: its number in the round, its clock, the sealed change.
LineReader 🔒: The whole lines of a computer’s records from where they were left, read a piece at a time (READ_CHUNK), one line held whole at most: a line longer than any record (LONGEST_LINE: whoever wrote it) is given empty, a broken line, and skipped to its end. A last line not ended yet is left for the next exchange.
Listing 🔒: A listing of a folder of files sealed apart (notes, papers).
Look 🔒: How a look goes: which stores it reads, whether it must hurry, which folders’ emptying you confirmed, this computer’s clock (milliseconds).
Memory 🔒: What this computer remembers between two exchanges (memory.json); what it remembers of files sealed apart aside (files.json, Sealed): a big notes folder makes that long, and what the doses and claims ask (heard, written, traffic) reads the rest alone.
Names 🔒: The names of the notes and papers here or known, as a storage that does not tell case, nor how an accent is written, sees them (a phone’s, a memory card’s, Windows’, a Mac’s): two it would take for one are never both written.
Newer 🔒: A part met in a format newer than this Sioul knows (Memory::newer).
Opened 🔒: A sealed line’s change and its round’s turn (Turn), read in one pass.
Other: Another computer sharing through the folder, and when it last exchanged (Unix seconds).
Outcome: What an exchange did.
Placed 🔒: An element of a list format 2 names by ids, as give_ids left it: its entry in format 1 before, its entry in format 2, its value, and whether it stands for that format-1 entry (what format 1 last sent or received under it: the other devices hold it under that name, and give it the same id).
Quiet 🔒: An exchange that left everything settled (exchange): what it read, as it stood (Standing); its time and until when the next may do nothing (the hour’s tidying, this device’s notes due again); its memory’s two files as it wrote them; its own round and that file’s size; what it said.
Receiving 🔒: What writing the others’ changes needs.
Reference 🔒: A file sealed apart, as its record says it: its content’s hash, its size, when it changed (milliseconds).
Roots: The folders Sioul keeps its files in.
Rules: How a TOML file divides, beyond one entry per setting.
SealFile 🔒: The folder’s seal: how the key is made from the passphrase, and a value to check it with. The same on every computer; the passphrase never written.
Sealed 🔒: What this computer remembers of files sealed apart (notes, papers), beside its memory (files.json). Their entries, their files as last read and the changes waiting for them are kept here too, out of memory.json.
Sealing 🔒: A change as it is sealed in a line: the change, and on a round’s first line, its turn (Turn).
Seen 🔒: A computer’s own notes in the folder: when it last exchanged, its round, how far it read the others.
Sharing: Sharing as set up on this computer.
Standing 🔒: What an exchange reads, as it stands before it reads anything: the files of the stores it reads (each by its stamp), the folder’s top and what was fetched from the server beside it (remote::overlay: the pull writes there only what changed on the server), the other devices’ rounds and the seal by their stamps, every other name there by itself, and what each other device’s entry says but for its exchanges’ times (devices::steady). The same at the next exchange, and that one has nothing to read (quiet).
Stat 🔒: A file as last read: its size, when it changed (nanoseconds), its entries’ hashes, and when it was read (milliseconds, this computer’s clock).
Store: A file, or a folder of files, that is shared.
Turn 🔒: What the first line of a round says of where it stands, sealed with its change: a full round (new_round, a computer’s first), which restates all its writer holds, or one continuing the round before (SEGMENT), with the number of that round’s last line. A reader enters a continuing round only once it has read the one before to that line: a sync app may bring a round before the end of the one before, and that end, a dose marked taken among it, would never be read (docs/database.md, “The log”). An older Sioul’s lines say neither, and are read as before; an older Sioul passes over both fields.
WholeList 🔒: A list format 1 sends whole, as the whole lists seen here said it, each at its clock (Memory::lists), in whatever order they came: for each element one of them held, the latest clock of a list that held it, and the latest of one that did not. An element is taken out when a list without it came after the last one with it (removed). An element no list held is not in it: a list that did not know it did not take it out.

Enums§

Holds: Why a device holds back format 2 (format_holders).
Received 🔒: What came of another device’s change to a file sealed apart.
Refused: Why sharing cannot start.
Renamed 🔒: How format 2 names an entry format 1 named so (its path in its file).
Shape: How a file divides into entries.

Constants§

AWAITED 🔒: How long a round waits for the end of the round before (Turn), which a sync app may bring late, before that end is taken for lost: an hour (milliseconds) of exchanges, time asleep left out (AWAIT_STEP). Then the gap is said, the doses doubt what that computer marked until its next full round, and its later records are read.
AWAIT_STEP 🔒: The most one exchange counts of the wait (AWAITED): the time since the one before, five minutes at most (milliseconds). A device asleep, or closed, counts none of that time: woken, its sync app may not have brought the round’s end yet, and passing the round over then would ask for a full round for nothing (on a phone, megabytes of its texts: review of 10 October 2026, third pass).
CALLS 🔒: Where the calls’ part keeps its files in the records: remembered beside the notes (files.json, not memory.json), never kept as an earlier version nor copied aside when sharing starts, so that a call leaves every device after its month (calls_store).
CALLS_LOG: The phones’ logs of the calls they screened (sioul_core::calls): each phone writes its own file, a line per call, taken out after a month by that phone alone; every device reads them all, so that a computer’s Porch lists what your phones declined. Never a blocked caller’s call.
CALLS_SEEN: The calls marked Seen, each device’s own file, a line per press: seen on one device, gone from the Porch of every device.
CHECK 🔒
CONFIG_LOCAL 🔒: Where things are on this computer, and how text reads on its screen.
DAY 🔒
DRAFTS 🔒: The drafts’ folder. A draft taken out on one device (sent, or thrown away) while another changed it, each unaware of the other, stays taken out on every device, whichever came later; the change made meanwhile is kept among that device’s earlier versions (review of 5 October 2026, F22: a draft sent could come back, and be sent twice). Each record of a draft names the version it replaced (Change::b), and each device keeps every version of a draft it met (Memory::drafts): a change of a change of the version sent loses too (sent_meanwhile). An older Sioul’s records name none: the later word wins, as before.
EMPTIED_WAIT 🔒: How long a file must stay empty, or gone, before its entries count as taken out: one being written, a full disk or a crash never takes everything out everywhere at once.
FILES 🔒: The beginning of the names of folders whose files are sealed apart (Shape::Files).
FORMAT: The format of what travels, as this Sioul reads and writes it (docs/database.md, “The format of what travels”). 1: as Sioul 0.0.4 and every earlier one wrote it. 2: money lines, covers, mail rules, splits, presets and time sessions each named by its own id (Keyed::ids); pinned sites, routines, task kinds, days off, the words you added or took away and the lighter days one each, where they travelled whole. Each device says it in its entry (devices::Entry::format), and writes format 2 once every device in the sharing says it (format_open): an older Sioul, which reads format 1 only, is never sent what it cannot read.
FRUGAL_ROUND_SIZE 🔒: While the connection is metered, or measured slow (set_frugal), a full round, a megabyte or two sent at once, waits, as long as this computer appended less than this since the last one.
HOUR 🔒
IMPORT_ROUND_SIZE 🔒: While a bulk import goes on (set_importing), full rounds wait until this device appended this much since the last one: the import’s records go out once, in the rounds that continue the last full one, and a single full round follows the import, not one every few megabytes of it.
KEPT_TABLES 🔒: The spam filter’s tables a computer keeps in the folder: the one in use and the one before it, for a device that has not read the newest record yet. Each training that does no worse seals a new one, about two megabytes, once a week at most (docs/spam-filter.md); kept 90 days each, they would be a dozen, and a phone whose sync app never deletes a file (eDrive) would keep every one it brought.
KEY_NAME: The keyring’s name for the key made from the passphrase.
LARGEST 🔒: Files larger than this stay here.
LONGEST_LINE 🔒: A line of a computer’s records longer than this is none (the longest, a file whole of 16 MiB sealed in a line, is about 30 MiB): skipped as broken.
MARK 🔒: Before an element’s identity, in a list split by elements.
MASS 🔒: More files sealed apart than this gone from a folder at once (or three and more, past a fifth of it) are held, said, until you say to take them out.
MINUTE 🔒
NOT_NOTES 🔒: In the notes folder, what the other parts carry: projects, budgets, the bank, contracts (projects), the papers’ wallet and its folder (papers).
OWED_METERED 🔒: The longest a full round owed or asked for (Memory::owed) waits for a connection not metered: six hours of exchanges, counted as AWAITED is (milliseconds). A phone always on mobile data, which marks most doses, would otherwise leave the others saying “check” on its doses for days after one damaged line, until 4 MiB of growth.
PAD_LIMIT 🔒: How far a rewritten file’s size climbs before it starts again from the smallest.
PARTS: The parts of what is shared, each switched on or off on each device (docs/database.md, “Parts”): settings and accounts, senders, the calls your phones screened, the messages from your phones’ notifications, the spam filter’s table and label logs, health, time, drafts and invoices, projects and money, lists kept here, notes, papers. (texts: the part “texts”, SMS phase b, after the phone’s messages.)
PHONE_MESSAGES 🔒: Where the phones’ messages keep their files in the records: as the calls’, remembered beside the notes, never kept as an earlier version nor copied aside when sharing starts (calls_store).
PHONE_MESSAGES_LOG: The phones’ logs of the messages their notifications brought (sioul_core::phonemsgs), for the apps you switched on there: each phone writes its own file, a line per message, padded, taken out after a week by that phone alone; every device reads them all, so that a computer’s Porch says what came. Never a code, never a blocked sender’s.
PHONE_MESSAGES_SEEN: The messages marked Seen, each device’s own file: seen on one device, gone from the Porch of every device.
READ_CHUNK 🔒: Records are read this much at a time, never a whole file.
RETIRED 🔒: Stores an older Sioul shared and this one no longer has: a Garmin watch’s days and the memory of its offers, taken out on 8 October 2026 (docs/health.md, “Your watch”). A device on an older version may still send their changes: they are left aside, neither written nor kept waiting, and the rest of the exchange goes on. The files stay where they are on every device. texts: the first build of the texts, never released, kept them in the state folder (state/texts/).
ROUND_SIZE 🔒: What a computer appends past its last full round before it opens a new one, restating every entry it holds (new_round): old rounds can then go.
SEGMENT 🔒: A computer’s file past this size is continued in a new round of its own, nothing restated (docs/database.md, “The log”): a server sent the file whole at each change (WebDAV has no append) is sent a small one, never the opening of a full round (on a computer, a megabyte or two) again and again.
SEP 🔒: Between the parts of a setting’s name.
SILENT_DAYS 🔒: A computer silent this long no longer holds back the removal of old rounds.
SMALL_FILE 🔒: Small files of the folder are never read past this.
SPAM_FLAGGED: What your own spam filter flagged where it is, each device’s own file: the training’s, which learns from it until you say otherwise.
SPAM_LABELS: The spam filter’s label logs (sioul_core::spam::labels): each device writes its own file, a line per act, never rewritten; every device reads them all, so that a message you said is not spam on one is never flagged again on another, and the training on your computer learns from what you said on your phone. Small, read in every exchange.
SPAM_MOVED: What your own spam filter moved into a Junk folder, each device’s own file: no word of yours; the Porch’s lane of its catches reads it, and the training, which learns from it until you say otherwise.
SPAM_TABLE: The spam filter’s table (sioul_core::spam::table), made by a training on a computer, read by every device. Sealed apart, as its content’s hash: a new table is sent once, and the records stay small (whole in a record, its two megabytes would go again in every round its computer starts). A single file of Sioul’s own, in its private folders: read in every exchange, a phone’s background step’s too. Never the language model nor the corpus beside it: they stay on the computer that made them.
TEMPORARY 🔒: How the names of files being written end: what is left of them after a crash is cleaned after an hour (clean_leftovers).
TEXTS 🔒: Where the texts keep their files in the records: as the calls’, remembered beside the notes, never kept as an earlier version nor copied aside (calls_store).
TEXTS_LOG: Each phone’s texts, the whole history (sioul_core::texts::Text).
TEXTS_OUTCOME: Each phone’s word on each text it was asked to send.
TEXTS_SEND: Each computer’s texts to send, a random key each.
TOMBSTONE_DAYS 🔒: Entries taken out are remembered this long, so an old copy does not bring them back.
TWIN_WITHIN 🔒: A device finding its own file ahead of its memory twice within this (milliseconds) shares its name with another device (share-twin).
UNKNOWN_TURN 🔒: The turn of a round that does not know where the round before it ended (Turn::p): one that could not restate all (new_round) after a round of its own found without a line. No reader ever met that line: it waits for the round before as for a lost one (AWAITED), then reads on with the gap said, the doses in doubt until a full round, never as an older Sioul’s round, which would take all before it as read.
WHOLE_FOLDERS 🔒: Folders whose files travel whole (Shape::Whole, Shape::Files): their keys are the file’s name and an empty entry, #, and a name may hold # itself (“Facture #123.pdf”).

Statics§

BANK_RULES 🔒
CONFIG_RULES 🔒
CONFIG_RULES_2 🔒: Format 2: pinned sites, routines and task kinds one each, by their ids; days off one each; the words you added to a list and those you took away, one each (docs/words.md). Until then each of these lists travels whole, and two devices adding to one in the same exchange keep only the later list.
CONTRACTS_RULES 🔒
DND_PEOPLE_RULES 🔒: Who may reach you during do-not-disturb: one person each, by its id.
DND_RULES 🔒: Do-not-disturb’s switch (docs/do-not-disturb.md): a table per device, each written by its own device alone, shared whole.
DOSES_RULES 🔒: Each dose that fell due (sioul_core::doses): one entry per field, each device’s opening apart, and each device’s answer whole, so that two devices never write one entry and an answer never travels in halves.
FIRST_LINES 🔒: Whether each round’s first line read by later_full opens a full round, by folder, computer and round: a reader waiting for a round’s end looks at the later rounds once, not at each exchange.
FRUGAL 🔒: The sharings (by their memory) whose connection is metered or slow: full rounds wait there (FRUGAL_ROUND_SIZE).
HEALTH_RULES 🔒
IMPORTING 🔒: The sharings (by their memory) whose device imports in bulk now (set_importing).
KEEPING 🔒: Whether this process keeps the memory and the logs of lines between its exchanges (set_keeping); always in tests, which run the sharing through it.
KEPT 🔒: The memories kept in this process, by the path of their memory.json.
LEDGER_RULES 🔒
LEDGER_RULES_2 🔒: Format 2: lines, covers, mail rules, splits and presets each by its id, so that two the same stay two and one changed on two devices stays one; one without an id (made by an older Sioul, or by hand) by an id derived from what it holds.
LINES 🔒
LINKS_RULES 🔒
MINE 🔒
MONEY_RULES 🔒
PAPERS_RULES 🔒
PLAIN_RULES 🔒
PORCH_RULES 🔒
PROJECTS_RULES 🔒
QUIET 🔒: The settled exchanges of this process, by the path of their memory.
QUIET_RULES 🔒: The hours’ overrides and the two pauses (sioul_core::quiet); format 2: the lighter days one each, by their date.
QUIET_RULES_2 🔒
REVIEWS_RULES 🔒: How each day went (sioul_core::reviews): a date’s review at the end of work and the one before sleep travel whole, so that two devices answering the same one keep the later answer, never a mix of both; the weather field by field.
TIME_RULES 🔒
TIME_RULES_2 🔒: Format 2: each session by its id, so that one changed on two devices stays one; a session without one by its start, task and project, as before.
TODAY_RULES 🔒

Functions§

align 🔒
aligned 🔒: The elements of a file’s keyed lists (format 2’s), each with its entry in format 1 (its own, or its whole list’s when format 1 sends the list whole), its entry in format 2, and its value.
append 🔒
appended 🔒: Where this device’s last append ended (its round and last number), as noted before it was made (append): its own records found ahead of its memory up to there were its own, its memory not saved after (a process stopped, a full disk; an append cut short ends before it), not another device’s under its name (share-twin).
array_at 🔒: The array at path in a table.
asked_for_full 🔒: Whether another computer heard lately asks this one for a full round after a round of its own that no full round followed yet (Seen::full): a round this computer wrote, at or after its last full one.
base_of 🔒: For a file sealed apart, the content a change made here replaces: its hash as last known (“” new).
below_whole_floor 🔒: Whether a record of an element of a list format 1 sent whole (pinned sites, words, days off, routines, task kinds, lighter days) comes at or below the clock of a whole list that took that element out here (Floor::removed), the list not holding it since. Passed over, so that an element taken out before the switch never comes back, as when a device restates its old entries in a new round (share-own-cut). An element no whole list here ever held (added in format 2 elsewhere, its record waiting here) is never passed over: a list that did not know it did not take it out.
bound 🔒
calls_store 🔒: A store, a file or an entry of the calls’ part, or of the phones’ messages, by its name in the records: logs of lines that leave every device after their time.
clean_leftovers 🔒: What a crash left half written in a folder (the sealed files, the history), removed after an hour.
clock_ms 🔒: This computer’s clock, in milliseconds.
computers 🔒: Every computer sharing through the folder: those that wrote records, and those that only read so far (their notes); in the copy fetched from the server too (remote::overlay).
confirm_gone: The files gone at once from a folder of notes or papers (share-vanished) taken out everywhere at the next exchange, as you said: the folder by its name in the records (“files/notes/”).
conflict_copy 🔒: A file two devices changed, copied beside it before the other’s version takes its place, under conflict_name: dated by when the version it holds was made, so that every device holding that version names it alike and one copy travels, not one each. Returns where it is.
conflict_name: The name of the copy kept beside a file two devices changed, the same on every device whatever its language: “lease (conflict 2026-10-05 16.05)”, dated (in this computer’s time zone) by when the version it holds was made.
copy_private 🔒: std::fs::copy, the copy yours alone (make_private).
count_device_again: A device counted again (Count it again), whatever it said since.
derive 🔒
derived 🔒: The id format 2 gives an element without one: from its list and what, the stable key format 1 named it by (identity: a session’s start, task and project; a money line itself), the same on every device. Written into the element once, when the device takes format 2 (switch_format); until then, and for an element made without one since (by hand), its name. Shaped as a UUID (version 8: made here, by name).
divided 🔒: The files of the stores format 2 divides otherwise: their names in the records, where they are, their store.
each_id_list 🔒: Each list of tables in table that format 2 names by ids (Keyed::ids), with its path.
edit_item 🔒: A TOML value as toml_edit holds it: a table stays a table, a list of tables a list of tables.
element_name 🔒: The element’s name (after ␞) in an entry.
entries_of 🔒: A file’s entries and their values; none when it cannot be read as its shape says. Files sealed apart are read through, never whole (read_file). A list or a settings file that is not text (saved by another tool in another encoding, damaged) is none: never decoded lossily, which would send its replaced characters and, written back, take its other lines out everywhere (review of 5 October 2026, F25).
entries_then_and_now 🔒: A file’s entries in a version kept, and in the file now.
entry_of 🔒: The entry a key names in its file.
entry_stamp 🔒: When an entry was written, as far as its own times tell (each writing sets one of them to its device’s clock then, and none goes back).
estimate: What notes or papers would send from here, before their part is switched on: how many files, how many bytes, and how many stay (too big). Listed as an exchange lists them, nothing read through.
exchange: One exchange: the changes found here go out, the others’ come in. One at a time on this computer, whatever runs it (exchange_lock): another running, a quick one waits for it; a whole one does nothing, and says so (share-busy).
exchange_lock: One exchange at a time on this computer, whatever runs it (two Sioul started, the command line): a lock on <state>/share/exchange.lock, held while it runs, let go when the file returned is. wait: until the running one ends; else none while another holds it a second on.
file_of 🔒: <store><file>: the part of a key before its entry.
file_stamp 🔒
fill_heard_at 🔒: The clock of each other device’s last record in the folder, opened (sealed, bound to its device, round, number and clock), for the devices this memory has not heard of yet (Memory::heard_at): a memory from before it was kept learns when each device it read last wrote.
first_format 🔒
flatten 🔒
floor_key 🔒: The name a floor is kept under: a hash of the format-1 entry (whose name may be a whole money line).
flush 🔒: What changed in the files format 2 divides otherwise since the last look, sent in format 1 (this device still writes it), as an exchange sends it; not for a store joining in this exchange, nor a part held under a newer format.
fnv 🔒
folded 🔒: A name composed one way (NFC), its case folded.
forget_device: A device you said is gone (Settings ▸ Your folder and sharing ▸ Forget this device), as the sharing sees it: it no longer holds format 2 back, nor keeps a part held, until it says anything newer than now (an entry written since, a record read here: present). Waits for an exchange running.
format_holders 🔒: The devices that hold back format 2 (FORMAT), and why: of the devices that count (present), each must say in its sealed entry that it reads format 2 (devices::Entry::format), and all it wrote up to that entry (wrote) must be read here (read_n). A device whose entry does not read here, or known by its records alone, holds it back: an older Sioul cannot read format 2 and would double what it changes (an entry that no longer reads is said as such, even when an older one was seen here). A hostile folder can only hold it back longer, never open it.
format_of 🔒: The format this device writes, as its memory says (Memory::format), whichever computer’s it is.
format_open 🔒: Whether this device may write format 2: another device at least counts (present; alone, it writes format 1: a device joining later may run an older Sioul), and none holds it back (format_holders). A device not joined yet holds nothing format 1 could lose: every other device saying it reads format 2 is enough, and it joins in format 2.
formats
frugal 🔒
full_asked 🔒: The other computers whose records this one met past what it read in order (Memory::met ahead of read_n: a line lost, a round passed over as lost, a device first read from a round continuing one gone), each with the latest round of theirs met: a full round of theirs after it tells where they stand (Seen::full).
gather 🔒: What the stores hold; a file whose size and time did not change since known is taken from there, not read. What could not be read is unknown, its last look kept: nothing of it is taken out elsewhere.
give_ids 🔒: Each element of the lists of path that format 2 names by ids is given one in the file, once: the element that stands for a format-1 entry (what was last sent or received under it) the id derived from that entry (derived), as every device holding it derives it; another (a second session at one start, a second money line alike, a preset an older Sioul never carried) an id of its own, drawn at random, since it was never shared. Two elements holding one id (two devices changed one element apart while they wrote format 1): the one holding the greatest text keeps it, the other takes the id derived from its own format-1 entry. A preset’s id is put where splits and lines named it by its place (#3). Written through the file’s lock, the file as it was kept first (history). Returns every element of those lists.
hash 🔒
heard
holds: Whether this device holds a part met in a newer format than its Sioul reads (Memory::newer), as its memory says on the disk: the same in every process, after a restart too. For the doses: this device’s entry then says its doses are not known, and it never closes as if they were (docs/health.md).
identity 🔒: An element’s name in its list: its naming fields, or the element itself.
importing 🔒
is_leftover 🔒: What a crash left half written by Sioul: its hidden names ending so.
is_zero 🔒
is_zero_i64 🔒
is_zero_u64 🔒
keep_copies 🔒: Before the first exchange, a copy of every shared file, in case. Not of notes and papers, which may be large: each file is kept before anything is written over it (history). Not of the calls’ logs: nothing removes these copies, and a call leaves every device after its month. A copy there already is never written over: a first exchange tried again (one that failed after writing the others’ changes), or sharing stopped and started again the same day, keeps the files as they were before sharing (review of 5 October 2026, F22).
keeping 🔒
kept_by_windows 🔒: Names Windows keeps for its devices (“aux.md”, “COM1.txt”), and names ending in a dot or a space, which it cuts.
key_for: The key for a folder: made from the passphrase and the folder’s seal, which the first computer writes (64 MiB, 3 passes: half a second, once per computer).
key_with 🔒
keyed 🔒: A keyed list as format 1 names its elements: by by, or by themselves.
keyed_at 🔒: The keyed list at path in a file: by its name at the top (or one of its other names, Keyed::also), by its pattern within tables.
keyed_named 🔒: The keyed list a record’s entry names (<list>␟␞<element>, <table>␟…␟<list>␟␞<element> within tables).
known_part 🔒: The part a file of the records belongs to, whether this device shares it or not; none for a store this version does not know (its changes wait for a version that knows it).
last_heard 🔒: When another device was last heard of, from sealed facts only: its entry’s times (sealed, bound to it) and the clock of its last record read here (Memory::heard_at), in milliseconds; 0 when nothing is known. Never its notes in the folder, which are plain and could be forged.
last_line 🔒: The number of the last line of one of a computer’s rounds (0 for none).
last_of 🔒: A round file’s last line’s number (0 for none) and its size.
last_own 🔒: This computer’s last record in the folder: its round, number, and that file’s size.
last_record_clock 🔒: The clock of the last record of a round that opens with the key, read from its end.
later_full 🔒: The first of another computer’s rounds after round that opens full (Turn): it restates all that computer held, so a reader waiting for the end of an earlier round, which may never come (an older copy of it put back), reads on from there. Each round’s first line read alone.
leaf_text 🔒: A value as TOML text, v = …: one form for one value, whatever the file’s layout.
leaf_value 🔒
lines_of 🔒: A log’s lines, as entries_of reads them: from LINES while the file is the one read there, else read now (clock: this computer’s, milliseconds) and kept.
list_files 🔒: Every file below a folder, by its path from it with /; temporary and hidden files left out.
list_name 🔒: The record’s name of a keyed list at path: its own at the top, its path within tables.
list_names 🔒: A keyed list’s elements at path: their entries in format 1 (their own, or the whole list’s), and the elements as format 2 reads them (its local fields out).
locate 🔒: The store and the file a key’s file part names.
look_after_sealed 🔒: The sealed files this computer’s records point to, looked for now and then: one gone from the folder (taken out by hand, by another device that sealed it long ago and swept it, by the server) or not of the size it was sealed at (cut, damaged on the way) is sealed again from the file here, while the file still holds that content.
lost_here 🔒: A line of another computer’s round found damaged here (it does not read, or does not open), said and dated already (lost_line): its number, as the line says it (one that does not open), or the one after the line met before in its round (one that does not read). Met (Memory::met), so that a round continuing this one is entered and the rest of that computer’s records flow; never counted as read (read_n stays before it): what that computer wrote is not all known here until its next full round, and the doses doubt until then, as they did before rounds turned aside (5fa4dd1: review of 10 October 2026, S2-A). This device asks for that full round (Seen::full).
lost_line 🔒: A line of another computer’s round lost here (it does not read, or does not open): when its computer wrote it, at the latest, in seconds (the clock of the line after it, else now; never the line before it, which may be days older: review of 10 October 2026, S2-A), for the doses’ doubt (Memory::broken). None when it was met before: a line after it was read already (read_n), and this reading goes over the round again (a store joining, a record rebuilt): said once, never stamped anew. good: the last line of the round that opened in this reading, its number and clock (none for where an earlier reading stopped).
machine 🔒: A hash of the machine’s own id (/etc/machine-id), else of its name.
made_by_tools 🔒: Names that sync apps, editors and systems make beside your files: hidden ones, temporary and backup copies, conflicted copies, locks. Sioul’s own copies of a file two devices changed (“lease (conflict …).md”) are none of them.
make_private 🔒: A file the sharing copied (a copy takes its source’s mode) or appends to, made yours alone (0600) when others could read it. Never through a link.
matches_rule 🔒
met_draft 🔒: A version of a draft met here (Memory::drafts), with the one it replaced.
modified_ns 🔒
names 🔒: The names of a keyed list’s elements (their local fields taken out), in their order. Format 1: as by says, or the element itself. Format 2 (Keyed::ids): each element’s own id; one without (made by hand), or whose id another element of the list holds too, by the id derived from the key format 1 named it by (derived): a stable key, which changing what the element holds does not change for a session (its start, task and project), and the same on every device. Elements format 1 named alike are one entry, as they were in format 1.
names_read 🔒: The names of a list’s elements as read (local fields out); none for one that does not read.
new_private 🔒: A new file to write, yours alone (0600 on Unix); an error when one is there (create_new).
new_round 🔒: A new file for this computer, opening on every entry it holds the last word on, with their clocks; entries taken out long ago are forgotten. A file sealed apart missing from the folder (taken out there by hand) is put back first. cut: the round before lost lines (its file cut short, or found without a line), which a reader that had not read them waits for until a full round restates all.
note_entries 🔒: What this device has seen of each other’s sealed entry, kept (Memory::seen): the latest by its own times. An older copy put back in the folder (a replay by a hostile server) never lowers it.
note_wanted 🔒: The sealed files this device waits for, said for the pull to fetch (blobs::Wanted, remote::fetch_wanted): those this exchange found neither in the folder nor fetched beside it (missing: their content’s hash and size) join; those it found (there), and those no change waits for any more (written, or another change came), leave. Those of changes it did not look at (not read this time, hurried) stay. Nothing read nor written while nothing waits.
note_whole_lists 🔒: What each list format 1 sends whole holds now in the files format 2 divides otherwise, by format 2’s names (Memory::lists): an element a list no longer holds is noted as taken out at the clock of the list’s last word here (this device’s or another’s), until a list holds it again. While this device writes format 1, after each exchange and before the switch renames its memory.
note_whole_record 🔒: A record of a list format 1 sends whole (format 2 dividing it), as WholeList::saw takes it: the names, in format 2, of what it holds. Any other record: nothing.
of_the_doses 🔒: The doses’ two records: the marks (health-state.toml) and each dose’s record (health-doses.toml).
open 🔒
open_round 🔒: Another computer’s round, from the longer of its two copies: the folder’s, and the one fetched from the server (remote::overlay). Records only grow: the longer holds all the shorter does, and where each line starts is the same in both.
others: The other computers sharing through the folder.
others_heard: The same, each heard when its notes, its entry in the devices’ registry (devices) or its last record that opens last said so, the latest: a device put away restates its notes once a day (write_seen), its entry once an hour (devices::RESTATED), as Settings says when each was last heard of. A device whose records came before its notes and its entry (each file travels on its own) is heard of by its records: the doses count it, in doubt, until its entry comes (review of 5 October 2026, F5).
own_id 🔒: An element’s own id, when it has one.
own_sealed: The sealed files this computer put in the folder (blobs/<name>), by name, and the size it sealed each at: what it sends to the server itself beside the sync app (remote::send), whole, and nothing else of blobs/. Asked before each send: as this process last wrote or read files.json while it is still that file (MINE), else from that part of the file alone, the rest passed over, never built (on a phone, tens of thousands of the texts’ entries).
pad_for 🔒: A file written again in place must change size. The sharing asks little of the sync app that carries the folder (docs/database.md, “What the sync app must do”): new files and files that grow, copied some day, in any order. Some sync apps tell a change by its size alone: eDrive (Murena’s, on /e/OS) downloads a file changed elsewhere only when its size differs from the copy it holds (its FileDiffUtils.getActionForFileDiff), and others compare size and time. So each rewrite is padded one step past the size of the file there now, up to PAD_LIMIT, then from the smallest again: a copy held elsewhere matches the newest only when a whole turn of rewrites (several hundred) went by unseen, and the next rewrite mends it. size(pad) is the file’s size with pad characters of padding.
part_format: The format each part is written in at FORMAT: 2 for the parts whose records changed (settings, time, projects and money), 1 for the others. Each record says its part’s format when it is not 1 (Change::f).
place_of 🔒: Where a store is read, as the memory keeps it (Memory::places): its path, the projects’ file under its first name whichever it has, so that renaming it (sioul_core::projects::rename_file) is no move: a move rebuilds the file from the records, and a change made since would go.
placed 🔒: A table read from an entry’s text, placed in a file: written where it stands, its own tables under it. toml_edit writes a file’s tables in the order of the positions they were read at; those read from the entry’s text would put them out of place (a project’s routes under the project after it). So its tables keep none, and it takes at, the position of the one it replaces.
present 🔒: The other devices of the sharing that count, and what each says of itself (its latest sealed entry seen here, Memory::seen, a replayed older copy never lowering it): every device known here by a sealed fact (its readable entry, its records in the folder, or its records read here before, read_n, heard_at, whatever the folder shows now: a hostile folder hiding a device’s files never makes it go), but those that left (their entry says so), those you forgot until they say anything newer (forget_device), and those not heard of for SILENT_DAYS (one of which no clock is known at all, from when this device first found it so, Memory::unclocked). A file alone (plain notes, an entry that does not read) with no record is a stray file, not a device.
private_dirs: What the sharing writes is yours alone on Unix, as the calls’ logs are (sioul_core::calls::append_private): its files 0600, the folders it makes 0700, whatever the umask would let others read (the records, sealed files, the files it brings in from your other devices, the copies it keeps). A file there already with a wider mode is made yours alone the next time the sharing writes it: written beside then renamed, it takes the new file’s mode; appended to or copied, its mode is set. Never by a sweep of your folders. Where modes mean nothing (a phone’s shared storage, Windows), nothing is asked and nothing said. These folders made, with their parents, each 0700; folders there already keep their mode.
prune_tables 🔒: This computer’s own spam filter’s tables past the newest KEPT_TABLES taken out of the folder now, unless a record of this computer’s names one again (used: a table put back): that one goes by the usual rule. Never another device’s file: only those this computer sealed (mine). A device that reads only the newest record, as every Sioul does, never asks for them; an earlier version of the table kept by reference on another device can no longer be put back from the folder.
put_back: A version put back (history). A file whole goes back as it was, the file as it is now kept first. A file of entries (settings, lists, the doses’ record, sessions) is put back entry by entry: each entry the version held goes back to what it was, those taken out since come back, and those added since stay. Putting back never takes out, on any device, what was added after that version. The next exchange sends what changed as changes made here, dated now. stores holds every part, those switched off too (a part off here is put back here only); vault the sharing folder and its key, for a version kept by reference. Waits for an exchange running.
put_back_preview: What putting back stamp would change in file (put_back).
quiet 🔒: An exchange with nothing to do: the last one here left everything settled (Quiet), and since then nothing it reads changed (Standing, noted at taken, this computer’s clock), neither its memory nor this device’s own file in the folder (a sync app putting back an older copy changes its size), and nothing fell due. Its outcome is that one’s: nothing sent, nothing received, how far this device wrote, and its files looked at when their stamps were: as they were, so every answer captured here before is in its records (Outcome::looked). Else none, and the exchange runs.
read_file 🔒
read_seen 🔒: Another computer’s notes, the later of the folder’s and the copy fetched from the server (remote::overlay); the folder’s on a tie.
read_seen_in 🔒
read_small 🔒: A small file of the folder (a computer’s notes, the seal, a claim), never read past SMALL_FILE: one larger is no such file (whoever wrote it).
reads_now 🔒: Whether this exchange reads a store: every one, but notes and papers (files sealed apart in a folder) only when it reads them (Sharing::files).
rebuild: The entries of files read again from every computer’s records, this one’s too, at the next exchange; this computer forgets it held them, so that a record lost or broken here, started again empty, takes nothing out elsewhere and gets back what was written (docs/database.md, “Prudence”).
receive 🔒: Another device’s change to a file sealed apart, written here: its content opened from the folder beside the file and checked, then put in its place, the file as it was kept first (history: by reference when a record named that content, else copied). A file here that is neither what that change replaced nor a content the others’ records name (seen) changed here too: it is kept beside, under a name that says so (its path in the folder returned), never lost. A file changed here since it was looked at (gathered) is not written over. Nothing is written without room for it, for the copy kept, and some left (disk::kept_free).
reference 🔒
release_newer 🔒: Parts held for writers that no longer count (present: gone, forgotten, silent 180 days: a test build tried once): no longer held. Their changes in that newer format, kept waiting, are dropped; read again later, they are passed over (Memory::released).
remove_if_old 🔒: A file left half written, removed once an hour old: never one still being written.
remove_old_rounds 🔒: This computer’s old files, once every other computer heard lately has read past them.
rename_memory 🔒: The memory of one file said in format 2’s names, once its elements carry their ids (give_ids): the entry each element stands for becomes its entry in format 2 (its value now holding the id: its hash too), at the same clock; a list format 1 sent whole becomes an entry per element, its clock and what it held kept as its floor; an entry for an element no longer here (taken out) is named as stateless names it. Several of format 1’s entries for one element (its versions) make one: the latest clock, the version held. Each renamed entry keeps its clock as its floor.
renamed 🔒
restatement 🔒: What a full round restates: every entry this computer holds the last word on, with its value as it reads now, and how many of them it could not restate though their store is here and read (their file not readable now, a settings file held empty (EMPTIED_WAIT), a change found and not sent yet: their value here is not the one this computer last said). An entry of a store not here (a part switched off on this device, a store that left) is passed over, as it always was: it stops no round from being full (review of 10 October 2026, S2-B).
retired 🔒: Whether a record’s key names a store that left (RETIRED).
rewritten 🔒: What a file holds once entries are written into it; none when it goes.
round_file 🔒
rounds 🔒: The computers’ files in the folder: computer → its rounds.
rounds_with 🔒: The computers’ files in the folder and in the copy fetched from the server (remote::overlay): computer → its rounds, those of either.
say_broken 🔒: A line of another computer’s lost here, dated (Memory::broken): the latest such date is kept, never an earlier one, so a doubt once said only grows.
seal 🔒
seal_apart 🔒: A file sealed apart put in the folder before its record goes out (blobs); false when it could not be (it changed while read, a full disk): its record waits for the next look. Anything else needs nothing.
sealed: Whether the folder already holds a seal: another computer shares through it.
sealed_for 🔒: The sharing folder as each exchange finds it first (review of 5 October 2026, F5 and F20). Gone (a disk not mounted, a sync app’s folder moved): an error, and nothing is made, read or written (share-no-seal), never a new empty folder whose files would later meet the real ones as conflicted copies. Else its seal: none (a seal that does not read, an empty placeholder of one, is none), or whether it opens with this device’s key, and its salt (which sharing it is). Gone, or not opening, where this device saw it open before (Memory::seal_seen: a folder made again by a sync app, another device’s seal put in its place), nothing is written either, said (share-no-seal, share-sealed-otherwise): never under a key the others lack; sharing set up again with the passphrase the folder’s seal holds mends it.
sealed_path 🔒: Where what this computer remembers of files sealed apart is kept: files.json, beside its memory.
seen_path 🔒
sent_meanwhile 🔒: How a record of a draft is decided (DRAFTS): Some(true) it wins, Some(false) it loses, whichever came later; None, the later word wins, as ever. here: the draft here, or what came for it earlier in this reading (taken out, its version, the version it replaced); met: every version of it met here.
set_frugal: Said by the window before its exchanges: the connection is metered, or measured slow (remote::Sending::slow); a full round, sent whole, then waits for a better one, within FRUGAL_ROUND_SIZE. memory: the sharing’s.
set_importing: Said before each exchange, by the background step and the window alike: a bulk import goes on here (a phone’s first import of its texts, or one it fell behind in), so that no full round restating every record starts meanwhile (IMPORT_ROUND_SIZE). On 8 October 2026 a first import of 10 MB of texts made six full rounds, 63 MB in all, each sent twice.
set_keeping: Said once by a process that exchanges every few minutes for a long time (a phone’s background service): the memory and the logs of lines are kept between its exchanges (Kept, LINES), rather than read again at each. They weigh some tens of megabytes with many texts shared (about 30 MB for 10 MB of texts): a window’s process, which holds little between its minutes, reads them again at each (docs/android.md, “In the background”).
set_path 🔒
settling_ms 🔒: A file sealed apart changed this recently may still be being written (an editor writing it in place): read at the next look.
shaped: The stores as a format divides their files (Rules::at): format 2’s rules from 2 on, where they differ.
shared_by_default: Whether a device that never chose shares a part: what was shared before parts had switches, everything but notes and papers, and projects as the setting all devices followed then said (share_projects); the spam filter’s table, which every device reads. Never the phones’ messages, newer than the switches: each device shares them once you turn them on there.
shown: A file’s name in the records, as shown: without the folder Sioul keeps it in (“config/config.toml” → “config.toml”, “files/notes/admin/lease.md” → “admin/lease.md”).
stamp_at 🔒
stamp_below 🔒: Every file below path (or path itself), hidden ones left out, by its stamp.
stateless 🔒: The name format 2 gives an element format 1 named ident when the file here does not say otherwise: format 1 named it by itself (by empty), and its own id, else the id derived from it, names it; by its id: that id; by other fields (a session by its start, task and project): the id derived from them, the one written into it when a device took format 2.
stores: What is shared, each part as a device that never chose shares it (shared_by_default).
stores_of: What is shared of the parts shares keeps. Not shared: caches, how far each sync got, how pages are shown on this screen, the site notices of this computer’s browser, your own PGP keys (secret keys never leave the computer they were made on).
strip_local 🔒
switch_format 🔒: This device takes format 2 (FORMAT), once and for all, before this exchange goes on:
table_at 🔒: The table at path below table: made when make (implicit, as a file’s own tables are), else none when it is not there. A table written inline becomes a table of its own.
temporary 🔒: A hidden name beside path for a file being written, never another’s: two exchanges, two Sioul running, never write into one (“.lease.md.4211-7.sioul.tmp”).
text_to_write 🔒: A list’s or a settings file’s text, to write entries into: none there yet is an empty one; one that cannot be read, or is not text, is an error, and what came for it waits (never the incoming entries alone written in its place).
toml_entries 🔒: A TOML file’s entries: one per setting, one per element of a keyed list, one per table kept whole; the settings that stay here left out.
toml_write 🔒: Sets or takes out entries in a TOML file’s text, keeping the rest as written; renamed: the file has another name than its record’s (Keyed::also).
traffic: When each part last sent a change from here, and last received one (Unix seconds; 0 never).
translate 🔒: Format 1’s changes (older: by entry, the later of each), for the files format 2 divides otherwise, in format 2’s names. Passed over: one at or below what format 1 already said under that entry here (Floor). An element’s change takes the name format 2 gives it: its own id; for a session (named by its start, task and project) without one, the id of the session of that name here (a device on format 1 writes a session without the id the switch gave it here: the id is kept), else the id derived from that name; for a money line, its id, else the id derived from it. A value without its id takes the id it goes under, written into it: what the switch wrote stays. From an older Sioul (modern: the writers whose sealed entry says they read format 2; the others), a line’s removal named by a version this device does not hold any more (a copy changed since) is passed over; from a device that reads format 2 and still writes format 1 for a few minutes, the later word wins. Several entries for one element (an older Sioul changes a line by adding its new version and taking the old one out) make one change: the latest version held, at the latest clock; none held, taken out. A list sent whole sets what it holds and takes out, of what the previous whole list held, what it no longer holds, at its clock: never an element added since in format 2. Returns the changes, and the names that differ from what a device holding none of them would give (a session whose own id was kept here, its value carrying none): sent again from here in format 2, so that every device, one joining later too, holds it under one name.
unfinished 🔒: Where a file’s last whole line ends, when it does not end one: its end read back a piece at a time, never the file whole. None when it ends a line, or is empty or not there.
value_hash 🔒: What an entry’s value is known by: a file sealed apart by its content’s hash, anything else by its value’s.
value_of 🔒: An entry’s value, read from its file now.
wait 🔒: A change kept waiting (Memory::waiting): the later of two for one entry.
whole_lists 🔒: The elements of the lists of words and dates format 1 sends whole (format 2 names them by themselves, no id to give): each stands for its whole list’s entry when the file holds what was last sent under it.
with_ids 🔒: A keyed list whose elements are named by their ids (format 2); by: as format 1 named them.
without_id 🔒: An element as text, its id left out: what two versions of one element compare by.
writable 🔒: Whether a file may be written where a record says: never through a link below its store’s folder (a link to elsewhere would carry the write out of it), nor over a link, nor inside the sharing folder (it would travel in plain) or Sioul’s own state, but for the stores of that state itself (state/…: the shield’s answers, local lists’ state, the spam filter’s label logs), which live there by design, each in its own folder.
writable_in 🔒
write_atomically: A file written whole beside its place under a hidden name, yours alone (new_private), then renamed over it: never half a file, and its folders made yours alone (private_dirs).
write_elements 🔒: The elements named so of a keyed list in table (changes: each name and its value, none to take it out), all named as the list holds them before any of them changes: replaced (their local fields kept), added, or taken out. list: its name in the records; at the top, the list keeps the name it has in the file (Keyed::also).
write_entries 🔒: Writes entries into one file: each (entry, value), None taking it out; under the file’s lock, as the window writes some of these files too (the doses’ record: sioul_core::filelock). Before the file changes, or goes, keep keeps it as it was (history).
write_seen 🔒: This computer’s notes in the folder, when what they say changes (its round, how far it read the others); else restated a quarter of an hour after the last while this device is in use (its entry says it: another device’s do-not-disturb hears of a computer in use by them), once a day while it is put away (a phone’s background step: how far it read changes rarely, and the sync is not asked to carry a file every few minutes). Returns when they are due again (milliseconds).
write_synced 🔒: The same, the bytes on the disk before the name changes: a file whose loss costs more than a minute’s work (this computer’s name and sharing, its memory).
write_then_rename 🔒
writes: The format this device writes (FORMAT): 1 until every device reads format 2 (format_open), then 2.
written: How far this computer wrote its records: its round and the number of the last, for its claims to say (lease::Claim::wrote); none before sharing.

Type Aliases§

Lines 🔒: Each log of lines (Shape::Lines) as this process last read it, by its path: the file’s stamp then, when it was read (milliseconds), its lines. Read again only once the file changed, or when it was read within settling_ms of its change (a coarse clock: it may have changed again at the same size and time). The texts’ log alone is megabytes of sealed lines, once read at every exchange of a phone’s background step.
Mine 🔒: What this device sealed in the folder (Sealed::mine, by name, the size sealed), as files.json said it when last written or read in this process (its stamp, and whose it is): what each send asks first (own_sealed), a few names.

Module share

Module share Copy item path

Structs§

Enums§

Constants§

Statics§

Functions§

Type Aliases§

Module share