this.me 2.9.43 → 3.0.0

package/README.md

@@ -1,77 +1,209 @@
 <img src="https://docs.neurons.me/media/all-this/webP/this.me.webp" alt="SVG Image" width="250" height="250">
 
 # THIS.ME  
-> **This.Me** is a data-structured identity designed to generate and manage identities, attributes, properties and more.
+> **This.Me** is a data-structured identity designed to generate and manage identities, attributes, properties and more. It combines privacy, user control, and secure interoperability.
+
+<strong>.me</strong> is your identity that lives on your machine, under your control. It holds attributes, relationships, and keys that define who you are—and crucially, <strong>how you relate to others</strong>.
 
 # Getting Started:
 
-1. ##### **Install `this.me`:**
-   Open your terminal and run the following command to install the `this.me` package:
-   ```js
-   npm install this.me
-   ```
-   
-2. ##### **Import `Me` in Your Project:**
-   In the JavaScript file where you want to use `this.me`, import the `Me` class.
-   ```js
-   import Me from 'this.me';
-   ```
-   
-   **Explanation**
-   ​	•	The **be** method in the **Me** class accepts an object of **key-value pairs** and **adds these to the identity object**.
-   ​	•	You can call **me.be()** multiple times with different attributes to dynamically update the identity object.
-   
-   ```javascript
-   // Create a new Me instance
-   let me = new Me("xyxyxy");
-   
-   // Add attributes to the identity
-   me.be({ a: "XXX", b: "YYY" });
-   me.be({ c: "z" });
-   ```
-
-**A less abstract example:**
+You can use **this.me** both in the browser and in Node environments. The library automatically detects the environment and provides a single global instance of `me` once initialized.
+
+### **1. Installation**
+
+If you are using npm:
+
+```bash
+npm install this.me
+```
+
+Or load it directly in the browser (after building):
+
+```html
+<script src="this.me.umd.js"></script>
+<script>
+  // Global instance automatically attached to `window.me`
+  console.log(me); // Ready to use after initialization
+</script>
+```
+
+---
+
+### **2. Initialization**
+
+You need to initialize the `.me` instance before using it:
+
+```js
+import me from "this.me";
+
+await me.init({
+  monadEndpoint: "http://localhost:7777" // optional, defaults to 7777
+});
+```
+
+Once initialized, the `me` instance will maintain its state (status, loaded identities, etc.) globally.
+
+---
+
+### **3. Checking Daemon Status**
+
+You can verify if the local daemon is running:
+
+```js
+const status = await me.status();
+console.log("Daemon active:", status.active);
+```
+
+The floating components or any GUI indicators (green/red) can rely directly on `me.status()`.
+
+---
+
+### **4. Listing Identities**
+
+```js
+const list = await me.listUs();
+console.log(list);
+/*
+[
+  { alias: "suign", path: "/Users/abellae/.this/me/suign" }
+]
+*/
+```
+
+---
+
+### **5. Loading an Identity**
+
+```js
+await me.load("abellae", "mySecretHash");
+console.log(me.active); // true if identity is successfully loaded
+```
+
+After loading, you can use all available methods (`be`, `have`, `do`, etc.).
+
+---
+
+### **6. Example in the Browser Console**
+
+If you include the UMD bundle:
+
+```html
+<script src="this.me.umd.js"></script>
+<script>
+  (async () => {
+    await me.init();
+    console.log(await me.status());
+    console.log(await me.listUs());
+  })();
+</script>
+```
+
+- `me` is a **singleton instance** that lives in memory once initialized.
+- Works in both browser and Node.
+- Provides methods for status, identity management, and attribute handling.
+
+------
+
+# How this.me **Works (Simplified)**
+
+The Me class creates and manages a **local, encrypted identity file** based on a username and a secret hash.
+
+#### **Creating a new identity**
+
+When you run:
 
 ```js
-// Add attributes to the identity
-me.be({ name: "Alice", phone: "33550000" });
+Me.create('abellae', 'mySecretHash');
 ```
 
-**1. Registry as a Service:**
-• The registry becomes a centralized service hosted by an authority (e.g., neurons.me).
-• This service would handle the verification and management of all Me instances across the network.
+It does the following:
+
+- Builds a .me file path: ~/.this/me/abellae.me.
+- Creates some **identity data** (username, keys, attributes, etc.).
+- Uses the hash to **encrypt** that data with AES-256-CBC:
+  - It generates a random iv (initialization vector).
+  - Derives a key from the hash (sha256(hash)).
+  - Stores the encrypted result as iv + encryptedData.
+
+> 🔒 The hash is **never saved** — it’s just used as a secret key.
+
+------
+
+#### Loading an existing identity
 
-**Example Flow:**
-1. **Setup**: A developer installs this.me and configures it to connect to neurons.me.
-2. **User Registration**: Users register their Me identity through the service, and the library connects to the neurons.me registry for verification.
-3. **Service Interaction**: When a user interacts with a service that uses this.me, the service can trust the identity by querying the selected registry.
+When you run:
 
-**Implementation:**
 ```js
-import Me from 'this.me';
-const config = {
-  registryURL: 'https://registry.neurons.me', // Registry authority URL
-};
-let me = new Me('alice', config);
-me.register({ password: 'securePass123', email: 'alice@example.com' });
-// Verify and interact with services using the connected registry
+Me.load('abellae', 'mySecretHash');
 ```
 
---------
+It:
+
+- Reads the encrypted .me file.
+- Extracts the first 16 bytes as iv.
+- Recomputes the key from the given hash.
+- Tries to decrypt the file.
+- If it works, it unlocks the identity and loads the data into memory.
+
+------
+
+#### **Using the unlocked identity**
+
+Once unlocked, you can:
+
+- Set attributes: me.be('developer', true)
+- Add endorsements: me.addEndorsement(...)
+- View attributes: me.getAttributes()
+- Save updates with: me.save('mySecretHash')
+
+------
+
+### **Summary**
+
+- Your identity is encrypted on your own machine.
+- Only the correct hash can unlock it.
+- No third parties are involved.
+- The .me file is secure, portable, and self-owned.
+
+Let me know if you’d like a diagram or visual flow to go with this explanation!
+
+---
+
+### 🔍 Core Principles
+
+1. **Freedom to Declare**
+   Anyone can generate a `.me` identity locally without external approval.
+2. **Trusted Endorsements**
+   Authorities (e.g., Cleaker) can endorse `.me` identities without controlling them.
+3. **Local Ownership**
+   All sensitive data (including private keys) stays on the user's machine.
+
+---
+### 🛡️ Security Model
+* No private key ever leaves the local `.me` file.
+* Endorsements are public and verifiable using the public key.
+* If compromised, user can rotate keys and notify authorities.
+
+---
+## 🌐 Multi-Device Support
+* `.me` can be restored using a seed phrase or backup.
+* New devices can be authorized using signatures from old devices.
+
+---
+## 🌍 Use Cases
+* Digital signature of documents
+* Smart contract interaction
+* Federated profiles with trust anchors
+* Group identity and shared contexts (`me && you && them in context/friends`)
+
+---
 <img src="https://suign.github.io/assets/imgs/monads.png" alt="Cleak Me Please" width="244">Hello, I am **.me**
+
 ### ❯ add.me 
 ----
 
-###### Using the CLI and this.me globally to manage user sessions.
-```bash
-npm i -g this.me
-```
-----------
-
 # What is All.This?
-
 ###### Modular Data Structures:
-
 **Each module** in **[all.this](https://neurons.me/all-this)** represents a specific **datastructure**. These **classes** encapsulate the functionalities and **data specific to their domain.**
 
 **[this.me](https://docs.neurons.me/this.me/index.html)  - [this.audio](https://docs.neurons.me/this.audio/index.html) - [this.text](https://docs.neurons.me/this.text/index.html) - [this.wallet](https://docs.neurons.me/this.wallet/index.html) - [this.img](https://docs.neurons.me/this.img/index.html) - [this.pixel](https://docs.neurons.me/this.pixel/index.html) - [be.this](https://docs.neurons.me/be.this/index.html) - [this.DOM](https://docs.neurons.me/this.DOM/index.html) - [this.env](https://docs.neurons.me/this.env/index.html) - [this.GUI](https://docs.neurons.me/this.GUI/index.html) - [this.be](https://docs.neurons.me/this.be/index.html) - [this.video](https://docs.neurons.me/this.video/index.html) - [this.dictionaries](https://docs.neurons.me/this.dictionaries/index.html)** 
@@ -81,7 +213,7 @@ If you are interested in collaborating or wish to share your insights, please fe
 
 #### License & Policies
 - **License**: MIT License.
-- **Learn more** at **https://docs.neurons.me**
-  [Terms](https://docs.neurons.me/terms-and-conditions) | [Privacy](https://docs.neurons.me/privacy-policy)
+- **Learn more** at **https://neurons.me**
+  [Terms](https://neurons.me/terms-and-conditions) | [Privacy](https://neurons.me/privacy-policy)
 
   <img src="https://docs.neurons.me/neurons.me.webp" alt="neurons.me logo" width="123" height="123">

package/dist/this-me.cjs.js

@@ -0,0 +1,55 @@
+"use strict";class c{constructor(t,s){this.me=t,this.url=s,this.ws=null,this.reconnectInterval=1e4,this.isConnected=!1,this.connect()}connect(){this.ws=new WebSocket(this.url),this.ws.onopen=()=>{console.log("[this.me][WS] Connected to daemon"),this.isConnected=!0,this.me.state?.status&&(this.me.state.status.active=!0,this.me.state.status.error=!1),this.#t()},this.ws.onmessage=t=>{try{const s=JSON.parse(t.data);this.#s(s)}catch{console.warn("[this.me][WS] Invalid message:",t.data)}},this.ws.onclose=()=>{console.warn("[this.me][WS] Disconnected, retrying in 10s"),this.isConnected=!1,this.me.state?.status&&(this.me.state.status.active=!1,this.me.state.status.error=!0),this.#t(),setTimeout(()=>this.connect(),this.reconnectInterval)},this.ws.onerror=t=>{console.error("[this.me][WS] Error:",t),this.ws.close()}}#s(t){switch(t.type){case"status":this.me.state.status={active:t.data.active,error:!1,data:t.data};break;case"listUs":this.me.state.listUs=t.data;break;case"update":console.log("[this.me][WS] Update event:",t.data);break;default:console.warn("[this.me][WS] Unknown message type:",t.type)}this.#t()}send(t,s){this.isConnected&&this.ws.readyState===WebSocket.OPEN&&this.ws.send(JSON.stringify({type:t,data:s}))}#t(){this.me.subscribers?.size&&this.me.subscribers.forEach(t=>t(this.me.state))}}class u{constructor(t="http://localhost:7777/graphql"){this.endpoint=t,this.state={status:{active:!1,error:!1,loading:!0,data:null},listUs:[],activeMe:null},this.subscribers=new Set,this.status(),this.socket=null}async init(){return this.#s({status:{...this.state.status,loading:!0}}),(await this.status()).active&&(await this.startSocket(),await new Promise(s=>{let a=!1;const e=this.subscribe(i=>{!a&&i.status.active!==void 0&&(a=!0,e(),s())});setTimeout(()=>{a||(a=!0,e(),s())},2e3)})),this.#s({status:{...this.state.status,loading:!1}}),this.state.status}async startSocket(){if(this.state.status.active){if(this.socket){console.warn("[this.me] WebSocket already running");return}this.socket=new c(this.endpoint.replace("/graphql","")),this.socket.on("status",t=>{this._updateFromSocket({status:{active:!0,error:!1,data:t}})}),this.socket.on("listUs",t=>{this._updateFromSocket({listUs:t})}),this.socket.on("update",t=>{console.log("[this.me] update event",t)})}}_updateFromSocket(t){this.#s(t)}setEndpoint(t){typeof t=="string"&&t.trim()!==""&&(this.endpoint=t)}getState(){return this.state}#s(t){this.state={...this.state,...t},this.subscribers.forEach(s=>s(this.state))}subscribe(t){return this.subscribers.add(t),()=>this.subscribers.delete(t)}async#t(t,s={}){const a=await fetch(this.endpoint,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({query:t,variables:s})});if(!a.ok)throw new Error(`GraphQL error: ${a.status}`);const{data:e,errors:i}=await a.json();if(i)throw new Error(i.map(o=>o.message).join(", "));return e}async status(){const t=`
+      query {
+        status {
+          active
+          version
+          uptime
+        }
+      }
+    `;try{const s=await this.#t(t),a=s.status?{active:s.status.active,version:s.status.version,uptime:s.status.uptime}:{active:!1,version:null,uptime:null};return this.#s({status:{active:a.active,error:!1,data:a}}),a}catch{const s={active:!1,version:null,uptime:null};return this.#s({status:{active:!1,error:!0,data:null}}),s}}async listUs(){const t=`
+      query {
+        listUs {
+          alias
+          path
+        }
+      }
+    `;try{const s=await this.#t(t),a=Array.isArray(s.listUs)?s.listUs.map(({alias:e,path:i})=>({alias:e,path:i})):[];return this.#s({listUs:a}),a}catch{return this.#s({listUs:[]}),[]}}async loadMe(t,s){const a=`
+      mutation($alias: String!, $hash: String!) {
+        loadMe(alias: $alias, hash: $hash)
+      }
+    `;try{const i=!!(await this.#t(a,{alias:t,hash:s})).loadMe;return i&&this.#s({activeMe:t}),i}catch{return!1}}async be(t,s,a){const e=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        be(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(e,{alias:t,key:s,value:a})).be}catch{return!1}}async have(t,s,a){const e=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        have(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(e,{alias:t,key:s,value:a})).have}catch{return!1}}async do_(t,s,a){const e=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        do(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(e,{alias:t,key:s,value:a})).do}catch{return!1}}async at(t,s,a){const e=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        at(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(e,{alias:t,key:s,value:a})).at}catch{return!1}}async relate(t,s,a){const e=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        relate(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(e,{alias:t,key:s,value:a})).relate}catch{return!1}}async react(t,s,a){const e=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        react(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(e,{alias:t,key:s,value:a})).react}catch{return!1}}async communication(t,s,a){const e=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        communication(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(e,{alias:t,key:s,value:a})).communication}catch{return!1}}async me(t){const s=`
+      query($alias: String!) {
+        me(alias: $alias) {
+          alias
+          publicKey
+        }
+      }
+    `;try{const a=await this.#t(s,{alias:t});if(a.me&&typeof a.me=="object"){const{alias:e,publicKey:i}=a.me;return e&&i?{alias:e,publicKey:i}:null}return null}catch{return null}}}const n=new u;typeof window<"u"&&(window.me=n,console.log("[this.me] Global instance available as window.me"));module.exports=n;

package/dist/this-me.es.js

@@ -0,0 +1,324 @@
+class o {
+  constructor(t, s) {
+    this.me = t, this.url = s, this.ws = null, this.reconnectInterval = 1e4, this.isConnected = !1, this.connect();
+  }
+  connect() {
+    this.ws = new WebSocket(this.url), this.ws.onopen = () => {
+      console.log("[this.me][WS] Connected to daemon"), this.isConnected = !0, this.me.state?.status && (this.me.state.status.active = !0, this.me.state.status.error = !1), this.#t();
+    }, this.ws.onmessage = (t) => {
+      try {
+        const s = JSON.parse(t.data);
+        this.#s(s);
+      } catch {
+        console.warn("[this.me][WS] Invalid message:", t.data);
+      }
+    }, this.ws.onclose = () => {
+      console.warn("[this.me][WS] Disconnected, retrying in 10s"), this.isConnected = !1, this.me.state?.status && (this.me.state.status.active = !1, this.me.state.status.error = !0), this.#t(), setTimeout(() => this.connect(), this.reconnectInterval);
+    }, this.ws.onerror = (t) => {
+      console.error("[this.me][WS] Error:", t), this.ws.close();
+    };
+  }
+  #s(t) {
+    switch (t.type) {
+      case "status":
+        this.me.state.status = {
+          active: t.data.active,
+          error: !1,
+          data: t.data
+        };
+        break;
+      case "listUs":
+        this.me.state.listUs = t.data;
+        break;
+      case "update":
+        console.log("[this.me][WS] Update event:", t.data);
+        break;
+      default:
+        console.warn("[this.me][WS] Unknown message type:", t.type);
+    }
+    this.#t();
+  }
+  send(t, s) {
+    this.isConnected && this.ws.readyState === WebSocket.OPEN && this.ws.send(JSON.stringify({ type: t, data: s }));
+  }
+  #t() {
+    this.me.subscribers?.size && this.me.subscribers.forEach((t) => t(this.me.state));
+  }
+}
+class c {
+  constructor(t = "http://localhost:7777/graphql") {
+    this.endpoint = t, this.state = {
+      status: { active: !1, error: !1, loading: !0, data: null },
+      listUs: [],
+      activeMe: null
+    }, this.subscribers = /* @__PURE__ */ new Set(), this.status(), this.socket = null;
+  }
+  /** 🔹 Init
+   * Manually initializes the daemon state (status + listUs).
+   * Useful if you need to re-check after user actions.
+   */
+  async init() {
+    return this.#s({
+      status: { ...this.state.status, loading: !0 }
+    }), (await this.status()).active && (await this.startSocket(), await new Promise((s) => {
+      let a = !1;
+      const e = this.subscribe((i) => {
+        !a && i.status.active !== void 0 && (a = !0, e(), s());
+      });
+      setTimeout(() => {
+        a || (a = !0, e(), s());
+      }, 2e3);
+    })), this.#s({
+      status: { ...this.state.status, loading: !1 }
+    }), this.state.status;
+  }
+  async startSocket() {
+    if (this.state.status.active) {
+      if (this.socket) {
+        console.warn("[this.me] WebSocket already running");
+        return;
+      }
+      this.socket = new o(this.endpoint.replace("/graphql", "")), this.socket.on("status", (t) => {
+        this._updateFromSocket({
+          status: { active: !0, error: !1, data: t }
+        });
+      }), this.socket.on("listUs", (t) => {
+        this._updateFromSocket({ listUs: t });
+      }), this.socket.on("update", (t) => {
+        console.log("[this.me] update event", t);
+      });
+    }
+  }
+  _updateFromSocket(t) {
+    this.#s(t);
+  }
+  setEndpoint(t) {
+    typeof t == "string" && t.trim() !== "" && (this.endpoint = t);
+  }
+  getState() {
+    return this.state;
+  }
+  #s(t) {
+    this.state = { ...this.state, ...t }, this.subscribers.forEach((s) => s(this.state));
+  }
+  subscribe(t) {
+    return this.subscribers.add(t), () => this.subscribers.delete(t);
+  }
+  async #t(t, s = {}) {
+    const a = await fetch(this.endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query: t, variables: s })
+    });
+    if (!a.ok) throw new Error(`GraphQL error: ${a.status}`);
+    const { data: e, errors: i } = await a.json();
+    if (i) throw new Error(i.map((r) => r.message).join(", "));
+    return e;
+  }
+  // 🔹 Daemon-level helpers
+  /** 🔹 Daemon status
+   * Retrieves the current status of the daemon.
+   * Use to check if the service is active and get version/uptime info.
+   */
+  async status() {
+    const t = `
+      query {
+        status {
+          active
+          version
+          uptime
+        }
+      }
+    `;
+    try {
+      const s = await this.#t(t), a = s.status ? {
+        active: s.status.active,
+        version: s.status.version,
+        uptime: s.status.uptime
+      } : { active: !1, version: null, uptime: null };
+      return this.#s({ status: { active: a.active, error: !1, data: a } }), a;
+    } catch {
+      const s = { active: !1, version: null, uptime: null };
+      return this.#s({ status: { active: !1, error: !0, data: null } }), s;
+    }
+  }
+  /** 🔹 List all identities
+   * Fetches all available identities (users).
+   * Use to display or manage the list of identities.
+   */
+  async listUs() {
+    const t = `
+      query {
+        listUs {
+          alias
+          path
+        }
+      }
+    `;
+    try {
+      const s = await this.#t(t), a = Array.isArray(s.listUs) ? s.listUs.map(({ alias: e, path: i }) => ({ alias: e, path: i })) : [];
+      return this.#s({ listUs: a }), a;
+    } catch {
+      return this.#s({ listUs: [] }), [];
+    }
+  }
+  /** 🔹 Load an identity
+   * Loads a specific identity by alias and hash.
+   * Use to activate or switch to a particular identity.
+   */
+  async loadMe(t, s) {
+    const a = `
+      mutation($alias: String!, $hash: String!) {
+        loadMe(alias: $alias, hash: $hash)
+      }
+    `;
+    try {
+      const i = !!(await this.#t(a, { alias: t, hash: s })).loadMe;
+      return i && this.#s({ activeMe: t }), i;
+    } catch {
+      return !1;
+    }
+  }
+  // 🔹 Me-level operations
+  /** 🔹 Be operation
+   * Performs a 'be' mutation for given alias, key, and value.
+   * Use to set or update identity attributes.
+   */
+  async be(t, s, a) {
+    const e = `
+      mutation($alias: String!, $key: String!, $value: String!) {
+        be(alias: $alias, key: $key, value: $value)
+      }
+    `;
+    try {
+      return !!(await this.#t(e, { alias: t, key: s, value: a })).be;
+    } catch {
+      return !1;
+    }
+  }
+  /** 🔹 Have operation
+   * Performs a 'have' mutation for given alias, key, and value.
+   * Use to declare possession or ownership related to identity.
+   */
+  async have(t, s, a) {
+    const e = `
+      mutation($alias: String!, $key: String!, $value: String!) {
+        have(alias: $alias, key: $key, value: $value)
+      }
+    `;
+    try {
+      return !!(await this.#t(e, { alias: t, key: s, value: a })).have;
+    } catch {
+      return !1;
+    }
+  }
+  /** 🔹 Do operation
+   * Performs a 'do' mutation for given alias, key, and value.
+   * Use to record actions or activities for the identity.
+   */
+  async do_(t, s, a) {
+    const e = `
+      mutation($alias: String!, $key: String!, $value: String!) {
+        do(alias: $alias, key: $key, value: $value)
+      }
+    `;
+    try {
+      return !!(await this.#t(e, { alias: t, key: s, value: a })).do;
+    } catch {
+      return !1;
+    }
+  }
+  /** 🔹 At operation
+   * Performs an 'at' mutation for given alias, key, and value.
+   * Use to set location or context related data for the identity.
+   */
+  async at(t, s, a) {
+    const e = `
+      mutation($alias: String!, $key: String!, $value: String!) {
+        at(alias: $alias, key: $key, value: $value)
+      }
+    `;
+    try {
+      return !!(await this.#t(e, { alias: t, key: s, value: a })).at;
+    } catch {
+      return !1;
+    }
+  }
+  /** 🔹 Relate operation
+   * Performs a 'relate' mutation for given alias, key, and value.
+   * Use to define relationships or connections for the identity.
+   */
+  async relate(t, s, a) {
+    const e = `
+      mutation($alias: String!, $key: String!, $value: String!) {
+        relate(alias: $alias, key: $key, value: $value)
+      }
+    `;
+    try {
+      return !!(await this.#t(e, { alias: t, key: s, value: a })).relate;
+    } catch {
+      return !1;
+    }
+  }
+  /** 🔹 React operation
+   * Performs a 'react' mutation for given alias, key, and value.
+   * Use to record reactions or responses by the identity.
+   */
+  async react(t, s, a) {
+    const e = `
+      mutation($alias: String!, $key: String!, $value: String!) {
+        react(alias: $alias, key: $key, value: $value)
+      }
+    `;
+    try {
+      return !!(await this.#t(e, { alias: t, key: s, value: a })).react;
+    } catch {
+      return !1;
+    }
+  }
+  /** 🔹 Communication operation
+   * Performs a 'communication' mutation for given alias, key, and value.
+   * Use to log communications or messages for the identity.
+   */
+  async communication(t, s, a) {
+    const e = `
+      mutation($alias: String!, $key: String!, $value: String!) {
+        communication(alias: $alias, key: $key, value: $value)
+      }
+    `;
+    try {
+      return !!(await this.#t(e, { alias: t, key: s, value: a })).communication;
+    } catch {
+      return !1;
+    }
+  }
+  /** 🔹 Get identity info
+   * Queries detailed information about a specific identity by alias.
+   * Use to retrieve public data like alias and publicKey.
+   */
+  async me(t) {
+    const s = `
+      query($alias: String!) {
+        me(alias: $alias) {
+          alias
+          publicKey
+        }
+      }
+    `;
+    try {
+      const a = await this.#t(s, { alias: t });
+      if (a.me && typeof a.me == "object") {
+        const { alias: e, publicKey: i } = a.me;
+        return e && i ? { alias: e, publicKey: i } : null;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+}
+const u = new c();
+typeof window < "u" && (window.me = u, console.log("[this.me] Global instance available as window.me"));
+export {
+  u as default
+};

package/dist/this-me.umd.js

@@ -0,0 +1,55 @@
+(function(n,r){typeof exports=="object"&&typeof module<"u"?module.exports=r():typeof define=="function"&&define.amd?define(r):(n=typeof globalThis<"u"?globalThis:n||self,n.Me=r())})(this,function(){"use strict";class n{constructor(t,s){this.me=t,this.url=s,this.ws=null,this.reconnectInterval=1e4,this.isConnected=!1,this.connect()}connect(){this.ws=new WebSocket(this.url),this.ws.onopen=()=>{console.log("[this.me][WS] Connected to daemon"),this.isConnected=!0,this.me.state?.status&&(this.me.state.status.active=!0,this.me.state.status.error=!1),this.#t()},this.ws.onmessage=t=>{try{const s=JSON.parse(t.data);this.#s(s)}catch{console.warn("[this.me][WS] Invalid message:",t.data)}},this.ws.onclose=()=>{console.warn("[this.me][WS] Disconnected, retrying in 10s"),this.isConnected=!1,this.me.state?.status&&(this.me.state.status.active=!1,this.me.state.status.error=!0),this.#t(),setTimeout(()=>this.connect(),this.reconnectInterval)},this.ws.onerror=t=>{console.error("[this.me][WS] Error:",t),this.ws.close()}}#s(t){switch(t.type){case"status":this.me.state.status={active:t.data.active,error:!1,data:t.data};break;case"listUs":this.me.state.listUs=t.data;break;case"update":console.log("[this.me][WS] Update event:",t.data);break;default:console.warn("[this.me][WS] Unknown message type:",t.type)}this.#t()}send(t,s){this.isConnected&&this.ws.readyState===WebSocket.OPEN&&this.ws.send(JSON.stringify({type:t,data:s}))}#t(){this.me.subscribers?.size&&this.me.subscribers.forEach(t=>t(this.me.state))}}class r{constructor(t="http://localhost:7777/graphql"){this.endpoint=t,this.state={status:{active:!1,error:!1,loading:!0,data:null},listUs:[],activeMe:null},this.subscribers=new Set,this.status(),this.socket=null}async init(){return this.#s({status:{...this.state.status,loading:!0}}),(await this.status()).active&&(await this.startSocket(),await new Promise(s=>{let e=!1;const a=this.subscribe(i=>{!e&&i.status.active!==void 0&&(e=!0,a(),s())});setTimeout(()=>{e||(e=!0,a(),s())},2e3)})),this.#s({status:{...this.state.status,loading:!1}}),this.state.status}async startSocket(){if(this.state.status.active){if(this.socket){console.warn("[this.me] WebSocket already running");return}this.socket=new n(this.endpoint.replace("/graphql","")),this.socket.on("status",t=>{this._updateFromSocket({status:{active:!0,error:!1,data:t}})}),this.socket.on("listUs",t=>{this._updateFromSocket({listUs:t})}),this.socket.on("update",t=>{console.log("[this.me] update event",t)})}}_updateFromSocket(t){this.#s(t)}setEndpoint(t){typeof t=="string"&&t.trim()!==""&&(this.endpoint=t)}getState(){return this.state}#s(t){this.state={...this.state,...t},this.subscribers.forEach(s=>s(this.state))}subscribe(t){return this.subscribers.add(t),()=>this.subscribers.delete(t)}async#t(t,s={}){const e=await fetch(this.endpoint,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({query:t,variables:s})});if(!e.ok)throw new Error(`GraphQL error: ${e.status}`);const{data:a,errors:i}=await e.json();if(i)throw new Error(i.map(u=>u.message).join(", "));return a}async status(){const t=`
+      query {
+        status {
+          active
+          version
+          uptime
+        }
+      }
+    `;try{const s=await this.#t(t),e=s.status?{active:s.status.active,version:s.status.version,uptime:s.status.uptime}:{active:!1,version:null,uptime:null};return this.#s({status:{active:e.active,error:!1,data:e}}),e}catch{const s={active:!1,version:null,uptime:null};return this.#s({status:{active:!1,error:!0,data:null}}),s}}async listUs(){const t=`
+      query {
+        listUs {
+          alias
+          path
+        }
+      }
+    `;try{const s=await this.#t(t),e=Array.isArray(s.listUs)?s.listUs.map(({alias:a,path:i})=>({alias:a,path:i})):[];return this.#s({listUs:e}),e}catch{return this.#s({listUs:[]}),[]}}async loadMe(t,s){const e=`
+      mutation($alias: String!, $hash: String!) {
+        loadMe(alias: $alias, hash: $hash)
+      }
+    `;try{const i=!!(await this.#t(e,{alias:t,hash:s})).loadMe;return i&&this.#s({activeMe:t}),i}catch{return!1}}async be(t,s,e){const a=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        be(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(a,{alias:t,key:s,value:e})).be}catch{return!1}}async have(t,s,e){const a=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        have(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(a,{alias:t,key:s,value:e})).have}catch{return!1}}async do_(t,s,e){const a=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        do(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(a,{alias:t,key:s,value:e})).do}catch{return!1}}async at(t,s,e){const a=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        at(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(a,{alias:t,key:s,value:e})).at}catch{return!1}}async relate(t,s,e){const a=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        relate(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(a,{alias:t,key:s,value:e})).relate}catch{return!1}}async react(t,s,e){const a=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        react(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(a,{alias:t,key:s,value:e})).react}catch{return!1}}async communication(t,s,e){const a=`
+      mutation($alias: String!, $key: String!, $value: String!) {
+        communication(alias: $alias, key: $key, value: $value)
+      }
+    `;try{return!!(await this.#t(a,{alias:t,key:s,value:e})).communication}catch{return!1}}async me(t){const s=`
+      query($alias: String!) {
+        me(alias: $alias) {
+          alias
+          publicKey
+        }
+      }
+    `;try{const e=await this.#t(s,{alias:t});if(e.me&&typeof e.me=="object"){const{alias:a,publicKey:i}=e.me;return a&&i?{alias:a,publicKey:i}:null}return null}catch{return null}}}const o=new r;return typeof window<"u"&&(window.me=o,console.log("[this.me] Global instance available as window.me")),o});

package/package.json

@@ -1,33 +1,42 @@
 {
   "name": "this.me",
-  "version": "2.9.43",
-  "description": "_me-Centric.",
-  "main": "index.js",
-  "scripts": {
-    "start": "node index.js",
-    "test": "test"
-  },
-  "bin": {
-    ".me": "src/.me.cli.js"
+  "version": "3.0.0",
+  "description": ".me is your identity. It enables decentralized trust through cryptographic signatures.",
+  "main": "dist/this-me.cjs.js",
+"module": "dist/this-me.es.js",
+"browser": "dist/this-me.umd.js",
+  "exports": {
+    ".": {
+    "import": "./dist/this-me.es.js",
+      "require": "./dist/this-me.cjs.js"
+    }
   },
+  "type": "module",
   "keywords": [
     "this.me",
-    "user"
+    "identity",
+    "decentralized",
+    "cryptographic",
+    "trust",
+    "signature",
+    "local",
+    "self-sovereign",
+    "monad"
   ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/neurons-me/this.me.git"
   },
   "homepage": "https://www.npmjs.com/package/this.me",
-  "docs": "https://suiGn.github.io/this.me",
-  "type": "module",
   "author": "suiGn",
   "license": "MIT",
-  "repoType": "NPM Package",
-  "category": "dataformatter",
-  "dependencies": {
-    "chalk": "^5.3.0",
-    "commander": "^12.1.0",
-    "inquirer": "^9.2.16"
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+  "build": "vite build"
+  },
+  "devDependencies": {
+    "vite": "^7.0.6"
   }
 }

package/index.js

@@ -1,10 +0,0 @@
-//index.js
-/**
- * @module This.Me
- * @description
- *  This.Me is a data-structured identity...    
- * */
-
-import Me from './src/me.js';
-//when a user declares "I am %.me," their digital existence is affirmed and recorded in the system.
-export default Me;

package/jsdoc.json

@@ -1,41 +0,0 @@
-{
-  "source": {
-    "include": ["./src", "./index.js", "./README.md"]
-  },
-  "opts": {
-    "destination": "/mnt/neuroverse/https-neurons/subDomains/docs/public/this.me",
-    "template": "../../../suign.github.io/Sandbox/better-docs/",
-    "readme": "./README.md"
-  },
-  "templates": {
-    "cleverLinks": false,
-    "monospaceLinks": false,
-    "search": true,
-    "default": {
-      "staticFiles": {
-        "include": ["./README.md"]
-      }
-    },
-    "better-docs": {
-      "name": "this.me",
-      "title": "this.me Docs",
-      "css": "style.css",
-      "trackingCode": "...",
-      "hideGenerator": false,
-      "navLinks": [
-        {
-          "label": "All.This",
-          "href": "https://docs.neurons.me/all.this/"
-        },
-        {
-          "label": "Neurons.me",
-          "href": "https://neurons.me"
-        },
-        {
-          "label": "Github",
-          "href": "https://github.com/neurons-me/this.me"
-        }
-      ]
-        }
-  }
-}

package/notes/Index.md

@@ -1,134 +0,0 @@
-### **Index of `this.me` Structure**
-Here’s a comprehensive list of the components and their purposes within the `this.me` class:
-
-#### **1. Identity**
-- **Description:** Immutable attributes defining the core identity of the user.
-#### **2. Attributes**
-- **Description:** Flexible traits and descriptive properties of the user.
-#### **3. Relationships**
-- **Description:** Connections and associations with others.
-#### **4. Reactions**
-- **Description:** User’s interactions and engagements with the world.
-#### **5. Properties**
-- **Description:** Items owned or managed by the user.
-
-------
-
-### **1. The Me Structure Overview**
-#### **Core Components**
-- **Identity:** The foundation of the `this.me` object.
-  - Immutable attributes: `username`, `DID`.
-  - Core methods for validation and setup.
-
-------
-
-- **Attributes:** Fundamental identity traits.
-  Store and manage user traits dynamically:
-  - Examples: Name, age, location, pronouns, bio.
-    **Use `.be()` to add or update attributes.**
-
-    Example: 
-    ```json
-    { name: 'John Doe', age: 30, location: 'Earth' }
-    ```
-    Implement `be()` as a flexible key-value store.
-    Add validation for specific attributes (if required).
-
-------
-
-- **Relationships:** Connections with others.
-  - Examples: Friends, groups, networks, organizations.
-    **Contacts:** Individual connections.
-    **Groups:** Collections of users with shared context.
-
-    ```js
-    .relationships.addContact({ username: 'alice', status: 'friend' });
-    .relationships.createGroup({ name: 'Family', members: ['alice', 'bob'] });
-    ```
-
-  Define `addContact` and `createGroup` methods.
-  Enable nested relationship structures (e.g., groups of groups).
-
-------
-
-- **Reactions:** How a user interacts with the world.
-  Streamline all user engagements under `.react()`
-  - Examples: Likes, comments, shares, emotions.
-  - Categorization Rationale:
-    - Keeps all engagements unified.
-    - Expands easily (adding emojis, advanced reactions).
-
-  ```js
-  .react.add({ type: 'like', target: 'PostID' });
-  .react.add({ type: 'comment', target: 'PhotoID', content: 'Great pic!' });
-  ```
-  Design a structure to store and retrieve reactions efficiently.
-  Define a `log` system for reaction history.
-
-------
-
-- **Properties:** Things the user owns or manages.
-  Attach external, modular objects as user-owned assets:
-  - Use `this.me.properties` as a unified interface for ownership.
-  - Modular objects like `Wallet`, `Device`, `File`.
-  - Examples: Wallets, devices, digital files, accounts.
-  - **Sub-Methods:** Add, Share, Transfer Ownership, Revoke Access.
-
-```js
-const jabellae = new Me('jabellae'); // Create a new Me instance
-const wallet = new Wallet({ type: 'ETH', address: '0x123...' }); // Create a wallet object
-jabellae.addProperty(wallet); // Add wallet as a property to Me
-```
-
-​	Implement `add`, `share`, `transferOwnership`, and `revokeAccess` methods for properties. Define modular objects (`Wallet`, `Device`) independently.
-
-1. **Creating a Wallet**
-    The wallet is created independently and then added to the `Me` instance's properties.
-   ```javascript
-   const jabellae = new Me('jabellae'); // Create a new Me instance
-   const wallet = new Wallet({ type: 'ETH', address: '0x123...' }); // Create a wallet object
-   jabellae.addProperty(wallet); // Add wallet as a property to Me
-   ```
-
-2. **Sharing the Wallet**
-    Sharing logic is handled by the `Me` instance, not the property itself.
-   ```javascript
-   jabellae.shareProperty(wallet, 'otherMe', { permissions: 'view' });
-   ```
-
-3. **Transferring Ownership**
-    Ownership transfer is also managed by the `Me` instance.
-   ```javascript
-   jabellae.transferOwnership(wallet, 'otherMe');
-   ```
-
-------
-------
-------
-
-### **2. Why Independent Objects?**
-#### **Modularity**
-- Keeps the `this.me` instance *agnostic* of specifics.
-- Allows new property types to integrate seamlessly.
-
-#### **Reusability**
-- Each property (e.g., `this.wallet`, `this.device`) operates independently.
-- Can be ported across `this.me` instances without coupling.
-
-#### **Transferability**
-- Ownership is a property-level concern.
-- Example:
-
-  ```javascript
-  const wallet = new Wallet(owner = "me");
-  wallet.transferOwnership("otherMeInstance");
-  ```
-
-#### **Separation of Concerns**
-- Identity (`this.me`) manages relationships, attributes, and higher-level user interactions.
-- Objects like `Wallet` or `Device` manage their specific functionality.
-
-#### **Scalability**
-- Adding a new property type is as simple as:
-  1. Defining the object (e.g., `Vehicle`).
-  2. Registering it with `this.me`.

package/notes/Inmutabilidad_de_la_Identidad_basica.md

@@ -1,44 +0,0 @@
- El mayor acto de rebelión en un mundo que busca controlarte es ser libre de verdad.
- 
- **this.me** y el proceso de autenticación con **Cleaker** como una red de identificación descentralizada (**DID**) tiene sentido dentro de un marco de criptografía y autenticación distribuida. A continuación, desgloso los puntos importantes para asegurarnos de que el concepto sea claro y funcional:
-
-### **Inmutabilidad de la Identidad Básica**
-**this.me** se basa en la creación de una identidad. Los componentes inmutables que mencionas (nombre de usuario, email y la red de autenticación) son fundamentales para que el sistema garantice que la identidad siempre se pueda verificar a partir de un hash único.
-
-1. **Nombre de Usuario (username)**: El nombre de usuario es clave en la identidad. No puede cambiar una vez creado porque el hash que lo representa depende de esta cadena de caracteres.
-2. **Correo Electrónico (email)**: Esto actúa como otra pieza inmutable, probablemente porque es un dato importante para autenticar usuarios a través de redes o servicios.
-3. **Red de Autenticación (Cleaker)**: Como mencionas, **Cleaker** actuaría como el **DID**, o sea, la autoridad central que autentica tu identidad. Es clave para asegurar que no cualquiera pueda crear una identidad falsa.
-
-### **Proceso de Creación del Hash**
-Lo que estás describiendo es un esquema de hashing similar al que se usa en la criptografía para asegurar que los datos no sean manipulados. Cuando generas una identidad con `this.me`, combinas información inmutable (username, email, red) para generar un **hash único**, que se convierte en tu **clave pública**.
-
-1. **Hash como Clave Pública**: Cuando hasheas tu información (e.g., nombre + email + red), se genera una clave pública (hash). Esta clave es única para cada combinación de información.
-   - Si cambias incluso una letra de tu nombre o red, el hash resultante será completamente diferente.
-   - Este hash será tu "firma digital" o clave pública para verificarte ante otros sistemas.
-
-2. **Encriptación y Desencriptación de Datos**: Utilizando tu **clave pública** (hash generado), puedes firmar o desencriptar información que hayas dejado en el sistema. Esencialmente, es una forma de probar que eres el propietario legítimo de esa clave.
-   - Si alguien intenta usar un hash distinto (porque cambió alguna información), no podrá desencriptar la información asociada a tu clave pública original.
-
-### **Uso de Cleaker como DID**
-**Cleaker** sería la red de confianza que actúa como verificador. En este caso:
-- **Cleaker** puede autenticar tu identidad, asegurando que el hash generado sea correcto, en el sentido de que el nombre de usuario, email, y red de autenticación son válidos.
-- **Cleaker** también sirve como autoridad para evitar que cualquiera pueda generar una identidad falsa o duplicada. Si intentas acceder a la red con información diferente, el sistema rechaza la autenticación porque el hash no coincide con los registros en la red.
-
-### **Flujo Ejemplificado de Autenticación**
-1. Creas tu identidad en **this.me** con tu nombre de usuario, email y red de autenticación (**Cleaker**).
-2. **this.me** genera un **hash único** para esa combinación de datos, lo que te da una **clave pública**.
-3. Puedes usar esa clave pública para autenticarte en cualquier servicio compatible, y solo tú puedes desencriptar los datos usando tu hash, ya que corresponde exactamente con la información que usaste para crearlo.
-4. Si cambias cualquier parte de tu información (nombre, email o red), obtendrás un hash completamente diferente, lo que efectivamente cambia tu identidad digital.
-
-### **Encriptación y Desencriptación**
-Al tener tu clave pública, puedes usarla para desencriptar datos que hayas almacenado en sistemas que utilizan **this.me**. La clave pública se usa para verificar tu identidad y acceder a la información que has dejado. Como mencionabas:
-
-- Si hasheas "jose" y "abella", obtendrás un hash específico.
-- Si cambias "abella" por "abellae", el hash cambia y no podrás desencriptar la información almacenada bajo el hash anterior.
-
-Este proceso asegura que tu identidad es única y está protegida criptográficamente.
-
-### **Conclusión**
-Este sistema de identidad descentralizada que estás describiendo se asemeja a los **DIDs** utilizados en blockchain y criptografía, donde las identidades no dependen de un servidor centralizado, sino de la prueba criptográfica de su validez. **Cleaker** actuaría como una red que verifica la validez del hash, y **this.me** genera y gestiona las identidades de una forma flexible pero segura. El uso de hashes y criptografía garantiza que las identidades sean inmutables y verificables sin depender de terceros centralizados.
-
-Este sistema tiene aplicaciones en una amplia gama de servicios donde la autenticación segura es fundamental y donde se quiere evitar la creación de múltiples credenciales en diferentes plataformas.

package/notes/Questions.md

@@ -1,62 +0,0 @@
-Key Questions to Address
-Identity Core: What defines the essence of .me?
-Relationships: How does .me relate to others, groups, or larger entities?
-Belongings: What does .me own or have as personal items?
-Modularity: How do we allow external objects to seamlessly integrate with .me?
-Hierarchy of Interactions: How do we classify interactions into tiers (self, relationships, society, etc.)?
----
-
-### **1. Identity Core: What defines the essence of `.me`?**
-   - **Essence Defined:**
-     - **Immutable Core Attributes:** `username` and `DID` (Decentralized Identifier).
-     - Clearly distinguishes the user's unique existence in the digital realm.
-   - **Practical Implementation:**
-     - Identity core is foundational and unchangeable, ensuring trust and consistency across systems.
-
----
-
-### **2. Relationships: How does `.me` relate to others, groups, or larger entities?**
-   - **Connections Defined:**
-     - **Contacts:** Direct relationships (e.g., friends, acquaintances).
-     - **Groups:** Collections with shared contexts (e.g., family, organizations, societies).
-   - **Methods:**
-     - `.relationships.addContact()` to add individual connections.
-     - `.relationships.createGroup()` to organize groups dynamically.
-   - **Hierarchy:**
-     - Nested structures enable relationships at various tiers (e.g., groups of groups, organizations within societies).
-
----
-
-### **3. Belongings: What does `.me` own or have as personal items?**
-   - **Properties Defined:**
-     - Everything the user owns or manages (e.g., wallets, devices, digital files).
-   - **Methods for Ownership:**
-     - `.properties.add()`, `.properties.share()`, `.properties.transferOwnership()`, `.properties.revokeAccess()`.
-   - **Modular Approach:**
-     - Allows external objects like `Wallet`, `Device`, or `Vehicle` to integrate without hardcoding.
-
----
-
-### **4. Modularity: How do we allow external objects to seamlessly integrate with `.me`?**
-   - **Independent Objects:**
-     - Objects like `Wallet`, `Device`, etc., are designed and managed outside the `this.me` instance.
-   - **Integration:**
-     - These objects are registered to `this.me` via methods like `.addProperty()`.
-     - They maintain their internal logic while adhering to the ownership and interaction protocols defined by `.me`.
-   - **Advantages:**
-     - Scalability: Easy to introduce new objects without modifying the `this.me` core.
-     - Transferability: Ownership can move across `.me` instances seamlessly.
-
----
-
-### **5. Hierarchy of Interactions: How do we classify interactions into tiers (self, relationships, society, etc.)?**
-   - **Tiers of Interactions:**
-     - **Reactions:** Personal engagements (`like`, `comment`, `share`).
-     - **Relationships:** Broader social connections (individuals, groups, organizations).
-     - **Attributes:** How `.me` defines itself (e.g., status, bio, pronouns).
-     - **Properties:** Interaction with owned or managed items.
-   - **Unified Structure:**
-     - Centralized under `.reactions` and `.relationships`.
-     - Interaction types remain modular and expandable, allowing for a hierarchy to emerge naturally through usage (e.g., personal to societal interactions).
-
----

package/notes/hot_encoding.md

@@ -1,44 +0,0 @@
-### Neural Networks - **One-Hot Encoding**
---------
-To represent the combinations of **“me, you, him, her, it, us, them”** in a neural network, we need to convert the elements into a suitable format for neural network processing, such as one-hot encoding, and design a neural network architecture that can process these inputs.
-
-Here’s a step-by-step approach to achieve this:
-1.	**One-Hot Encoding:** Convert each element (“me”, “you”, “him”, “her”, “it”, “us”, “them”) into a one-hot encoded vector.
-2.	**Combination Representation:** Create input vectors for each combination by combining the one-hot encoded vectors.
-3.	**Neural Network Design:** Design a simple neural network to process these input vectors.
-
-#### Step 1: One-Hot Encoding
-One-hot encoding represents each element as a binary vector with a single high (1) value and the rest low (0). For the elements “me”, “you”, “him”, “her”, “it”, “us”, “them”, we can assign the following one-hot encoded vectors:
-
-```js
-// Create Me instances
-const meInstance = new Me('me');
-const youInstance = new Me('you');
-const himInstance = new Me('him');
-const herInstance = new Me('her');
-const itInstance = new Me('it');
-const usInstance = new Me('us');
-const themInstance = new Me('them');
-
-// One-hot encoding representation
-const subjects = {
-  'me': [1, 0, 0, 0, 0, 0, 0],
-  'you': [0, 1, 0, 0, 0, 0, 0],
-  'him': [0, 0, 1, 0, 0, 0, 0],
-  'her': [0, 0, 0, 1, 0, 0, 0],
-  'it': [0, 0, 0, 0, 1, 0, 0],
-  'us': [0, 0, 0, 0, 0, 1, 0],
-  'them': [0, 0, 0, 0, 0, 0, 1]
-};
-```
-
-#### Step 2: Combination Representation
-For each combination, we can create an input vector by combining the one-hot encoded vectors of its elements. For example:
-Combination “me, you” would be represented as the sum of the one-hot vectors for “me” and “you”:
-
-```
-[1, 0, 0, 0, 0, 0, 0] + [0, 1, 0, 0, 0, 0, 0] = [1, 1, 0, 0, 0, 0, 0]
-```
----
-### Me Deviation Formula
-**How Spread Out the data Points are around the .me?**

package/src/.me.cli.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-//.me.cli.js
-import { program } from 'commander';
-import { meMainChoices } from './CLI/me_MainChoices.js';
-import AddMe from './CLI/AddMe.js'; 
-import LogMe from './CLI/LogMe.js'; 
-program
-  .description('.Me Command Line Interface')
-  .version('1.0.0')
-  .action(meMainChoices);
-
-program.command('add-me')
-  .description('+ Add .me')
-  .action(AddMe);
-
-program.command('log-me')
-  .description('Log .me')
-  .action(LogMe);
-
-program.parse(process.argv);

package/src/example.js

@@ -1,25 +0,0 @@
-//this.me/src/example.js
-import Me from './me.js';
-import chalk from 'chalk';
-// Create a new Me instance
-let me = new Me('suign');
-// Add attributes to the identity
-me.be({ fullName: "Jose", lastName: "Abella" });
-me.be({ xy: "z" });
-console.log(me);
-// Examplconsole.log(me.identity());e with another instance
-let anotherMe = new Me('anotherUser');
-anotherMe.be({ nickname: "hero", favoriteColor: "blue" });
-console.log(anotherMe);
-// Create a new Me instance with dynamic property name
-let user = 'suign';
-let users = {};
-users[user] = new Me(user);
-// Add attributes to the identity
-users[user].be({ fullName: "ZZZ", lastName: "WWW" });
-users[user].be({ xy: "axax" });
-console.log(users[user]);
-
-console.log(users);
-
-

package/src/me.js

@@ -1,54 +0,0 @@
-//this.me/src/me.js
-import Registry from './registry';
-class Me {
-  static registry = Registry.load();
-  constructor(username = 'default') {
-    if (Me.registry[username]) {
-      throw new Error(`Username ${username} already exists.`);
-    }
-
-    this.username = username;
-    this.identity = {
-      username,
-      devices: [],
-    };
-
-    this.addDevice(); // Automatically adds the current device
-    Me.registry[username] = this.identity;
-    Registry.save(Me.registry);
-  }
-
-  static load(username) {
-    if (!Me.registry[username]) {
-      throw new Error(`Username ${username} does not exist.`);
-    }
-    return new Me(username, Me.registry[username]);
-  }
-
-  addDevice(deviceInfo = null) {
-    const device = deviceInfo || {
-      deviceId: crypto.randomUUID(),
-      hostname: os.hostname(),
-      platform: os.platform(),
-      isPrimary: this.identity.devices.length === 0,
-    };
-
-    this.identity.devices.push(device);
-    Registry.save(Me.registry);
-  }
-
-  removeDevice(deviceId) {
-    this.identity.devices = this.identity.devices.filter((d) => d.deviceId !== deviceId);
-    Registry.save(Me.registry);
-  }
-
-  listDevices() {
-    return this.identity.devices;
-  }
-
-  static getAllUsers() {
-    return Object.keys(Me.registry);
-  }
-}
-
-export default Me;