DEV Community

Sui Gn
Sui Gn

Posted on

me.whatever.you.want("x")

#ai #opensource #programming #machinelearning

How .me turns arbitrary property chains into a semantic tree with operators, pointers, privacy, and derivations.

me.whatever.you.want("x")

Most APIs ask you to learn their shape first.

.me starts from the opposite direction:

me.whatever.you.want("x");
Enter fullscreen mode Exit fullscreen mode

There is no predefined whatever, no predefined you, and no predefined want.

The path is created by using it.

That is the basic structure of .me: a free-form semantic tree exposed through a callable JavaScript proxy.

Paths

A .me value behaves like both an object and a function.

You can write through property chaining:

me.profile.name("Sui Gn");
me.profile.location.city("Cordoba");
me.project.kernel.language("TypeScript");
Enter fullscreen mode Exit fullscreen mode

And read through a path string:

me("profile.name");
me("profile.location.city");
me("project.kernel.language");
Enter fullscreen mode Exit fullscreen mode

The property chain is not a normal JavaScript object tree. It is a path builder.

me.whatever.you.want("x");
Enter fullscreen mode Exit fullscreen mode

means:

whatever.you.want = "x"
Enter fullscreen mode Exit fullscreen mode

The kernel records that as a memory event, not just as an object mutation.

Free-Form, But Not Unstructured

.me is free-form at the semantic path layer.

You can say:

me.any.path.you.need("value");
Enter fullscreen mode Exit fullscreen mode

But the kernel still gives every write structure:

path
operator
value
timestamp
previous hash
Enter fullscreen mode Exit fullscreen mode

That means arbitrary paths can still be replayed, inspected, snapshotted, encrypted, derived, and explained.

So .me is not “just a loose object.”

It is a semantic memory runtime.

Operators

The tree is free, but some symbols are reserved as operators.

Operators are how .me gives behavior to paths.

For example, plain calls write values:

me.order.price(100);
me.order.quantity(5);
Enter fullscreen mode Exit fullscreen mode

The = operator creates a derivation:

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

me("order.total"); // 500
Enter fullscreen mode Exit fullscreen mode

If a dependency changes:

me.order.price(200);

me("order.total"); // 1000
Enter fullscreen mode Exit fullscreen mode

The derived path updates from the dependency graph.

Other operators give the tree more semantics:

me.profile["_"]("secret-key");     // secret scope
me.profile["~"]("noise-key");      // reset secret lineage boundary
me["@"]("sui-gn");                 // identity claim
me.notes["-"]("old");              // remove/tombstone
me.cart["?"]("total", "tax");      // query/collect
Enter fullscreen mode Exit fullscreen mode

The exact operator is small, but the idea is important:

normal paths describe meaning
operators change how meaning is stored, linked, derived, or protected
Enter fullscreen mode Exit fullscreen mode

Pointers

Pointers let one path refer to another path without copying the data.

For example:

me.users.ana.name("Ana");
me.users.ana.city("Cordoba");

me.friends.ana["->"]("users.ana");
Enter fullscreen mode Exit fullscreen mode

Now the friend entry points at the user entry:

me("friends.ana.name"); // "Ana"
me("friends.ana.city"); // "Cordoba"
Enter fullscreen mode Exit fullscreen mode

The pointer is structural. It preserves a single source of truth.

If the original path changes:

me.users.ana.city("Veracruz");

me("friends.ana.city"); // "Veracruz"
Enter fullscreen mode Exit fullscreen mode

That is different from copying:

me.friends.ana.name("Ana");
me.friends.ana.city("Cordoba");
Enter fullscreen mode Exit fullscreen mode

Copying creates duplicated facts. A pointer creates a relationship.

Secret Scopes

The _ operator creates a secret branch:

me.wallet["_"]("wallet-key");
me.wallet.balance(12480);
Enter fullscreen mode Exit fullscreen mode

The root becomes stealth:

me("wallet"); // undefined
Enter fullscreen mode Exit fullscreen mode

But the leaf can still be read by the authorized local kernel context:

me("wallet.balance"); // 12480
Enter fullscreen mode Exit fullscreen mode

So secrecy is not a global mode.

It is bound to a path.

wallet = stealth root
wallet.balance = encrypted branch leaf
Enter fullscreen mode Exit fullscreen mode

The Runtime Plane

There is one more boundary: kernel controls.

Most paths are free-form:

me.whatever.you.want("x");
Enter fullscreen mode Exit fullscreen mode

But runtime inspection and controls live under a reserved escape plane:

me["!"]
Enter fullscreen mode Exit fullscreen mode

For example:

me["!"].inspect();
me["!"].explain("order.total");
me["!"].runtime.setRecomputeMode("lazy");
Enter fullscreen mode Exit fullscreen mode

This keeps user semantics separate from kernel mechanics.

So:

me.whatever.you.want("x");
Enter fullscreen mode Exit fullscreen mode

is semantic data.

And:

me["!"].runtime.setRecomputeMode("lazy");
Enter fullscreen mode Exit fullscreen mode

is runtime configuration.

The Mental Model

The simplest model is:

property access builds a path
function call acts on that path
operators give special behavior
the kernel records the event
Enter fullscreen mode Exit fullscreen mode

So this:

me.people.ana.likes.coffee(true);
Enter fullscreen mode Exit fullscreen mode

is a semantic claim:

people.ana.likes.coffee = true
Enter fullscreen mode Exit fullscreen mode

This:

me.people.ana["->"]("users.ana");
Enter fullscreen mode Exit fullscreen mode

is a structural relationship.

This:

me.order["="]("total", "price * quantity");
Enter fullscreen mode Exit fullscreen mode

is a derived fact.

And this:

me.wallet["_"]("key");
Enter fullscreen mode Exit fullscreen mode

is a private branch.

Why It Matters

Most systems make you define the schema first, then fit your data into it.

.me lets meaning emerge as paths:

me.whatever.you.want("x");
Enter fullscreen mode Exit fullscreen mode

Then it gives those paths runtime behavior through operators, pointers, derivations, privacy scopes, replay, snapshots, and explainability.

That is the design:

free-form semantics on the outside
deterministic kernel structure underneath
Enter fullscreen mode Exit fullscreen mode
Enter fullscreen mode Exit fullscreen mode

Top comments (0)