𓋹 The Axioms of .me

Built on the Primitives. Each axiom is stated, then demonstrated; every line marked //= is checked against what the kernel returns.

A-struct-0 | Unified Callable Surface

Statement. The kernel is one value that is at once a function and an object: every path reached from it is again callable, and a call on a path writes it.

typeof me                       //= "function"
typeof me.profile.name          //= "function"
me.profile.name("Abella");
me("profile.name")              //= "Abella"

Also checked by A-struct-0 in axioms.test.ts.

A0 | Secret Root Stealth

Statement. The root of a secret scope does not resolve. Its leaves resolve by their full path, and public paths are unaffected.

me.ledger.host("localhost:8161");
me.wallet["_"]("secret");
me.wallet.income(100);
me("ledger.host")               //= "localhost:8161"
me("wallet")                    //= undefined
me("wallet.income")             //= 100

Also checked by A0 in axioms.test.ts.

A1 | Identity Normalization (@)

Statement. An identity claim is normalized before it is recorded at the root, and a claim that is not a valid name is refused.

me["@"]("Abella");
lastMemory().operator           //= "@"
lastMemory().value.__id         //= "abella"
throws(() => me["@"]("a b"))    //= true

Also checked by A1 in axioms.test.ts.

A2 | Path-Bound Secret Scopes (_)

Statement. Secrecy belongs to a path, not to the instance: declaring _ on a path hides that path’s root and leaves the rest of the tree as it was.

me.profile.kind("public-profile");
me.profile["_"]("alpha");
me.profile.name("Abella");
me("profile")                   //= undefined
me("profile.name")              //= "Abella"

Also checked by A2 in axioms.test.ts.

A3 | Noise Reset (~)

Statement. ~ cuts secret inheritance at a path: a secret declared after it derives a different effective secret than the one before it.

me.wallet["_"]("alpha");
me.wallet.hidden.notes("alpha-note");
me.wallet["~"]("noise");
me.wallet["_"]("beta");
me.wallet.hidden.seed("beta-seed");
me("wallet")                    //= undefined
me("wallet.hidden.seed")        //= "beta-seed"
secretOf("wallet.hidden.notes") !== secretOf("wallet.hidden.seed")   //= true

Also checked by A3 · A3b · A3c in axioms.test.ts.

A4 | Structural Pointers (__ / ->)

Statement. A pointer is stored as data ({ __ptr }) and is followed when a path is read through it.

me.wallet["_"]("secret");
me.wallet.income(1000);
me.profile.cards.primary["__"]("wallet");
me("profile.cards.primary")         //= { __ptr: "wallet" }
me("profile.cards.primary.income")  //= 1000

Also checked by A4 in axioms.test.ts.

A5 | Query as Memory Event (?)

Statement. A query is recorded in memory as a ? event, and it does not reveal the root of the secret scope it reads.

me.profile["_"]("alpha");
me.profile.name("Abella");
me.profile.city("Veracruz");
me.profile["?"]("name", "city");
lastMemory().operator           //= "?"
me("profile")                   //= undefined
me("profile.name")              //= "Abella"

Also checked by A5 in axioms.test.ts.

A6 | Tombstone Remove (-)

Statement. After -, a removed path no longer resolves to the value it had.

me.wallet["_"]("secret");
me.wallet.hidden.notes("private note");
me("wallet.hidden.notes")       //= "private note"
me.wallet.hidden["-"]("notes");
me("wallet.hidden.notes") !== "private note"   //= true

Also checked by A6 in axioms.test.ts.

A7 | Public + Secret Coexistence

Statement. Secret declarations and noise resets do not change what the public paths resolve to.

me.ledger.host("localhost:8161");
me.profile["_"]("alpha");
me.profile.name("Abella");
me.profile["~"]("noise");
me.profile["_"]("beta");
me.profile.hidden.seed("beta-seed");
me.ledger.status("ok");
me("ledger.host")               //= "localhost:8161"
me("ledger.status")             //= "ok"
me("profile")                   //= undefined

Also checked by A7 in axioms.test.ts.

A8 | Hash Chain Integrity

Statement. Every memory links to the hash of the one before it, starting from an empty hash, and its own hash can be recomputed from its fields.

me.ledger.host("localhost:8161");
me.wallet["_"]("secret");
me.wallet.balance(1000);
memories()[0].prevHash ?? ""    //= ""
memories().every((m, i) => (m.prevHash ?? "") === (i ? memories()[i - 1].hash : ""))   //= true
memories().every((m) => m.hash === rehash(m))   //= true

Also checked by A8 in axioms.test.ts.

A9 | Deterministic Conflict Resolution (LWW)

Statement. When writes to one path collide, the last write wins by logical order (seq, then hash), not by the physical clock; the index and the read agree on the winner.

Date.now = () => 1000; me.wallet.balance(10);
Date.now = () => 2000; me.wallet.balance(20);
me("wallet.balance")            //= 20
Date.now = () => 3000; me.wallet.balance(111);
me.wallet.balance(222);
me("wallet.balance")            //= 222
me.index["wallet.balance"]      //= 222

Also checked by A9 in axioms.test.ts.

Why This Combination Is Powerful

Together, these axioms enable real-world use cases that traditional data structures cannot easily achieve:

Personal Digital Identity: You can have a single source of truth for your online self (me["@"]("jabella.e")) with public profiles and deeply hidden private sections that remain structurally coherent.
Secure Personal Vault: Store sensitive data (wallets, keys, notes) that can be partially hidden while still being traversable and pointer-referenced from public areas.
Auditable Memory: Every change, query, or deletion is logged with cryptographic integrity, making .me suitable for self-sovereign identity or personal knowledge bases where trust and history matter.
Composability: Pointers + secrecy + queries allow complex data relationships without duplication or security leaks.
Deterministic & Tamper-evident: Ideal for decentralized systems, personal agents, or any application where data integrity and reproducibility are critical.

In short, .me gives you a living, programmable personal memory that feels like a natural extension of yourself — flexible, private when needed, and provably consistent.

How the demonstrations run

Each snippet runs on a fresh new ME() from the unmodified this.me 4.2.1 (jsDelivr, unpkg fallback), whose sha256 is checked in the browser before it is imported. Statements run in order; a line expression //= expected is evaluated at that point and compared with expected. The helpers (memories, lastMemory, secretOf, throws, rehash) are listed in the kernel panel at the top. The runner is axioms-live.js.

The test suite

The same axioms are checked in Node by Typescript/tests/axioms.test.ts: one case per axiom (A3 has two more, A3b and A3c, for nested secrets), each asserting its proofs as expected / returned pairs. From Typescript/, after npm run build (the test imports ../dist/index.js), on Node ≥ 22.6:

node tests/axioms.test.ts

Expected: AXIOMS SUMMARY: 13/13 passed. Run against this.me 4.2.1 from npm: 13/13 passed, exit code 0. Case-by-case: TypeScript validation.

∴ Witness our seal