What if Identity and Privacy Were Structural A kernel…
0 reactions
What if Identity and Privacy Were Structural
A kernel where identity isn’t a table row and privacy isn’t an ACL flag. Both are part of the graph. Recompute cost is `O(k)` where `k` = dependency count, not dataset size. Secret-path is slower by design, but <1ms. Code + data below.
The core idea is that `.me` is a **reactive semantic graph** where two things normally handled by external systems — identity and privacy — become structural properties of the data model itself, not bolted-on features.
# The primitive: .me is a reactive semantic graph
At its core, `.me` is a **fine-grained reactive dataflow engine** where the unit of reactivity is a path in a semantic graph (like `fleet.trucks1].cost`), not a component, store, or query. When a source value changes, only the paths that *depend* on it are invalidated — nothing more. This is what "O(k)" means: you pay for k dependencies, not n records.
This puts it in the same family as **Adapton** (UMD's incremental computation research), **MobX** (JS observable graphs), and **SolidJS** (fine-grained signals) — but `.me` goes further by claiming that the graph itself should *be* identity and privacy, not just compute state.
`import ME from ' this.me ';`
`const me = new ME();`
`// declare a derivation: cost depends on fuel * price`
` me.finance.fuel_price(24.5 );`
`me.fleet.trucks[1].fuel(200);`
`me.fleet.trucks[2].fuel(350);`
`me.fleet["trucks[i]"]["=" "cost", "fuel * finance.fuel_price";`
`// change one source`
` me.finance.fuel_price(25 );`
`// reads are fresh, but only touched paths recomputed`
`me("fleet.trucks1].cost"); // 5000`
`me("fleet.trucks[2].cost"); // 8750`
Why this matters: You didn’t write a subscription. You didn’t write an ACL check. You declared structure. The kernel enforces it.
Under the hood: `derivations` \+ `refSubscribers` \+ `staleDerivations` set.
Mutation invalidates `finance.fuel_price`, queues `fleet.trucks.1.cost` and `fleet.trucks.2.cost`, stops there.
***If you had 10k trucks, only the 2 affected recompute.***
That’s `k=2`.
**Structural privacy instead of ACL tables**
When you mark a path with `_` (stealth scope), it becomes structurally inaccessible — `me("wallet")` returns `undefined` if you're outside the scope. There's no permissions lookup, no middleware check, no forgot-to-check bug. The graph topology *is* the access rule.
You write `trucks[i].cost = fuel * finance.fuel_price` once. The system tracks the dependency graph. `me.explain("fleet.trucks.2.cost")` gives you a full provenance trace with 24% overhead — cheap enough for production.
What this opens: compliance and auditability. In finance, healthcare, or legal systems where you need to explain *why* a computed value is what it is (an AI decision, a risk score, a price), this is a powerful primitive. You get a causal graph for free.
# What “O(k)” looks like in practice
Claim: public-path latency depends on `k`, not `n`.
Clone the Github Repository:
`git clone` [` https://github.com/neurons-me/.me ` https://github.com/neurons-me/.me
`cd .me`
`cd npm`
`npm install`
`node tests/fire.test.ts`
`node tests/axioms.test.ts`
Ran on M2 MacBook Air, April 9 2026, isolated. Key ones:
|Fanout|p95 latency|
|:-|:-|
|10|0.0192ms|
|100|0.0140ms|
|1000|0.0097ms|
|5000|0.0056ms|
Interpretation: ***k fixed at 2***. Latency drops slightly as fanout grows due to cache effects. If this were O(n), the 5k row would be ∼500x the 10 row. It isn’t. You’re paying per dependency, not per record.
Regression gate:
latency\_p95: ✅ 0.0201ms (threshold 20ms)
complexity\_k: ✅ k=2 (threshold <=4)
stealth\_masking: ✅ value=●●●●
Latency *drops* as fanout grows == `k` constant. You’re measuring per-path cost, not total graph traversal. If this were `O(n)`, the 5k row would be 500x the 10 row. It isn’t.
**Secret pays for:** encryption, stealth boundary checks, lazy refresh + write-back to the hash chain.
**Key point:** absolute secret p95 is now <1ms for these scenarios. March 2026 baseline was `4.65ms`. We cut 81-84% by adding shared v3 key cache + chunking. The ratio looks huge (50x) because public is \~timer floor. Absolute cost is what matters for UX.
`#11` shows mutation stays cheap `0.04ms`. Read is noisy `0.35-0.75ms` because it couples crypto + derivation + append. That’s the next refactor: separate refresh from hash-chain write-back. It’s semantic work, not micro-opt, so we’ll do it when real apps need it.
# 5. Explainability isn’t free, but it’s cheap
TypeScript
me.finance "_" "k-2026"; // stealth rootme.finance.fuel_price(24.5);me.fleet.trucks2].fuel(350);me.fleet.trucks[2 ]["=" "cost", "fuel * finance.fuel_price";
me.explain("fleet.trucks.2.cost")
1 line hidden
JSON
TreeRaw
▶{ } "path":"fleet.trucks.2.cost", "value":8575, ▶"derivation":{ } "expression":"fuel * finance.fuel_price", ▶"inputs":
2 items
]
`#8` shows `explain()` adds 24.9% p95 overhead. Absolute: `0.0173ms`. You can trace prod without killing latency.
# 6. Why I care about O(k)
Databases give you indexes. FRP gives you glitches or full re-renders. Spreadsheets give you recalc storms.
`.me` gives you: write once `trucks[i].cost = fuel * price`, change `price`, and only `cost` fields recompute. No manual dependency tracking. No subscription leaks. No N+1.
`k` is visible: `me.explain(path).meta.dependsOn.length`. You can budget latency before you ship.
Secret scopes `_` give you structural privacy: `me("wallet")` → `undefined` unless you’re inside the scope. `me("wallet.balance")` works. No ACL tables. The graph itself enforces it. A3 secrecy axiom, tested.
# Structural privacy has a cost. It’s bounded.
Benchmark #9 ecret-Scope, isolated run:
|Scope|p95|
|:-|:-|
|public|0.0162-0.0170ms|
|secret|0.7475-0.8788ms|
# 7. Repro yourself
Bash
npm i this.menode tests/Benchmarks/benchmark.6.fanout-sensitivity.test.tsnode tests/axioms.test.ts
All green = invariants hold. Change the evaluator, re-run. If O(k) breaks, CI fails.
Repo: [ https://github.com/neurons-me/.me https://github.com/neurons-me/this.me
Docs: https://neurons-me.github.io/.me
`cleaker` adds the network boundary: `cleaker(me)` mounts identity into a namespace, same O(k) guarantees.
#technology S
A kernel where identity isn’t a table row and privacy isn’t an ACL flag. Both are part of the graph. Recompute cost is `O(k)` where `k` = dependency count, not dataset size. Secret-path is slower by design, but <1ms. Code + data below.
The core idea is that `.me` is a **reactive semantic graph** where two things normally handled by external systems — identity and privacy — become structural properties of the data model itself, not bolted-on features.
# The primitive: .me is a reactive semantic graph
At its core, `.me` is a **fine-grained reactive dataflow engine** where the unit of reactivity is a path in a semantic graph (like `fleet.trucks1].cost`), not a component, store, or query. When a source value changes, only the paths that *depend* on it are invalidated — nothing more. This is what "O(k)" means: you pay for k dependencies, not n records.
This puts it in the same family as **Adapton** (UMD's incremental computation research), **MobX** (JS observable graphs), and **SolidJS** (fine-grained signals) — but `.me` goes further by claiming that the graph itself should *be* identity and privacy, not just compute state.
`import ME from ' this.me ';`
`const me = new ME();`
`// declare a derivation: cost depends on fuel * price`
` me.finance.fuel_price(24.5 );`
`me.fleet.trucks[1].fuel(200);`
`me.fleet.trucks[2].fuel(350);`
`me.fleet["trucks[i]"]["=" "cost", "fuel * finance.fuel_price";`
`// change one source`
` me.finance.fuel_price(25 );`
`// reads are fresh, but only touched paths recomputed`
`me("fleet.trucks1].cost"); // 5000`
`me("fleet.trucks[2].cost"); // 8750`
Why this matters: You didn’t write a subscription. You didn’t write an ACL check. You declared structure. The kernel enforces it.
Under the hood: `derivations` \+ `refSubscribers` \+ `staleDerivations` set.
Mutation invalidates `finance.fuel_price`, queues `fleet.trucks.1.cost` and `fleet.trucks.2.cost`, stops there.
***If you had 10k trucks, only the 2 affected recompute.***
That’s `k=2`.
**Structural privacy instead of ACL tables**
When you mark a path with `_` (stealth scope), it becomes structurally inaccessible — `me("wallet")` returns `undefined` if you're outside the scope. There's no permissions lookup, no middleware check, no forgot-to-check bug. The graph topology *is* the access rule.
You write `trucks[i].cost = fuel * finance.fuel_price` once. The system tracks the dependency graph. `me.explain("fleet.trucks.2.cost")` gives you a full provenance trace with 24% overhead — cheap enough for production.
What this opens: compliance and auditability. In finance, healthcare, or legal systems where you need to explain *why* a computed value is what it is (an AI decision, a risk score, a price), this is a powerful primitive. You get a causal graph for free.
# What “O(k)” looks like in practice
Claim: public-path latency depends on `k`, not `n`.
Clone the Github Repository:
`git clone` [` https://github.com/neurons-me/.me ` https://github.com/neurons-me/.me
`cd .me`
`cd npm`
`npm install`
`node tests/fire.test.ts`
`node tests/axioms.test.ts`
Ran on M2 MacBook Air, April 9 2026, isolated. Key ones:
|Fanout|p95 latency|
|:-|:-|
|10|0.0192ms|
|100|0.0140ms|
|1000|0.0097ms|
|5000|0.0056ms|
Interpretation: ***k fixed at 2***. Latency drops slightly as fanout grows due to cache effects. If this were O(n), the 5k row would be ∼500x the 10 row. It isn’t. You’re paying per dependency, not per record.
Regression gate:
latency\_p95: ✅ 0.0201ms (threshold 20ms)
complexity\_k: ✅ k=2 (threshold <=4)
stealth\_masking: ✅ value=●●●●
Latency *drops* as fanout grows == `k` constant. You’re measuring per-path cost, not total graph traversal. If this were `O(n)`, the 5k row would be 500x the 10 row. It isn’t.
**Secret pays for:** encryption, stealth boundary checks, lazy refresh + write-back to the hash chain.
**Key point:** absolute secret p95 is now <1ms for these scenarios. March 2026 baseline was `4.65ms`. We cut 81-84% by adding shared v3 key cache + chunking. The ratio looks huge (50x) because public is \~timer floor. Absolute cost is what matters for UX.
`#11` shows mutation stays cheap `0.04ms`. Read is noisy `0.35-0.75ms` because it couples crypto + derivation + append. That’s the next refactor: separate refresh from hash-chain write-back. It’s semantic work, not micro-opt, so we’ll do it when real apps need it.
# 5. Explainability isn’t free, but it’s cheap
TypeScript
me.finance "_" "k-2026"; // stealth rootme.finance.fuel_price(24.5);me.fleet.trucks2].fuel(350);me.fleet.trucks[2 ]["=" "cost", "fuel * finance.fuel_price";
me.explain("fleet.trucks.2.cost")
1 line hidden
JSON
TreeRaw
▶{ } "path":"fleet.trucks.2.cost", "value":8575, ▶"derivation":{ } "expression":"fuel * finance.fuel_price", ▶"inputs":
2 items
]
`#8` shows `explain()` adds 24.9% p95 overhead. Absolute: `0.0173ms`. You can trace prod without killing latency.
# 6. Why I care about O(k)
Databases give you indexes. FRP gives you glitches or full re-renders. Spreadsheets give you recalc storms.
`.me` gives you: write once `trucks[i].cost = fuel * price`, change `price`, and only `cost` fields recompute. No manual dependency tracking. No subscription leaks. No N+1.
`k` is visible: `me.explain(path).meta.dependsOn.length`. You can budget latency before you ship.
Secret scopes `_` give you structural privacy: `me("wallet")` → `undefined` unless you’re inside the scope. `me("wallet.balance")` works. No ACL tables. The graph itself enforces it. A3 secrecy axiom, tested.
# Structural privacy has a cost. It’s bounded.
Benchmark #9 ecret-Scope, isolated run:
|Scope|p95|
|:-|:-|
|public|0.0162-0.0170ms|
|secret|0.7475-0.8788ms|
# 7. Repro yourself
Bash
npm i this.menode tests/Benchmarks/benchmark.6.fanout-sensitivity.test.tsnode tests/axioms.test.ts
All green = invariants hold. Change the evaluator, re-run. If O(k) breaks, CI fails.
Repo: [ https://github.com/neurons-me/.me https://github.com/neurons-me/this.me
Docs: https://neurons-me.github.io/.me
`cleaker` adds the network boundary: `cleaker(me)` mounts identity into a namespace, same O(k) guarantees.
#technology S
| 2,000 mlx | |
| 4 | |
| 0 |