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.
DeviceFiles: What “Remove its files” takes out for a device, and what stays, as the window says it before you press (device_files, remove_device_files).
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.
GoneDevice: A device that no longer counts here and still has files in the folder (departed_devices): why it no longer counts (“left”, “forgotten”, “replaced”), the bytes of its records, its name and kind as its last entry seen here said them.
HandedOff 🔒: The lock held for a batch of the copies beside drafts, handed to an exchange waiting in this process when let go (hand_off), let go at once when none waits here; it ends after its copy once one does (waiting_here).
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).
PutBack: What “Put them back” did (put_back_withheld): how many came back, of how many were held from that folder (as the Porch counts them). Fewer is said as such, never as done: other files or links are at their places, or their contents are not on this device (review of 18 October 2026, M-1).
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).
RemovedDevice: A device whose files you removed here (Memory::removed_devices): when (milliseconds); its last round then and that round’s size: the rounds before it stay out by the floor of the rounds past (Memory::departed), that one while it is no longer than it was (a copy a sync app brings back; a device still in use that goes on writing it makes it longer, and it comes); whether its entry and its note of how far it read go too (small_go, judged again at each exchange: forgotten here, then replaced, they go then); and each of its small files then, by its place in the folder and its content (small_seen; its size, small, for a removal by an earlier build): a copy of one is taken out again only while it is the same bytes (a sync app bringing it back), never one it wrote since (a claim renewed, its texts to send) (reviews of 17 and 18 October 2026, L7 and L-5). Its claims and its texts to send went in every case.
Roots: The folders Sioul keeps its files in.
Rules: How a TOML file divides, beyond one entry per setting.
SavePrepared 🔒: The memory’s files written ahead (Memory::prepare_save): hidden, synced and closed, each beside the file it replaces; taken away unless put in place.
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.
Waiting 🔒: One exchange waiting for the lock, counted until it holds it or gives up.
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.
Withheld: Notes or papers gone many at once from this device and held (GONE_GRACE), by folder of the records (“files/notes/”): how many, when the first and the last went and when the last leave your other devices by themselves (milliseconds), unless they come back, and where they were, said shortly (bulk_folders: the deepest folder holding four in five of them, else the few that hold most, else the folder above them all).

Enums§

Counted 🔒: Where another device of the sharing stands, by sealed facts (counted): what present keeps, and why it leaves a device out.
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§

AGED_TOMBSTONE_DAYS 🔒: The lines of the logs every device ages out by itself (ages_out) taken out are remembered this long, past the longest one of them keeps a line anywhere (its writer KEPT_DAYS, the others LATE_DAYS more): a line older than that is never shown and goes by itself on a device back after longer. They are many, a line for each call and for each message of the phone’s, each a few hundred bytes (a message’s padded), its whole line its name, and each full round restates them: 90 days, as before 17 October 2026.
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).
FILE_PARTS 🔒: The parts whose files are sealed apart (Shape::Files): what one of their records names is a sealed file of the folder, the same bytes the same file whatever the part (blobs::name): a note and a paper alike.
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.
GONE_GRACE 🔒: Notes or papers gone many at once from a folder still there (deleted in bulk, a folder moved within the notes): held this long from when they went (Sealed::gone), said on the Porch with “Put them back” and “Take them out now” (withheld), then taken out everywhere by themselves, unless they came back. Nothing has to be pressed (until 17 October 2026, they waited for “Take them out everywhere”, however long that took). Two weeks, as replaced contents stay (blobs::UNUSED_DAYS).
GONE_GRACE_DAYS: The same in days, for the window to say.
HAND_OFF_MOST 🔒: The longest a holder letting the lock go waits for an exchange of this process to take it before taking it again (hand_off).
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.
LARGE_SETTLES 🔒: A note or a paper this large (bytes) is sealed only once it has settled (large_settling_ms): a recording or a scan saved again within minutes goes once, its last save, not each one. On 14 October 2026 four earlier takes of the owner’s recordings, 15.7 MB, were sealed 13, 16, 25 and 1 minute before the next save, and each stayed in the folder as long as replaced contents stay: ten minutes would have kept only the last of them (3.5 MB) off it. Smaller notes go as before.
LARGE_SETTLING 🔒: How long a note or a paper of LARGE_SETTLES or more stays unchanged before it is read and sealed. One that never stops changing still goes an hour after it was first found changed (read_file, Sealed::changing).
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_ASK: Each computer’s replies to send to the phones’ notifications, its own file, each line padded and sealed at rest by its writer (sioul_core::replies::Ask); also sent on the lane of the texts to send (remote::place_asks). A week, then gone.
PHONE_MESSAGES_LIVE: What each relayed notification offers a reply from a computer, each phone’s own file (sioul_core::replies::Live): a Reply, a Mark as read, or that it went; no words, no names. Taken out with the log.
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_OUTCOME: Each phone’s word on each reply it was asked to send (sioul_core::replies::Outcome): never the words. A week, then gone.
PHONE_MESSAGES_SEEN: The messages marked Seen, each device’s own file: seen on one device, gone from the Porch of every device.
PREPARE_AGAIN 🔒: How many times a file changed between its copy and the exchanges’ lock is copied again outside it before it is copied under it (put_back).
PUT_BACK_BATCH 🔒: How many held files are opened at once, outside the exchanges’ lock, at most, and for how long at most (PUT_BACK_HOLD); they are then placed under it in short holds (in_short_holds), the lock left free a while between two (PUT_BACK_FREE), for whatever exchange waits for it, a dose’s first. Until 18 October 2026 the put back took it again at once, and a dose’s exchange waited up to 14 s for it on a computer; until 20 October 2026 it placed a whole batch in one hold, 1.1 s on CI’s Windows job.
PUT_BACK_FREE 🔒
PUT_BACK_HOLD 🔒
READ_CHUNK 🔒: Records are read this much at a time, never a whole file.
REMOVAL_PLANS 🔒: How many times “Remove its files” plans what goes outside the lock, an exchange having written the memory meanwhile each time, before it says busy.
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.
SHORT_HOLD 🔒: The longest one hold of the exchanges’ lock does work that grows with a count of files (in_short_holds): placing notes put back, taking a device’s files out. The copies beside drafts keep the same bound (sioul_core::draftcopies, HOLD_AT_MOST).
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.
TAKE_OUT_COPIES 🔒: The take-outs of an exchange copy at most this many bytes into the earlier versions (where a file cannot be moved there: a phone’s shared storage), the first whatever its size; the rest wait for the next exchanges, a minute apart. A bulk of thousands of notes taken out on a phone would otherwise copy them all in one exchange (review of 17 October 2026, L9); the history’s cap holds them all in time (a GB, or a twentieth of the disk).
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_MARKS: Each device’s marks on conversations: read, hidden (deleted in Sioul).
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, and each full round restates them (new_round): as long as a device may be away and still count (SILENT_DAYS). A device you forgot, or one another replaces, no longer holds the others’ rounds back; back within that time, it counts again and reads from a full round, which must still say what was taken out meanwhile (but the lines of the logs every device ages out by itself: AGED_TOMBSTONE_DAYS). Until 17 October 2026 it was 90 days, and such a device back after more than 90 days kept for good what the others had taken out (review of 17 October 2026, M1).
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 🔒
REMINDERS_RULES 🔒: What each device did to remind each dose (sioul_core::dose_reminders): each device’s entry for a dose written by it alone, and travelling whole, so that a notice said sent and a promise of quiet never travel apart.
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 🔒
WAITERS 🔒: By the exchanges’ lock file, in this process: how many wait for it now, and how many times one that waited took it (exchange_lock).

Functions§

after_plan 🔒: After each plan of a removal, what a test asks (AFTER_PLAN); nothing in a build.
after_prepare 🔒: After each copy made ahead of the lock, what a test asks (AFTER_PREPARE); nothing in a build.
ages_out 🔒: Whether an entry is a line of a log every device ages out by itself (AGED_TOMBSTONE_DAYS): the calls’ logs, the phone’s messages’ logs, the texts’ requests and outcomes; never the texts themselves, whose log only grows.
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.
asking: Who may ask this device to act for them (texts’ and replies’ requests), in two sets: the devices the sharing counts now (as counting), and those gone by a sealed fact (they left, you forgot them, another device replaces them: Counted::departed). Any other device is not known yet: its records have not come (a new computer’s first request may come before them), a file alone, or a device silent for weeks that wakes; its request waits while it is fresh, never refused for good.
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 🔒
bulk_folders 🔒: Where files gone many at once were, said shortly, by their place in the store (“” for its own top): the deepest folder that holds four in five of them; else the few folders below it, three at most, that hold four in five of them together; else that folder, which holds them all. For thousands of files in hundreds of folders (a tool’s run folders), the folder above them all, never three of them picked at random (review of 17 October 2026, L5).
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.
clean_leftovers_below 🔒: clean_leftovers in dir and its folders, a few deep: the folders whose files travel whole (drafts, calendars and address books kept here), where a crash in a receive, a Put back or a copy’s replacement leaves a hidden file that nothing else ever sweeps (review of 19 October 2026, F17).
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/disk/”, or a whole store, “files/notes/”), what is below it too, never a folder beside it; or a note replaced by a link (“files/notes/single.md”: confirms).
confirm_withheld: “Take them out now”: the files held after going many at once from a folder of the records (“files/notes/”) taken out everywhere at the next exchange, those alone (Sealed::confirmed_files): a folder that lists empty beside them (a disk not mounted at its place in the notes) stays unknown until its own line says so (confirm_gone; review of 17 October 2026, M1). How many.
confirms 🔒: Whether what you said to take out everywhere (Sealed::confirmed: a folder by its place, “files/notes/disk/”, or one note replaced by a link, “files/notes/single.md”) covers file (a file’s or a folder’s place): what is below that folder, or that note; never a name beside it.
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.
content_hash 🔒: A small file’s content, by its hash (SHA-256): a copy brought back is the same bytes; one written since never is, whatever its size.
copy_private 🔒: from copied to to, yours alone (make_private), as one version of it held it whole (filelock::copy_whole: never a file replaced while it was copied, whose old bytes may be zeros by the end).
count_device_again: A device counted again (Count it again), whatever it said since.
counted 🔒: Every other device known here, and where it stands (Counted): every device known by a sealed fact, as present says, and the stray files of the folder (notes alone). A stray file you forgot, or that a replacement names, is said so.
counting: The other devices that count here now, by sealed facts (counted): not left, forgotten, replaced, silent for SILENT_DAYS, nor a stray file. Only these may ask this phone for what your own devices alone may ask (a reply from a computer, sioul_core::replies::verdict).
departed_devices: The devices that no longer count here (they left, you forgot them, another replaces them) and still have files in the folder: Settings lists each with “Remove its files”.
departed_past: What the sending and the pull ask of the memory without the key (remote), as the last exchange left it: each device that no longer counts by a sealed fact, and the round below which its rounds are past their time here (Memory::departed): never fetched again, taken out of the server at a listing. Empty when the memory is not this computer’s.
departed_rounds 🔒: The past rounds of the devices that no longer count by a sealed fact (Counted::departed: they left, you forgot them, another device replaces them), each device’s below the round returned: below its last full round found in the folder (Turn::full on its first line, sealed: a hostile folder can hide a later one, never show one that is not), never that round nor those continuing it, and only those every reader read past (readers, this device’s own reading among them). Such a device never takes its own out again (a phone dead for good): any device that counts does, each in its own folder, and its sending on the server over the ETag listed there; two at once find it gone (404) or changed (412), and leave it. A device with no full round found (an older Sioul’s rounds say none) keeps every round. A device forgotten that says anything newer counts again at once (counted), and its rounds are its own again.
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).
device_files: What “Remove its files” would take out for device, and what stays, for the window to say before you press; None for a device not known here.
device_small_files 🔒: A device’s own small files in the folder and in what was fetched beside it (remote::overlay): its claims, its texts to send, its entry when entry, its note of how far it read when notes. Those there only.
device_small_places 🔒: The same, each with its place in the folder (leases/health/<id>.lease).
divided 🔒: The files of the stores format 2 divides otherwise: their names in the records, where they are, their store.
draft_copies_kept_before_sharing: The copies beside drafts kept before sharing began (keep_copies: before-sharing-<day>/data/drafts/<id>.eml, beside memory), which nothing removes: until 19 October 2026 one could hold an encrypted message’s text in clear (sioul_core::draftcopies::seal_versions encrypts those again).
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, nothing removed.
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).
full_round_after 🔒: What this computer appends since its last full round before it opens the next: as much as that round restated, and a megabyte at least (ROUND_SIZE). A phone’s full round restates its whole archive of texts (16 MB on the owner’s phone, 14 October 2026); opened at each megabyte appended, as until 15 October 2026, the full rounds cost the folder and the connection many times what was appended (eDrive sends each twice). Now restating never costs more than what was appended since, and the rounds a device joining reads stay within twice the last full round. Its size, not known to a memory from before, is read once from that round’s file.
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.
hand_off 🔒: The exchanges’ lock let go between two short holds (in_short_holds, the copies beside drafts, “Remove its files” planning again): when an exchange of this process waits for it (a dose’s alarm, the window’s), the holder takes it again only once that one has taken it, or a second has passed, so that a waiter slow to wake (a loaded machine, a busy phone) never loses the hand to it again and again (CI’s macOS job of 20 October 2026: two holds back to back, 0.41 s). It stops waiting too as soon as fewer wait than when it let go: a waiter that gave up, or that lost the lock to another process, never keeps it a second (review of part 4, D-1a). With none waiting here, a moment (free: PUT_BACK_FREE between short holds; none for the copies beside drafts, which let go LET_GO between their batches and nothing after the last, D-1b): a waiter in another process (the command line, a phone’s background service) gets that moment alone, as before, since a file’s lock keeps no queue.
hash 🔒
heard
heard_of: When device was last heard of here, from sealed facts only (last_heard: its latest entry read here, its records’ last clock read), in milliseconds; 0 when nothing is known. What a replacement says of it (devices::Replaced::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 🔒
in_short_holds 🔒: each done for every one of items under the exchanges’ lock, a fifth of a second at a time (SHORT_HOLD), the lock then left free a moment (PUT_BACK_FREE) for whatever exchange waits for it, a dose’s first, and taken again for the rest: work that grows with a count of files never keeps an exchange waiting for its whole. An exchange may run between two holds: each looks again at what it does under its own hold. A hold passes its fifth of a second by the one item it does then, at most, and ends after the item it does when an exchange of this process comes to wait (waiting_here): a dose’s alarm waits for one item, not the hold’s rest. The lock that cannot be taken stops it: why, and the items left.
is_leftover 🔒: What a crash left half written by Sioul: its hidden names ending so, and those its replacements write beside a file (filelock::Prepared, filelock::replace: .<name>.<process>-<number>.new).
is_seal: Whether bytes are a seal of Sioul’s (a folder’s seal.toml): a few lines that read as one, with a salt and a check. Says nothing of the passphrase (key_for does): for finding the folder on a server (remote::seek).
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 🔒
keeps_itself 🔒: Whether Sioul keeps this sharing’s folder itself, with no sync app (remote::mirror_of): its folder is its own copy of the server’s.
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).
large_settling_ms 🔒
last_full 🔒: The last of a computer’s rounds in the folder that opens full (Turn): it restates all that computer held then, and every round before it is past for whoever read that far (departed_rounds).
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.
lock_waiting 🔒: The lock taken, waiting for it: the system’s wait (as slow to wake as a test asks, SLOW_WAKE).
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.
needed_sealed: Sioul keeping the folder itself: the sealed files its copy keeps though the server may no longer list them (Sealed::needed), by name, as the last exchange said them; for the pull, which has no key and lets go of the others (remote). None when the memory is not this computer’s, or does not say it yet (an older Sioul’s, before this one’s first exchange): then nothing is let go.
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’ records: the marks (health-state.toml), each dose’s record (health-doses.toml), and what each device did to remind it (health-reminders.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.
opens_full 🔒: Whether a computer’s round opens full: its first line opens with the key, bound to that computer and round, and says so (Turn::full).
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).
past_below 🔒: The round below which a computer’s rounds are past their time: every reader (readers) read past them (its notes say a later round: it met their end, Memory::met, or read on from a later full round; a reader without notes in the folder read none), and never its last full round nor the rounds continuing it: a device joining reads from the oldest kept, and finds every entry there (share::rounds_tests). A device forgotten that comes back counts again at once, its notes with it, and reads from the oldest kept the same way.
place_new 🔒: A file written beside its place taken there only while none is (a hard link refuses to take an existing name; where links cannot be made, a last look, then a rename). Whether it took the place; the file beside goes in any case.
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.
place_put_back 🔒: One file of “Put them back” placed, under the exchanges’ lock (its caller’s hold): after a last look (nothing at its place, a link included, and still a place the sharing writes), in its own folders made only now (L-1), dated as it was only now (M-1), through a hard link that takes only a free name. Whether it came back; the file opened beside goes in any case. A folder that cannot be made stops the put back, said.
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.
plan_removal 🔒: What “Remove its files” would take out for device: its paths, its sealed files’ names, those that go later, and what is said (DeviceFiles). None for a device not known here.
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), those another device’s entry says it replaces, until they say anything newer than it says (devices::Entry::replaces), 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. The same devices as counted says count.
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).
put_back_withheld: The notes or papers gone many at once from a folder of the records (“files/notes/”) and held (Sealed::bulk, as the Porch counts them: never a note you deleted on purpose beside a bulk’s remainder, as Take them out now takes those alone: review of 18 October 2026, I-1), put back where they were, each from its content sealed in the folder (or fetched beside it), dated as it was last seen here, or, held before this was kept (Sioul up to 17 October 2026), as its last record was made (within a minute of the change, on a computer in use; at its first exchange, for a file older than the sharing): the next exchange finds them back, and nothing leaves. Never through a link, nor into the sharing folder or Sioul’s state, nor over a file there, one written there meanwhile included; never without room for it and some left (as every write of the sharing, disk::fits). A quarter of a second’s worth at a time, each file opened under a hidden name in the deepest of its folders that is there, outside the exchanges’ lock, which is taken only to make its own folders, date it and place it, after a last look under that hold, a fifth of a second at a time (in_short_holds), then left free a moment: a dose’s exchange never waits for more than a fifth of a second of placing them and the one file placed as it passes, even behind a note or paper of tens of megabytes, even on storage that takes tens of milliseconds a file (thousands take half a minute: reviews of 17 and 18 October 2026, L1, L-3 and L-a; CI’s Windows job of 20 October 2026). No exchange meets a folder made for them before its note is in it: holding hidden files alone, it would list empty, taken for a folder emptied, and its notes would leave the hold, for good after a stop meanwhile (L-1); a stop leaves them held, and Put them back again brings them. Each is dated as it was only under the lock, just before it is placed: an exchange’s sweep of leftovers takes a hidden file dated more than an hour ago, and none runs while the lock is held (M-1). How many came back, of how many were held (PutBack); a disk too full stops it, said.
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).
readers 🔒: The devices whose reading holds back the removal of a device’s rounds (past_below): every device that counts (counted), whose notes say how far it read (none in the folder: nothing read, everything held back; a hostile folder hiding them never makes a round go), and a file of notes alone whose notes say it read within SILENT_DAYS (a device whose entry has not come yet: plain notes only ever hold more back). Never a device that left, that you forgot, that another replaces, or silent for SILENT_DAYS by sealed facts, whatever its notes say: until 16 October 2026 every device whose plain notes were heard within 180 days held them back, a phone dead for good among them, and nothing of the others’ left the folder for half a year.
readers_by_notes 🔒: The readers as the rule was until 16 October 2026: every other computer whose plain notes were heard within SILENT_DAYS. For a memory that does not say who counts yet (Memory::counting: one saved by an older Sioul, before its first exchange since).
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”). The files left as they are, what they hold may be what was there before: at that exchange they join as a store new here does, read from the records first, only what the records lack going out (Memory::rejoin), so that an old mark never goes out again with a fresh clock (review of 15 October 2026, RV-P2).
rebuild_then: As rebuild, then then, which sets the files aside (the doses’ repair: HealthState::set_aside), run while the exchanges’ lock is still held, before any exchange can read those files again. Run apart, an exchange between the two steps filled the lost record again from the records, the full record was then set aside, and the next mark written made every other mark look taken out, on every device (review of 15 October 2026, P1). Set aside in that same step, the files hold afterwards only what was written after the repair: it goes out as changes made here, never replaced by an older record of the same entry (a dose marked again after it was taken back elsewhere was lost on every device: RF-J).
rebuild_with 🔒
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_device_files: “Remove its files” for a device that no longer counts here (it left, you forgot it, another replaces it: sealed facts and your own word only; a live one is forgotten first, by the window): every round of its records (its last full round too), its entry, its claims, its texts to send, its note of how far it read once it left or was replaced, and its notes’ and papers’ sealed files that no record known here names, taken out of the folder here and of what was fetched beside it; the sending takes them out of the server (remote::Departed), and none is fetched again. Each device keeps what it already read; a device joining later never gets its records unless another device’s records carry them (texts restored on a new phone). A device that counts here is refused (“share-device-counts”).
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 device that counts has read past them (readers), and the past rounds of the devices that no longer count by a sealed fact (Memory::departed), here and in the copy fetched from the server beside (remote::overlay): never fetched again, and taken out of the server by the sending (remote).
removed_devices: The devices whose files you removed here (remove_device_files), and what went, as the last exchange or removal left them: for the sending and the pull (remote::Departed), which never fetch such a file again and take those still on the server out. Empty when the memory is not this computer’s.
removed_due 🔒: The contents of notes and papers this device sealed whose file was taken out (removed_now: by this device, or read in another device’s record), each with that record’s writer and round (Sealed::removed); each is due once every device that counts read past that round (readers: a reader without notes in the folder read none, and holds it): its last use then counts as days ago, and blobs::sweep_after takes it out at once, with its care all the same: never a content used again or named lately, never one made fresh within days (on a phone under eDrive, which keeps every sealed file it brought, a content used again past that is made fresh, and sent there again). Nothing else needs it: a device taking such a file out keeps it as a copy among its earlier versions (history::keep_moved), and a device joining, or back after long, reads that it was taken out. Only when early: every device that counts says it keeps such a file so (blobs::KEEPING_MOVED); an earlier Sioul keeps it by reference, its content needed in the folder for history::SEALED_DAYS. Until 17 October 2026 such a content stayed two weeks more (90 days while an older Sioul counts, as it still does: days), as it does when not early. Forgotten once swept, or once current again.
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 🔒
replacements_hold: The exchange lock as sioul_core::draftcopies::Hold asks it, for the copies beside drafts encrypted again: taken for each short batch of their replacements, waiting for an exchange running, so that no exchange reads a copy while it is replaced (nor seals and sends the zeros written over the old one after). A device that has never shared (no share/ folder beside memory) runs no exchange: a guard that holds nothing, no folder made.
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_past: This computer’s rounds below the one returned are past their time, as remove_old_rounds judges them from its memory as last saved and the others’ notes: its sending takes those still on the server out of it (remote), where a sync app left them (eDrive passes no deletion on). Who counts comes from the memory, as the last exchange found it by sealed facts (Memory::counting, Memory::uncounted: the sending has no key); a file of notes alone that it did not know of holds back as before, by its notes; a memory that does not say: the rule as it was (readers_by_notes). None when the memory does not read, or is not this computer’s.
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 🔒
set_time 🔒: A file’s last change set to when, through a handle that cannot write it. On Windows, a handle on its attributes alone (FILE_WRITE_ATTRIBUTES): closing a handle that could write the file has the antivirus read it whole before the close returns, a quarter of a second and more for a note of 24 MB, under the exchanges’ lock when a put back dates it there (CI’s Windows job, 19 October 2026); an attribute’s handle is not scanned. Elsewhere a read handle: the owner sets its times (futimens); where a file system asks for write access to set them, a write handle after all.
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”).
slow_memory_write 🔒
slow_under_lock 🔒: Each file done under the lock in short holds, as slow as a test asks (SLOW_UNDER_LOCK); nothing in a build.
small_go 🔒: Whether a removed device’s entry and its note of how far it read go with its files, as nothing needs them any more; a few hundred bytes each.
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 🔒
sweep_theirs 🔒: The others’ contents of notes and papers that stopped being current in this exchange (theirs_now: replaced, taken out, or passed by a later change read in it), noted (Sealed::theirs); and those whose writer no longer counts by a sealed fact (Counted::departed: it left, you forgot it, another replaces it) swept, since that writer never sweeps them again (a phone dead for good), with the care blobs::sweep takes of this device’s own (blobs::sweep_after): unused unused_days since their last use here, never fresh in the folder (another device uses that content again, blobs::put), never one a current record names (a note’s, a change waiting, one the others named lately, one this device sealed itself, the texts’ media: texts_media), and nothing at all while the texts’ media are not known here, nor while a part whose files are sealed apart is not shared here (FILE_PARTS): the records of a part a device does not share are passed over, and a current paper with the same bytes as a departed device’s replaced note would go (review of 17 October 2026, L1). Each one swept is said for the server (Memory::taken). A device that counts sweeps them, each its own folder; two at once find it gone, and their sending a file gone (404) or changed (412).
swept_theirs: The sealed files this device swept as written by a device that no longer counts (Memory::taken, sweep_theirs), by name, and when (milliseconds): the sending takes each out of the server too, when it is still as old there, and the pull of Sioul keeping the folder itself never brings it again. Empty when the memory is not this computer’s.
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.
take_out_copies 🔒
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).
texts_media 🔒: The sealed files the texts name, by name (blobs::name): each part of every text in each phone’s log as this device holds it (TEXTS_LOG, each line sealed at rest, textseal), the texts taken out included. None when they are not known here: the texts not shared on this device, or a whole line of their log that does not open or read (a last line still being written, with no line break yet, is passed over: its medium went into the folder before it, and is fresh there); then no other device’s sealed file is swept here (sweep_theirs). A sharing where no phone was ever seen (every other device known here by its entry, none a phone, nor this one) holds none: only a phone brings the texts’ media.
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.
unused_days 🔒: How long this device keeps the sealed files no record points to any more (days): two weeks (blobs::UNUSED_DAYS) once every other device that counts (present) says in its sealed entry that it keeps them so too (devices::Entry::keeping), else 90 days (blobs::UNUSED_DAYS_BEFORE), as until 15 October 2026. An older Sioul makes a content it uses again fresh only past 30 days (blobs::put): on a phone under eDrive, which keeps every sealed file it brought, it could put back an earlier version whose content left the server, and name it in a record no device could follow. A device whose entry does not read, or known by its records alone, counts as an older one; a hostile folder can only keep contents longer.
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.
waiting_here 🔒: Whether an exchange of this process waits for the lock beside memory now (WAITERS).
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.
win 🔒: A change read in as the winner of its entry. The content of a file sealed apart that another device’s change named, and that this one passes, noted as theirs (theirs_now, Sealed::theirs).
with_ids 🔒: A keyed list whose elements are named by their ids (format 2); by: as format 1 named them.
withheld: The notes and papers gone many at once from this device and held, as its last exchange found them (Memory::withheld): for the Porch to say once, with “Put them back” and “Take them out now”; nothing has to be pressed. Empty when the memory is not this computer’s.
withheld_of 🔒: The files of a store held after going many at once, and since when each (Sealed::gone), summed up: how many, the first and the last gone, when the last leave, and where they were (bulk_folders).
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