.me Logo

.me

Minimal and Expressive.

Install

Install via your package manager of choice:

# npm
npm install this.me

# pnpm
pnpm add this.me

# yarn / bun
bun add this.me

Import

import Me from "this.me";
let me = Me("ana", "secret"); //SEED derivation (keccak256)

Usage Context

.me is exported as an ES Module (ESM) and works out of the box in Node.js (18+), TypeScript, Bundlers (Vite/Webpack), and Modern Browsers.

Option A: TypeScript / Modern Node (ESM)

Add to your .ts or .js file (with "type": "module" in package.json):

import Me from "this.me";
// Initialize local sovereign kernel from (who, secret)
const me = Me("ana", "secret"); // Derives keccak256 seed locally

Option B: Browser (No Build Step)

If you are running directly in HTML or a frontend script using ES modules:

<script type="module">
  import Me from "https://esm.sh/this.me";
  const me = Me("ana", "secret");
</script>

Option C: Node.js (CommonJS / `require`)

If you are running a legacy Node environment:

const Me = require("this.me").default;
const me = Me("ana", "secret");

⌬ Docs

Free-form declaration: me.whatever.you.want("x").

Containment order: q ≤ p ⟺ q is descendant of p — meaning is by position in your graph (SpaceStructure, formula).

me 
├─ family.photos 
├─ family.messages 
├─ work.neurons_me 
├─ work.github 
├─ music.playlists 
└─ ai.claude

You can say/postulate/testify basically anything:

me.name("Ana") 
me.saw.event42("I was there")
me.price(100)
me.users.bob.trust(0.7) 
me.secret["_"]("key") 
me.secret.note("Only this audience can read it")

That is unlimited in form because .me is semantic algebra. It does not begin by asking permission. It lets an identity produce structured claims, private branches, derivations, links, proofs, memories.

But .me alone is local. It says:

“This identity, from this seed, computes this universe.”

The namespace (ledger) is different. That layer says:

“This identity testified this claim, and now there is a public or shared witness record.”

So the ledger does not make the claim true.

It makes the claim attested.

import Me from "this.me";

const me = Me("ana", "secret");

me.name("Sui Gn");              // write
me("name");                     // read
me.wallet["_"]("wallet-key");   // encrypted branch
me.wallet.balance(12480);       // encrypted leaf inside wallet
me.order.price(100);
me.order.quantity(5);
me.order["="]("total", "price * quantity"); // derived leaf

Identity

import Me from "this.me";
const me = Me("suign", "secret");
console.log(me["!"].identity());

Me(who, secret) creates a kernel from:

seed = keccak256("me.seed/compound:v1::" + who + "::" + secret)
identityHash = keccak256("this.me/identity:v1::" + seed)

Same (who, secret) means same identity hash everywhere. The seed is derived locally and is never transmitted by the kernel.

→ Seed, formalized · SEED → Monad · The Ontology of Identity — self-validation, cryptography as gravity · whois.me

You can also create a kernel from an explicit seed:

const me = Me("already-derived-seed");

The callable kernel can still be reseeded later with the same math:

const me = Me();
me("suign", "secret");

Semantic Tree

import Me from "this.me";

const me = Me("suign", "secret");

// Public identity (just paths — no namespace is required)
me.name("Sui Gn");
me.bio("Building the semantic web.");

// Private data: encrypted branch
me.wallet["_"]("wallet-key-2026");
me.wallet.balance(12480);

// Concrete collection with derived logic
me.people.ana.name("Ana");
me.people.ana.age(24);
me.people.pablo.name("Pablo");
me.people.pablo.age(17);
me.people["[i]"]["="]("isAdult", "age >= 18");

// Reference linking
me.users.ana.name("Ana");
me.friends.ana["->"]("users.ana");

console.log(me("name"));                // "Sui Gn"
console.log(me("wallet"));              // undefined
console.log(me("wallet.balance"));      // 12480
console.log(me("people.ana.isAdult"));  // true
console.log(me("friends.ana.name"));    // "Ana"

Broadcast derivations materialize on the concrete collection they are attached to. Links are for structural reads and single-source-of-truth relationships.

→ The Semantic Graph Engine — schema as a node, not a table · me.whatever(what) — the syntax, formalized · Robots That Understand Context — this exact [i] broadcast, applied to a fleet

Privacy Model

import Me from "this.me";

const me = Me();

me.secrets["_"]("private-key-2026");
me.secrets.notes("Only I can see this.");

me.name("Public Name");

console.log(me("secrets"));        // undefined
console.log(me("secrets.notes"));  // "Only I can see this."
console.log(me("name"));           // "Public Name"

Encrypted branches keep descendants out of the public semantic index. Observers can see that a secret scope exists, but leaf names and values under that scope are stored as encrypted branch chunks.

→ The Algebra of Encrypted Audiences — the _ operator, formalized · The Encrypted Island · T ⊥ A — infographic · Robots × Encrypted Audiences — infographic

Reactivity

import Me from "this.me";

const me = Me();

me.order.price(100);
me.order.quantity(5);
me.order["="]("total", "price * quantity");

me.order.price(200);

console.log(me("order.total")); // 1000

Reactivity is dependency-indexed: when a value changes, only derivations that actually depend on that value are marked and recomputed. The runtime supports eager and lazy recomputation through me.setRecomputeMode("eager" | "lazy").

→ Inverted Dependency Indexing · What is O(k)? — real benchmark numbers · cost(mutation) = O(k) — infographic · neurons-me’s own viz · Smart Cities — this same cascade, at city scale

Search

Vector search runs over a collection-scoped encrypted branch. The current public API names are searchExact, buildVectorIndex, and searchVector.

import Me from "this.me";

const me = Me();

me.memory.episodic["_"]("search-key");
me.memory.episodic[0]({
  id: 0,
  embedding: [1, 0],
  text: "semantic web",
});
me.memory.episodic[1]({
  id: 1,
  embedding: [0, 1],
  text: "robotics",
});

const exact = me.searchExact("memory.episodic", [1, 0], { k: 1 });
console.log(exact.hits[0].path); // "memory.episodic.0"

me.buildVectorIndex("memory.episodic", { k: 2, nprobe: 1 });
const approx = me.searchVector("memory.episodic", [1, 0], { k: 1, nprobe: 1 });
console.log(approx.hits[0].path); // "memory.episodic.0"

For large corpora, the benchmark suite writes chunked columnar encrypted vector data and compares exact scan against IVF sidecar search.

Explainability

import Me from "this.me";

const me = Me();

me.order.price(200);
me.order.quantity(5);
me.order["="]("total", "price * quantity");

const trace = me.explain("order.total");

console.log(trace.value);              // 1000
console.log(trace.expr);               // "price * quantity"
console.log(trace.meta.dependsOn);     // ["order.price", "order.quantity"]

explain(path) returns a structured trace: the expression, resolved inputs, origin metadata, recompute wave data, and masked values for secret inputs.

→ me.explain() — Why Did You Say That? · visual landing · neurons-me’s own copy

Snapshots And Replay

import Me from "this.me";

const me = Me();
me.name("Sui Gn");

const snapshot = me.exportSnapshot();

const restored = Me();
restored.hydrate(snapshot);

console.log(restored("name")); // "Sui Gn"

Network tools can feed memories back into the kernel through me.learn(memory) or replay a whole log with me.replayMemories(memories). The kernel can learn from the network, but identity and local computation do not depend on it.

Role In The NRP Stack

.me is the root of the stack. It operates offline: no network, no server, no external service is needed to derive identity or store local knowledge.

this.me    -> sovereign kernel. (who, secret) -> compound seed -> identity + tree.
cleaker    -> resolver. Projects .me into a namespace surface.
monad.ai   -> daemon. Exposes the namespace over HTTP and mesh surfaces.

When cleaker opens a namespace, it returns memories to the caller. Those memories can be replayed into .me via me.learn(memory).

→ NRP — Namespace Resolution Protocol · status · Decentralized Identity — issuer vs. reader as two different questions · Centralize the Self, Distribute the Data

Cryptographic Set-Chemistry

Multiple parties can derive a shared namespace without a server:

import sha3 from "js-sha3";

const { keccak256 } = sha3;

function audienceSeed(seeds: string[]): string {
  return keccak256("me.seed/audience:v1::" + [...seeds].sort().join("::"));
}

console.log(audienceSeed(["frank-seed", "ana-seed"]));

Properties:

frank + ana = ana + frank because seeds are sorted before hashing.
frank + ana + luna derives a different compound than frank + ana.
Remove any party and the namespace is no longer derivable.
No server. No registry. The namespace exists only where the exact seed set is present.

→ Cryptographic Set-Chemistry on Audiences — the formal version of this exact construction · The Algebra of Encrypted Audiences

Verified Locally

README examples are covered by:

npm run build
npm run test:readme
npm run test:contracts 
npm run test:phase3 

From .me/Typescript/

 node tests/fire.test.ts 
 node tests/pre-build.test.mjs

Performance


`0.001ms p50`	write enqueue
`0.003ms p50`	cascadeLazy 10-dep flush
`0.137ms p99`	cascadeLazy 10-dep flush
`~700 vps`	sustained write with 1536-dim vectors
`1M nodes`	in-memory with sub-ms propagation
`23.2x`	IVF search speedup over exact scan on 100k corpus

Run benchmark details with:

npm run bench

→ What is O(k)? — the same kind of numbers, sourced and verified · cost(mutation) = O(k) — infographic · Full Benchmarks — O(k) scaling, throughput, fan-out, cold/warm, explain overhead, secret-scope cost