Struct Sealed 

struct Sealed {

    computer: String,
    entries: BTreeMap<String, Known>,
    files: BTreeMap<String, Stat>,
    pending: BTreeMap<String, (Option<String>, u64, String)>,
    bases: BTreeMap<String, String>,
    named: BTreeMap<String, BTreeSet<String>>,
    mine: BTreeMap<String, (i64, u64)>,
    named_at: BTreeMap<String, i64>,
    theirs: BTreeMap<String, (String, i64)>,
    removed: BTreeMap<String, (String, u32)>,
    damaged: BTreeMap<String, (u64, u64, u64)>,
    missing: BTreeMap<String, i64>,
    failing: BTreeMap<String, (String, i64, u32)>,
    gone: BTreeMap<String, i64>,
    confirmed: BTreeSet<String>,
    confirmed_files: BTreeSet<String>,
    bulk: BTreeSet<String>,
    replaced: BTreeMap<String, i64>,
    needed: Option<BTreeSet<String>>,
    checked: i64,
    tidied: i64,
    tables: Vec<String>,
    changing: BTreeMap<String, i64>,
}

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.

Fields

computer: String

entries: BTreeMap<String, Known>

files: BTreeMap<String, Stat>

pending: BTreeMap<String, (Option<String>, u64, String)>

bases: BTreeMap<String, String>

For each change waiting, the content it replaces where it was made: its base.

named: BTreeMap<String, BTreeSet<String>>

For each change waiting, every content the others’ records named for its file so far, versions and bases (receive).

mine: BTreeMap<String, (i64, u64)>

The sealed files this computer put in the folder (blobs): when a record last pointed to each (milliseconds), and the size it sealed.

named_at: BTreeMap<String, i64>

Sealed files the others’ records named lately, by name: when this device first read such a record (milliseconds); never from its own records, nor from a record read again. None is taken out within the time sealed files stay (unused_days: two weeks, or 90 days) of that.

theirs: BTreeMap<String, (String, i64)>

Sealed files of the others’ notes and papers that stopped being current here (replaced, taken out, or passed by a later change read in the same exchange), by name: the device whose record named it, and its last use here (milliseconds). Its writer sweeps it (blobs::sweep); forgotten here once it left the folder. A writer that no longer counts by a sealed fact never will (a phone dead for good): swept here then, unused_days after that last use (sweep_theirs). Empty in an older Sioul’s memory, which passes it over.

removed: BTreeMap<String, (String, u32)>

Sealed files of notes and papers this device sealed (mine) whose file was taken out, by name: the device whose record took it out, and that record’s round. Each goes as soon as every device that counts read past that round, with blobs::sweep’s care, rather than two weeks on (removed_due): a device that takes such a file out keeps it among its earlier versions as a copy (history::keep_moved), and nothing else needs it. Empty in an older Sioul’s memory, which passes it over.

damaged: BTreeMap<String, (u64, u64, u64)>

Sealed files found damaged, as they were then (blobs::fingerprint): not opened again until another copy comes.

missing: BTreeMap<String, i64>

Changes waiting for their sealed file, since when (milliseconds): said after a day.

failing: BTreeMap<String, (String, i64, u32)>

Changes that could not be written here (a full disk, a name a folder takes here): their sealed file, when to try again, how many times so far.

gone: BTreeMap<String, i64>

Files gone here, since when (milliseconds): taken out elsewhere once gone a while (EMPTIED_WAIT).

confirmed: BTreeSet<String>

Folders whose files gone at once you said to take out everywhere (confirm_gone), by their place in the records (“files/notes/disk/”): a folder that lists empty, or a whole store; a folder below one confirmed is confirmed too, never one beside it.

confirmed_files: BTreeSet<String>

Files held after going many at once that you said to take out now (“Take them out now”, confirm_withheld): those alone, never a folder that lists empty beside them (review of 17 October 2026, M1).

bulk: BTreeSet<String>

Files held as gone many at once (GONE_GRACE): held so until their own grace ends, whatever goes or comes back beside them, so that a bulk’s remainder never leaves days early (review of 17 October 2026, L3).

replaced: BTreeMap<String, i64>

Sealed files whose content a change of a note or paper replaced, made here or read in another device’s records (its base), by name, and when (milliseconds), for history::SEALED_DAYS and a day: a device that received such a change may keep that content by reference among its earlier versions. None of them leaves early (removed_due), and a copy of the folder kept by Sioul itself keeps them (needed) (review of 17 October 2026, M2).

needed: Option<BTreeSet<String>>

Sioul keeping the folder itself: the sealed files its copy keeps though the server may no longer list them, by name, for the pull, which has no key (needed_sealed): the contents of the current notes and papers of the parts shared here, the files held after going many at once among them (a listing that leaves files out never takes what a record names: review of 18 October 2026, L-1), those changes waiting here name, and those a change replaced lately (replaced: an earlier version kept here by reference opens from that copy). Kept here, out of memory.json, which is written at every exchange. None in an older Sioul’s files, until this one’s first exchange says it: the pull lets go of nothing meanwhile.

checked: i64

When this computer’s sealed files were last looked for, and the history and leftovers last tidied (milliseconds): kept in memory.json now (Memory::checked, tidied), so that this file, large with many notes or texts, is written only when what it holds changes. Read once, from an older Sioul’s.

tidied: i64

tables: Vec<String>

The spam filter’s tables this computer sealed in the folder, by name, oldest first: past the newest KEPT_TABLES, the older go from the folder at once rather than 90 days on (prune_tables). This device’s own memory, never shared; empty in an older Sioul’s, whose tables go as before.

changing: BTreeMap<String, i64>

Large notes and papers found changed since they were last read, and since when (milliseconds, this computer’s clock): each is read and sealed once it has not changed for ten minutes, or an hour after that time (LARGE_SETTLES). Kept here rather than in each file’s last look (Stat::seen, when it was last read), which cannot tell a file quiet for an hour, then saved again, from one changing for an hour, and which a new file has none of (review of 15 October 2026, M2).

Trait Implementations

impl Debug for Sealed

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Sealed

fn default() -> Sealed

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Sealed

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Sealed

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.