diff --git a/.eslintrc b/.eslintrc
index cc53da22d..a62234fdf 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -37,6 +37,7 @@
     "FileReader": true,
     "cyblog": "readonly"
   },
+
   "rules": {
     "valid-jsdoc": "off",
     "no-shadow": "off",
diff --git a/docs/backend.md b/docs/backend.md
index 7f36deeb9..69cc83b36 100644
--- a/docs/backend.md
+++ b/docs/backend.md
@@ -1,51 +1,194 @@
-# Backend Architecture
+# CYB local backend(in-browser)
+
+Cyb plays singinficat role in cyber infrastructure. The app reconstruct self-sufficient backend+frontend pattern inside the browser.
+In big view app consist from 3 parts:
 
 ```mermaid
 graph TD;
+        App["frontend\n(main thread)"]-.proxy.->Backend["backend\n(shared worker)"];
+        App-.proxy.->Db["graph db\n(shared worker)"];
+        Backend-.proxy.->Db;
+        App<-.message\nchannels.->Backend;
+```
 
-    subgraph frontend["frontend(main thread)"]
-        App["Frontend"]-->Hook["useBackend()"];
-        Hook-->methods("startSync()\nloadIpfs()\n...\nisReady\nipfsError\n...");
-        Hook-.broadcast channel\n(any worker).->reducer["redux(state)"]
-        Hook-.save history from app.->defferedDbApiFront[/"DefferedDbApi(proxy)"/]
-        Hook--osenseApi["senseApi"];
-        Hook--oipfsApiFront[/"ipfsApi(proxy)"/];
-        senseApi--odbApi[/"dbApi(proxy)"/];
-    end
+To reduce overload of main thread we have created 2 separate shared workers, where all the stuff is hosted. Bi-interraction between all layers occurs using proxy(comlink abstraction) or directly using broadcast channels.
 
-    dbApi<-.message channel.->dbWorker["dbApi"];
-    subgraph dbWorkerGraph["cyb~db(worker)"]
-        dbWorker<-.bindings(webApi).->cozodb{{"CozoDb(wasm)"}}
-    end
+## Db layer
+
+Db worker is pretty simple it it's host only local relational-graph-vector database - [[cozo]]. It's represented with DbApi in frontend and backend layers.
+Cozo provide bazing fast access to brain and ipfs data in relational form and also in vector format, processing by [ml]embedder.
 
-    defferedDbApiFront-.->defferedDbApi;
-    ipfsApiFront<-.->ipfsApi;
-    subgraph backgroundWorker["cyb~backend(worker)"]
-        subgraph sync["sync service"]
-            ipfsNode["ipfs node"];
-            links;
-            transactions;
+```mermaid
+graph TD;
+        dbApi["dbApi"]--odb_meta_orm;
+        subgraph rune["cozo db"]
+            db_meta_orm[["meta orm"]]-.->db;
         end
-        sync--oparticleResolver[["Particle resolver"]]
-        particleResolver--oqueue;
-        particleResolver--odbProxyWorker;
-        sync--oipfsApi;
-        sync--odbProxyWorker[/"dbApi(proxy)"/];
-        defferedDbApi[["defferedDbApi"]]-->dbProxyWorker;
-        queue-->defferedDbApi;
-        ipfsApi--oqueue[["queue"]];
-        ipfsApi--onode["node"];
-        queue--balancer-->node;
-        node--embedded-->helia;
-        node--rpc-->kubo;
-        node--embedded-->js-ipfs;
+```
+
+### Db entities
+
+- brain:
+  - particles
+    - embeddings
+  - links
+  - transactions
+  - community
+- sense:
+
+  - sync items + update status
+
+- system:
+  - config
+  - queue messages
+
+## Backend layer
+
+Backend worker is more complicated it contains significant elements of cyb architecture:
+
+```mermaid
+graph TD;
+    subgraph Backend["backend(shared worker)"]
+
         subgraph ipfs["ipfs implementations"]
             helia;
             kubo;
             js-ipfs;
         end
 
-        dbProxyWorker<-.message channel.->dbWorker
+        subgraph queues["message brokers"]
+            ipfs_queue["ipfs load balancer"];
+            queue["data processing queue aka bus"];
+        end
+
+        subgraph rune["rune"]
+            vm["virtual machine"]--ovm_bingen{{"cyb bindings"}};
+        end
+
+        subgraph sense["sense"]
+            link_sync["link sync"];
+            msg_sync["message sync"];
+            swarm_sync["swarm sync"];
+        end
+
+        subgraph ml["ML transformers"]
+            feature_extractor["embedder"];
+        end
+
+    end
+```
+
+### Ipfs module
+
+Represented with IpfsApi at frontend layer, but also have direct access for some edge cases
+
+- Uses module that encapsulate different Ipfs implementations(kubo, helia, js-ipfs(obsolete))
+  - cache content(local storage & cozo)
+  - preserve redundancy
+- Ipfs queue, process all requests to ipfs, prioritize, cancel non-actual requests and organize content pipeline
+  - responsible for:
+    - ipfs load balancing(limit of requests)
+    - request prioritizing(actual requests first)
+    - fault processing(switch fetch policy)
+    - post processing(**inline rune vm** into pipeline)
+
+```mermaid
+graph LR
+user(ipfsApi\nenqueue particle) --> q[["queue\n(balancer)"]] --> node[/"ipfs"/] -- found --> rune[rune vm] -- mutation | content --> cache["cache"] --> app(app\ncontent)
+node -. not found\n(retry | error) .-> q
+```
+
+## Bus
+
+Represented with some helpers and used for cases when blaancer is needed, some services not initialized yet(deffered actions), or long calculations is requered(ml inference, ipfs requests):
+
+- particle, request ipfs, save; calc embedding
+- link, deffered save
+- message persistence is protected by db store
+
+```mermaid
+graph TD;
+        sender{{"enqueue(...)"}} -.message bus.-> bus
+        subgraph task["task manager"]
+            bus[["queue listener"]];
+
+            bus-.task.->db("store\ndata")--odb1["dbApi"];
+            bus-.task.->ml("calculate\nembedding")--oml1["mlApi"];
+            bus-.task.->ipfs("request ipfs\nlow-priority")--oi["ipfsApi"]
+        end
+```
+
+## Sense
+
+Represented by SenseApi + subscription to broadcast channel at fronted layer. Provide continious update of cyberlinks related to my brain and my swarm, recieving on chain messages etc.:
+
+- Particles service (pooling)
+- Transactions service (pooling + websocket)
+- My friends service (pooling)
+- Ipfs service(pooling)
+
+All data and update status is stored into db, when some new data is recieved that triggers notification for frontendю
+
+```mermaid
+graph TD;
+    db[["dbApi"]];
+    bus[["particle queue"]];
+
+    subgraph sense["sync service"]
+        notification("notification service")
+
+        particles[["particle service"]]--onotification;
+        transactions[["transaction service"]]--onotification;
+        myfriend[["my friends service"]]--onotification;
+
+        particles -.loop.-> particles;
+        transactions -.loop.-> transactions;
+        myfriend -.loop.-> myfriend;
+    end
+
+
+    subgraph blockchain["blockchain"]
+        lcd[["lcd"]]
+        websockets("websockets")
+        indexer[["indexer"]]
+    end
+
+    subgraph app["frontend"]
+        redux["redux"]
+        sender{{"senseApi"}};
+    end
+
+    notification -.message.-> redux;
+    sender -.proxy.-> db;
+    sense -.proxy.-> db;
+    sense -.message.-> bus;
+    bus -.proxy.-> db;
+
+    sense <-.request\nsubscriptin.->blockchain;
+
+```
+
+## Rune
+
+Rune VM execution is pipelined thru special abstraction called entrypoints. VM have bindings to all app parts: DB, transformers, signer, blockchain api, ipfs and also includes context of the entrypoint.(see. [[scripting]] for detailed description).
+
+## ML transformers
+
+Represented my mlApi. Uses inference from local ML models hosted inside browser.
+
+- future extractor. BERT-like model to trnsform text-to-embeddings.
+
+```mermaid
+graph TD;
+    subgraph ml["transformers"]
+        embedder["embedder"];
+    end
+
+    subgraph dbApi["dbApi"]
+        db[["DB"]];
     end
+    mlApi["mlApi"];
 
+    mlApi--odb;
+    mlApi--oembedder;
 ```
diff --git a/docs/scripting.md b/docs/scripting.md
new file mode 100644
index 000000000..765d42546
--- /dev/null
+++ b/docs/scripting.md
@@ -0,0 +1,404 @@
+# soul: scripting guide
+
+[rune Language]: https://rune-rs.github.io
+[cyb]: https://cyb.ai
+
+[cyb] uses [rune Language] for embeddable scripting aka [[cybscript]].
+
+rune is virtual machine that runs inside cyb and process all commands and rendering results
+
+## why we choose new language?
+
+rune is dynamic, compact, portable, async and fast scripting language which is specially targeted to rust developers.
+
+to our dismay we was not able to find any other way to provide dynamic execution in existing browsers which are compatable with future wasm based browsers.
+
+rune is wasm module written in rust.
+
+we hope you will enjoy it.
+
+Using cybscript any cyber citizen can
+
+- tune-up his [[soul]]
+- extend and modify robot behaivior and functionality
+
+soul is stored in [[ipfs]] and is linked directly to avatars passport.
+
+## CYB module
+
+cyb module provide bindings that connect cyber-scripting with app and extend [Rune language] functionality.
+
+#### Distributed computing
+
+Allows to evaluate code from external IPFS scripts in verifiable way, execute remote computations
+
+```
+// Evaluate function from IPFS
+cyb::eval_script_from_ipfs(cid,'func_name', #{'name': 'john-the-baptist', 'evangelist': true, 'age': 33})
+
+// Evaluate remote function(in developement)
+cyb::eval_remote_script(peer_id, func_name, params)
+```
+
+#### Passport
+
+Get info about Citizenship
+
+```
+// Get passport data by nickname
+cyb::get_passport_by_nickname(nickname: string) -> json;
+```
+
+#### Cyber links
+
+Work with Knowelege Graph
+
+```
+cyb::get_cyberlinks_from_cid(cid: string) -> json;
+cyb::get_cyberlinks_to_cid(cid: string)  -> json;
+
+// Search links by text or cid
+cyb::cyber_search(query: string) -> json;
+
+// Create cyber link
+// (this action requires trigger signer)
+cyb::cyber_link(from_cid: string, to_cid: string);
+```
+
+#### IPFS
+
+Work with IPFS
+
+```
+cyb::get_text_from_ipfs(cid: string) -> string;
+cyb::add_content_to_ipfs(text: string);
+```
+
+#### Local relational-graph-vector database
+
+Access to [[cozo]] and your [[brain]] data represented in text and vector-based formats.
+
+```
+// return N closest particles based on embeddings of each
+cyb::search_by_embedding(text:string, count: int) -> string[];
+```
+
+#### Experemental
+
+OpenAI promts(beta, in developement)
+
+```
+// Apply prompt OpenAI and get result
+cyb::open_ai_prompt(prompt: string;  params: json) -> string;
+```
+
+#### Debug
+
+Logging and debug methods
+
+```
+// Add debug info to script output
+dbg(`personal_processor ${cid} ${content_type} ${content}`);
+
+// console.log
+cyb:log("blah");
+```
+
+## Entrypoints
+
+Entrypoint is important concept of cyber scripting, literally that is the place where cyber-script is inlined into app pipeline.
+At the moment all entrypoint types is related to some particle in cyber:
+
+- Moon Domain Resolver
+- Personal Processor
+- Ask Companion
+
+### Entrypoint principles
+
+Each entrypoint is function that accept some arguments as **input**.
+
+```
+pub async fn personal_processor(cid, content_type, content) {
+    // ... //
+}
+```
+
+_`personal_processor` is entrypoint for each-single particle(see. furter)_
+
+Second convention that each entrypoint should return **output** object - with one required property named _action_ and some optional props depending on action for ex. `#{action: 'pass'}`.
+
+Cyber-scripting has helpers to construct object-like responses, with mandatory "action" field and some optional fields:
+
+```
+pass() // pass untouched = #{action: 'pass'}
+
+hide() // hide particle = #{ "action": "hide" }
+
+cid_result(cid) // change particle's cid and parse = #{ "action": "cid_result", "cid": cid  }
+
+content_result(content) //  modify particle content = #{ "action": "content_result", "content": content }
+
+error(message) // error ^_^ = #{ "action": "error", "message": message }
+```
+
+So minimal entrypoint looks like this:
+
+```
+pub async fn personal_processor(cid, content_type, content) {
+    return pass() // keep data stream untouched
+}
+```
+
+### Entrypoint types
+
+#### Particle processor
+
+Every single particle goes thru the pipeline and **personal_processor** function is applied to it content:
+
+```mermaid
+graph LR
+A[particle] -- cid --> B[IPFS] -- content --> C(("personal<br />processor")) -- content mutation --> D(app)
+```
+
+```
+// params:
+//      cid: CID of the content
+//      content_type: text, image, link, pdf, video, directory, html etc...
+//      content: (text only supported at the moment)
+pub async fn personal_processor(cid, content_type, content) {
+    /* SOME CODE */
+}
+```
+
+User can do any transformation of the particle in pipeline
+
+```
+// Update content
+return content_result("Transformed content")
+
+// Replace CID -> re-apply new particle
+return cid_result("Qm.....")
+
+// Hide item from UI
+return hide()
+
+// Keep it as is
+return pass()
+```
+
+#### .moon domain resolver
+
+Every user can write his own .moon domain resolver: _[username].moon_. When any other user meep particle with exactly such text, entrypoint will be executed.
+
+```mermaid
+graph LR
+B(username.moon) -- username --> C["cyber<br/>passport<br/>particle"] --  cid --> D(IPFS) -- script code --> E(( particle<br/> resolver)) -- render content --> F(result)
+```
+
+Minimal resolver can looks like this: \* _no input params but context is used(user that look at your domain)_
+
+```
+pub async fn moon_domain_resolver() {
+
+    // particle consumer from context
+    let name = cyb::context.nickname;
+
+    // respond
+    // as string
+    return content_result(`Hello ${name}!`)
+
+    // or CID(can be any text/image or even app hosted inside IPFS)
+    // return cid_result("QmcqikiVZJLmum6QRDH7kmLSUuvoPvNiDnCKY4A5nuRw17")
+}
+```
+
+And there is minimal personal processor that process domain and run resolver from remote user script.
+
+```
+pub async fn personal_processor(cid, content_type, content) {
+    // check if text is passed here and it's looks like .moon domain
+    if content_type == "text" and content.ends_with(".moon") {
+            let items = content.split(".").collect::<Vec>();
+            let username = items[0];
+            let ext = items[1];
+            if username.len() <= 14 && ext == "moon" {
+
+                // get citizenship data by username
+                let passport = cyb::get_passport_by_nickname(username).await;
+
+                // get personal particle
+                let particle_cid = passport["extension"]["particle"];
+
+                // log to browser console
+                cyb::log(`Resolve ${username} domain from passport particle '${particle_cid}'`);
+
+                // execute user 'moon_domain_resolver' function from 'soul' script with zero params
+                return cyb::eval_script_from_ipfs(particle_cid, "moon_domain_resolver", []).await;
+        }
+    }
+}
+```
+
+#### Ask Companion
+
+User can extend UI of the particle with custom controls. User can pass meta items as script result and cyb will render as UI extension.
+At the moment we have 2 meta UI items:
+
+- text: `meta_text("title")`
+- link: `meta_link("/@master", "link to user named @master")`
+
+```mermaid
+graph LR
+E(user) -- search input --> C(("ask<br/>Companion")) -- companion payload --> D(meta UI)
+```
+
+```
+pub async fn ask_companion(cid, content_type, content) {
+    // plain text item
+    let links = [meta_text("similar:")];
+
+    // search closest 5 particles using local data from the brain(embedding-search)
+    let similar_results = cyb::search_by_embedding(content, 5).await;
+
+
+    for v in similar_results {
+        // link item
+        links.push(meta_link(`/oracle/ask/${v.cid}`, v.text));
+    }
+
+    return content_result(links)
+}
+```
+
+### Context
+
+One of important thing, that can be used inside scripting is the context.
+Context point to place and obstacles where entrypoint was triggered. Context is stored in `cyb::context` and contains such values:
+
+- params(url params)
+  - path / query / search
+- user(user that executes entrypoint)
+  - address / nickname / passport
+- secrets(key-value list from the cyber app)
+  - key/value storage
+
+```
+
+// nick of user that see this particle(in case of domain resolver)
+let name = cyb::context.user.nickname;
+
+// user particle that contains soul, that can be interracted directly from your soul
+let particle = cyb::context.particle;
+
+// Get list of url parameters (in progress)
+let path = cyb::context.params.path;
+
+//get some secret (in progress)
+let open_ai_api_key = cyb::context.secrets.open_ai_api_key;
+
+```
+
+## Advanced examples
+
+#### Personal processor
+
+```
+// your content for <citizen_name>.moon domain
+pub async fn moon_domain_resolver() {
+    // get nickname of domain resolver at the momemnt
+    let nickname =  cyb::context.user.nickname;
+
+    let rng = rand::WyRand::new();
+    let rand_int = rng.int_range(0, 999999);
+
+    return content_result(`Hello, ${nickname}, your lucky number is ${rand_int} 🎉`);
+
+    // substitute with some CID (ipfs hosted app in this case)
+    // return cid_result("QmcqikiVZJLmum6QRDH7kmLSUuvoPvNiDnCKY4A5nuRw17")
+}
+
+// Extend particle page with custom UI elements
+pub async fn ask_companion(cid, content_type, content) {
+    // plain text item
+    let links = [meta_text("similar:")];
+
+    // search closest 5 particles using local data from the brain
+    let similar_results = cyb::search_by_embedding(content, 5).await;
+
+
+    for v in similar_results {
+        // link item
+        links.push(meta_link(`/oracle/ask/${v.cid}`, v.text));
+    }
+
+    return content_result(links)
+}
+
+// Transform content of the particle
+pub async fn personal_processor(cid, content_type, content) {
+
+    // skip any non-text content
+    if content_type != "text" {
+        return pass()
+    }
+
+    // <citizen_name>.moon domain resolver
+    if content.ends_with(".moon") {
+        let items = content.split(".").collect::<Vec>();
+
+        let username = items[0];
+        let ext = items[1];
+
+        if username.len() <= 14 && ext == "moon" {
+
+            // get passport data by username
+            let passport = cyb::get_passport_by_nickname(username).await;
+
+            // particle - CID of soul script
+            let particle_cid = passport["extension"]["particle"];
+
+            cyb::log(`Resolve ${username} domain from passport particle '${particle_cid}'`);
+
+            // resolve content(script) by cid
+            // evaluate 'moon_domain_resolver' from that
+            let result = cyb::eval_script_from_ipfs(particle_cid, "moon_domain_resolver", []).await;
+
+            return result
+        }
+    }
+
+    // example of content exclusion from the search results
+    let buzz_word = "пиздопроебанное хуеплетство";
+
+    if content.contains(buzz_word) {
+        cyb::log(`Hide ${cid} item because of '${buzz_word}' in the content`);
+        return hide()
+    }
+
+
+    // example of content modification
+    // replaces cyber with cyber❤
+    let highlight_text = "cyber";
+    let highlight_with = "❤";
+
+    if content.contains(highlight_text) {
+        cyb::log(`Update ${cid} content, highlight ${highlight_text}${highlight_with}`);
+        return content_result(content.replace(highlight_text, `${highlight_text}${highlight_with}`))
+    }
+
+    // replace <token_name>@NOW (ex. bitcoin@NOW) with actual price in usdt
+    // using external api call
+    if content.contains("@NOW") {
+        let left_part = content.split("@NOW").next().unwrap();
+        let token_name = left_part.split(" ").rev().next().unwrap();
+        let vs_currency = "usd";
+
+        // external url call
+        let json =  http::get(`https://api.coingecko.com/api/v3/simple/price?ids=${token_name}&vs_currencies=${vs_currency}`).await?.json().await?;
+        return content_result(content.replace(`${token_name}@NOW`, `Current ${token_name} price is ${json[token_name][vs_currency]} ${vs_currency}`))
+    }
+
+    // anything else - pass as is
+    pass()
+}
+```
diff --git a/package.json b/package.json
index 76754ca1e..eb8fedc79 100644
--- a/package.json
+++ b/package.json
@@ -178,6 +178,7 @@
     "@types/react-dom": "^18.0.11",
     "@types/react-router-dom": "^5.3.3",
     "@uniswap/sdk": "^3.0.3",
+    "@xenova/transformers": "^2.17.0",
     "apollo-boost": "^0.4.7",
     "bech32": "^1.1.3",
     "big.js": "^5.2.2",
@@ -186,10 +187,12 @@
     "blockstore-idb": "^1.1.4",
     "cjs-to-es6": "^2.0.1",
     "classnames": "^2.3.1",
+    "codemirror": "5.57.0",
     "comlink": "^4.4.1",
     "core-js": "^3.30.0",
     "crypto": "^1.0.1",
     "cyb-cozo-lib-wasm": "^0.7.145",
+    "cyb-rune-wasm": "^0.0.82",
     "datastore-core": "^9.2.3",
     "datastore-idb": "^2.1.4",
     "dateformat": "^3.0.3",
@@ -227,6 +230,7 @@
     "raw-loader": "^4.0.2",
     "rc-slider": "^9.7.2",
     "react": "^18.0.0",
+    "react-codemirror2": "^7.2.1",
     "react-dom": "^18.0.0",
     "react-force-graph": "^1.39.5",
     "react-helmet": "^6.1.0",
@@ -239,6 +243,7 @@
     "react-transition-group": "^4.4.2",
     "read-chunk": "^4.0.3",
     "readable-stream": "^4.3.0",
+    "redux-observable": "^3.0.0-rc.2",
     "redux-thunk": "^2.4.2",
     "regenerator-runtime": "^0.13.7",
     "remark-breaks": "^3.0.3",
diff --git a/src/components/ContentItem/contentItem.tsx b/src/components/ContentItem/contentItem.tsx
index 525c29d81..8819681b2 100644
--- a/src/components/ContentItem/contentItem.tsx
+++ b/src/components/ContentItem/contentItem.tsx
@@ -1,15 +1,11 @@
 // TODO: refactor needed
-import React, { useEffect, useState } from 'react';
+import { useEffect } from 'react';
 import { Link } from 'react-router-dom';
 import { $TsFixMe } from 'src/types/tsfix';
-import useQueueIpfsContent from 'src/hooks/useQueueIpfsContent';
-import type {
-  IpfsContentType,
-  IPFSContentDetails,
-} from 'src/services/ipfs/types';
-import { LinksType } from 'src/containers/Search/types';
+import type { IpfsContentType } from 'src/services/ipfs/types';
+import useParticle from 'src/hooks/useParticle';
 
-import { parseArrayLikeToDetails } from 'src/services/ipfs/utils/content';
+import { LinksType } from 'src/containers/Search/types';
 
 import SearchItem from '../SearchItem/searchItem';
 
@@ -35,24 +31,15 @@ function ContentItem({
   setType,
   className,
 }: ContentItemProps): JSX.Element {
-  const [details, setDetails] = useState<IPFSContentDetails>(undefined);
-  const { status, content, fetchParticle } = useQueueIpfsContent(parentId);
+  const { details, status, hidden, content } = useParticle(cid, parentId);
 
   useEffect(() => {
-    fetchParticle && (async () => fetchParticle(cid, item?.rank))();
-  }, [cid, item?.rank, fetchParticle]);
+    details?.type && setType && setType(details?.type);
+  }, [details]); //TODO: REFACT - setType rise infinite loop
 
-  useEffect(() => {
-    (async () => {
-      const details = await parseArrayLikeToDetails(
-        content,
-        cid
-        // (progress: number) => console.log(`${cid} progress: ${progress}`)
-      );
-      setDetails(details);
-      details?.type && setType && setType(details?.type);
-    })();
-  }, [content, cid]); //TODO: REFACT - setType rise infinite loop
+  if (hidden) {
+    return <div />;
+  }
 
   return (
     <Link className={className} style={{ color: '#fff' }} to={`/ipfs/${cid}`}>
diff --git a/src/components/DebugContentInfo/DebugContentInfo.tsx b/src/components/DebugContentInfo/DebugContentInfo.tsx
index da5fe1ffa..c61a9c1a2 100644
--- a/src/components/DebugContentInfo/DebugContentInfo.tsx
+++ b/src/components/DebugContentInfo/DebugContentInfo.tsx
@@ -1,5 +1,6 @@
-import { IPFSContentMaybe, IpfsContentSource } from 'src/utils/ipfs/ipfs';
+import { IpfsContent, IpfsContentSource } from 'src/utils/ipfs/ipfs';
 import styles from './DebugContentInfo.module.scss';
+import { Option } from 'src/types';
 
 function DebugContentInfo({
   cid,
@@ -8,9 +9,9 @@ function DebugContentInfo({
   status,
 }: {
   cid: string;
-  source: IpfsContentSource | undefined;
-  content: IPFSContentMaybe;
-  status: string | undefined;
+  source: Option<IpfsContentSource>;
+  content: Option<IpfsContent>;
+  status: Option<string>;
 }) {
   const meta = content ? content.meta : undefined;
   const measurementInfo =
diff --git a/src/components/VideoPlayer/VideoPlayerGatewayOnly.tsx b/src/components/VideoPlayer/VideoPlayerGatewayOnly.tsx
index 82bb49348..cb3f2323b 100644
--- a/src/components/VideoPlayer/VideoPlayerGatewayOnly.tsx
+++ b/src/components/VideoPlayer/VideoPlayerGatewayOnly.tsx
@@ -1,11 +1,11 @@
 /* eslint-disable no-restricted-syntax */
 import { useEffect, useState } from 'react';
-import { IPFSContentDetails, IPFSContentMaybe } from 'src/services/ipfs/types';
+import { IPFSContent, IPFSContentDetails } from 'src/services/ipfs/types';
 import { useBackend } from 'src/contexts/backend/backend';
 import { CYBER_GATEWAY_URL } from 'src/services/ipfs/config';
 
 interface VideoPlayerProps {
-  content: IPFSContentMaybe;
+  content: IPFSContent;
   details: IPFSContentDetails;
 }
 
diff --git a/src/components/contentIpfs/contentIpfs.tsx b/src/components/contentIpfs/contentIpfs.tsx
index 0f1fc69bd..f0f027027 100644
--- a/src/components/contentIpfs/contentIpfs.tsx
+++ b/src/components/contentIpfs/contentIpfs.tsx
@@ -1,4 +1,4 @@
-import { IPFSContentDetails, IPFSContentMaybe } from 'src/services/ipfs/types';
+import { IPFSContent, IPFSContentDetails } from 'src/services/ipfs/types';
 import { CYBER_GATEWAY } from 'src/constants/config';
 import VideoPlayerGatewayOnly from '../VideoPlayer/VideoPlayerGatewayOnly';
 import GatewayContent from './component/gateway';
@@ -7,6 +7,7 @@ import LinkHttp from './component/link';
 import Pdf from '../PDF';
 import Img from './component/img';
 import Audio from './component/Audio/Audio';
+import { Option } from 'src/types';
 
 function OtherItem({
   content,
@@ -25,6 +26,10 @@ function OtherItem({
   return <GatewayContent url={`${CYBER_GATEWAY}/ipfs/${cid}`} />;
 }
 
+function HtmlItem({ cid }: { cid: string }) {
+  return <GatewayContent url={`${CYBER_GATEWAY}/ipfs/${cid}`} />;
+}
+
 function DownloadableItem({ cid, search }: { cid: string; search?: boolean }) {
   if (search) {
     return <div>{`${cid} (gateway)`}</div>;
@@ -34,7 +39,7 @@ function DownloadableItem({ cid, search }: { cid: string; search?: boolean }) {
 
 type ContentTabProps = {
   details: IPFSContentDetails;
-  content?: IPFSContentMaybe;
+  content?: Option<IPFSContent>;
   cid: string;
   search?: boolean;
 };
@@ -77,7 +82,8 @@ function ContentIpfs({ details, content, cid, search }: ContentTabProps) {
           {contentType === 'link' && (
             <LinkHttp url={details.content!} preview={search} />
           )}
-          {contentType === 'other' && (
+          {contentType === 'html' && <HtmlItem cid={content?.cid} />}
+          {['other', 'cid'].some((i) => i === contentType) && (
             <OtherItem search={search} cid={cid} content={details.content} />
           )}
         </>
diff --git a/src/components/loader/loader.js b/src/components/loader/loader.js
index 3dbf40cee..a73978b53 100644
--- a/src/components/loader/loader.js
+++ b/src/components/loader/loader.js
@@ -220,7 +220,10 @@ function bootstrap() {
           console.log('service worker registered: ', registration);
         })
         .catch((registrationError) => {
-          console.log('service worker registration failed: ', registrationError);
+          console.log(
+            'service worker registration failed: ',
+            registrationError
+          );
         });
     });
   } else {
@@ -247,8 +250,9 @@ function bootstrap() {
 
       progressData.innerHTML = `Loading: <span>${Math.round(
         progress * 100
-      )}%</span>. <br/> Network speed: <span>${Math.round(e.networkSpeed * 100) / 100
-        } kbps</span>`;
+      )}%</span>. <br/> Network speed: <span>${
+        Math.round(e.networkSpeed * 100) / 100
+      } kbps</span>`;
 
       // console.log(e.loaded, e.loaded / e.totalSize); // @TODO
     })
diff --git a/src/constants/defaultNetworks.local.ts b/src/constants/defaultNetworks.local.ts
new file mode 100644
index 000000000..28da15fad
--- /dev/null
+++ b/src/constants/defaultNetworks.local.ts
@@ -0,0 +1,34 @@
+import { NetworkConfig, Networks } from 'src/types/networks';
+
+type NetworksList = {
+  [key in Networks.BOSTROM | Networks.SPACE_PUSSY]: NetworkConfig;
+};
+
+const defaultNetworks: NetworksList = {
+  bostrom: {
+    CHAIN_ID: Networks.BOSTROM,
+    BASE_DENOM: 'boot',
+    DENOM_LIQUID: 'hydrogen',
+    RPC_URL: 'http://localhost:26657', //'https://rpc.bostrom.cybernode.ai',
+    LCD_URL: 'http://localhost:1317/', //'https://lcd.bostrom.cybernode.ai',
+    WEBSOCKET_URL: 'ws://localhost:26657', //'wss://rpc.bostrom.cybernode.ai/websocket',
+    INDEX_HTTPS: 'http://localhost:8090/v1/graphql', //'https://index.bostrom.cybernode.ai/v1/graphql',
+    INDEX_WEBSOCKET: 'ws://localhost:8090/v1/graphql', // 'wss://index.bostrom.cybernode.ai/v1/graphql',
+    BECH32_PREFIX: 'bostrom',
+    MEMO_KEPLR: '[bostrom] cyb.ai, using keplr',
+  },
+  'space-pussy': {
+    CHAIN_ID: Networks.SPACE_PUSSY,
+    BASE_DENOM: 'pussy',
+    DENOM_LIQUID: 'liquidpussy',
+    RPC_URL: 'https://rpc.space-pussy.cybernode.ai/',
+    LCD_URL: 'https://lcd.space-pussy.cybernode.ai',
+    WEBSOCKET_URL: 'wss://rpc.space-pussy.cybernode.ai/websocket',
+    INDEX_HTTPS: 'https://index.space-pussy.cybernode.ai/v1/graphql',
+    INDEX_WEBSOCKET: 'wss://index.space-pussy.cybernode.ai/v1/graphql',
+    BECH32_PREFIX: 'pussy',
+    MEMO_KEPLR: '[space-pussy] cyb.ai, using keplr',
+  },
+};
+
+export default defaultNetworks;
diff --git a/src/constants/defaultNetworks.ts b/src/constants/defaultNetworks.ts
index 9342a27ca..7283d8e7e 100644
--- a/src/constants/defaultNetworks.ts
+++ b/src/constants/defaultNetworks.ts
@@ -9,9 +9,15 @@ const defaultNetworks: NetworksList = {
     CHAIN_ID: Networks.BOSTROM,
     BASE_DENOM: 'boot',
     DENOM_LIQUID: 'hydrogen',
-    RPC_URL: 'https://rpc.bostrom.cybernode.ai',
-    LCD_URL: 'https://lcd.bostrom.cybernode.ai',
-    WEBSOCKET_URL: 'wss://rpc.bostrom.cybernode.ai/websocket',
+    RPC_URL: process.env.IS_DEV
+      ? 'https://rpc.arch.bostrom.cybernode.ai:443'
+      : 'https://rpc.bostrom.cybernode.ai',
+    LCD_URL: process.env.IS_DEV
+      ? 'https://lcd.arch.bostrom.cybernode.ai:443'
+      : 'https://lcd.bostrom.cybernode.ai',
+    WEBSOCKET_URL: process.env.IS_DEV
+      ? 'wss://rpc.arch.bostrom.cybernode.ai:443/websocket'
+      : 'wss://rpc.bostrom.cybernode.ai/websocket',
     INDEX_HTTPS: 'https://index.bostrom.cybernode.ai/v1/graphql',
     INDEX_WEBSOCKET: 'wss://index.bostrom.cybernode.ai/v1/graphql',
     BECH32_PREFIX: 'bostrom',
diff --git a/src/containers/Search/SearchResults.tsx b/src/containers/Search/SearchResults.tsx
index 6dfa91716..6b369f40a 100644
--- a/src/containers/Search/SearchResults.tsx
+++ b/src/containers/Search/SearchResults.tsx
@@ -4,18 +4,16 @@ import { useParams } from 'react-router-dom';
 import Display from 'src/components/containerGradient/Display/Display';
 import Spark from 'src/components/search/Spark/Spark';
 import Loader2 from 'src/components/ui/Loader2';
-import { PATTERN_IPFS_HASH } from 'src/constants/patterns';
 import { useDevice } from 'src/contexts/device';
 import { IpfsContentType } from 'src/services/ipfs/types';
-import { getIpfsHash } from 'src/utils/ipfs/helpers';
 
 import useIsOnline from 'src/hooks/useIsOnline';
-import { encodeSlash } from '../../utils/utils';
 import ActionBarContainer from './ActionBarContainer';
 import Filters from './Filters/Filters';
 import styles from './SearchResults.module.scss';
 import FirstItems from './_FirstItems.refactor';
 import { initialContentTypeFilterState } from './constants';
+import { getSearchQuery } from 'src/utils/search/utils';
 import useSearchData from './hooks/useSearchData';
 import { LinksTypeFilter, SortBy } from './types';
 
@@ -89,15 +87,9 @@ function SearchResults({
     setContentType({});
 
     (async () => {
-      let keywordHashTemp = '';
+      const keywordHash = await getSearchQuery(query);
 
-      if (query.match(PATTERN_IPFS_HASH)) {
-        keywordHashTemp = query;
-      } else {
-        keywordHashTemp = await getIpfsHash(encodeSlash(query));
-      }
-
-      setKeywordHash(keywordHashTemp);
+      setKeywordHash(keywordHash);
     })();
   }, [query]);
 
diff --git a/src/containers/Search/hooks/useRankLinks.tsx b/src/containers/Search/hooks/useRankLinks.tsx
index 09bcd81e0..37993e0ee 100644
--- a/src/containers/Search/hooks/useRankLinks.tsx
+++ b/src/containers/Search/hooks/useRankLinks.tsx
@@ -4,16 +4,15 @@ import { useQueryClient } from 'src/contexts/queryClient';
 import { getRankGrade, searchByHash } from 'src/utils/search/utils';
 import { mapLinkToLinkDto } from 'src/services/CozoDb/mapping';
 import { coinDecimals } from 'src/utils/utils';
-import { useBackend } from 'src/contexts/backend/backend';
 
 import { LinksTypeFilter } from '../types';
 import { merge } from './shared';
+import { enqueueLinksSave } from 'src/services/backend/channels/BackendQueueChannel/backendQueueSenders';
 
 const PER_PAGE_LIMIT = 10;
 
 const useSearch = (hash: string, { skip = false } = {}) => {
   const cid = hash;
-  const { defferedDbApi } = useBackend();
 
   const queryClient = useQueryClient();
 
@@ -29,17 +28,14 @@ const useSearch = (hash: string, { skip = false } = {}) => {
     ['useSearch', cid],
     async ({ pageParam = 0 }: { pageParam?: number }) => {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const response = await searchByHash(
-        queryClient,
-        cid,
-        pageParam,
-        PER_PAGE_LIMIT
-      );
-      const result = response?.result || [];
-      result &&
-        defferedDbApi?.importCyberlinks(
-          result.map((l) => mapLinkToLinkDto(hash, l.particle))
+      const response = await searchByHash(queryClient, cid, pageParam);
+
+      if (response?.result) {
+        enqueueLinksSave(
+          response.result.map((l) => mapLinkToLinkDto(hash, l.particle))
         );
+      }
+
       return { data: response, page: pageParam };
     },
     {
diff --git a/src/containers/ipfs/components/SoulCompanion/SoulCompanion.tsx b/src/containers/ipfs/components/SoulCompanion/SoulCompanion.tsx
new file mode 100644
index 000000000..9a8f4afbb
--- /dev/null
+++ b/src/containers/ipfs/components/SoulCompanion/SoulCompanion.tsx
@@ -0,0 +1,87 @@
+import { Link } from 'react-router-dom';
+import {
+  ScriptingContextType,
+  useScripting,
+} from 'src/contexts/scripting/scripting';
+import type { ScriptMyCampanion } from 'src/services/scripting/types';
+import styles from './soulCompanion.module.scss';
+import { shortenString } from 'src/utils/string';
+import { ParticleCid } from 'src/types/base';
+import { IPFSContentDetails } from 'src/services/ipfs/types';
+import { Option } from 'src/types';
+import { useEffect, useState } from 'react';
+import { proxy } from 'comlink';
+
+type AskCompanionStatus = 'loading' | 'ready' | 'pending' | 'done' | 'error';
+
+function SoulCompanion({
+  cid,
+  details,
+  skip,
+}: {
+  cid: ParticleCid;
+  details: Option<IPFSContentDetails>;
+  skip: boolean;
+}) {
+  const [metaItems, setMetaItems] = useState<ScriptMyCampanion['metaItems']>(
+    []
+  );
+  const [status, setStatus] = useState<AskCompanionStatus>('loading');
+  const { rune, isSoulInitialized } = useScripting();
+
+  useEffect(() => {
+    if (!skip && isSoulInitialized && details) {
+      if (details.type && details.type !== 'text' && details.text) {
+        setStatus('done');
+        setMetaItems([
+          { type: 'text', text: `Skip companion for '${details.content}'.` },
+        ]);
+        return;
+      }
+
+      rune
+        ?.askCompanion(
+          cid,
+          details!.type!,
+          details!.text!.substring(0, 255),
+          proxy((data = {}) => console.log('CALLBACK'))
+        )
+        .then((result) => {
+          setMetaItems(result.metaItems);
+          setStatus('done');
+        });
+    }
+  }, [cid, skip, rune, isSoulInitialized, details]);
+
+  useEffect(() => {
+    setMetaItems([]);
+  }, [cid]);
+
+  if (status !== 'done' && metaItems) {
+    return (
+      <div
+        className={styles.itemText}
+      >{`soul companion status: ${status}`}</div>
+    );
+  }
+  return (
+    <div>
+      <ul className={styles.itemLinks}>
+        {metaItems.map((item, index) => (
+          <li key={`soul_comp_${index}`}>
+            {item.type === 'text' && (
+              <p className={styles.itemText}>{item.text}</p>
+            )}
+            {item.type === 'link' && (
+              <Link className={styles.itemLink} to={item.url}>
+                {shortenString(item.title, 64)}
+              </Link>
+            )}
+          </li>
+        ))}
+      </ul>
+    </div>
+  );
+}
+
+export default SoulCompanion;
diff --git a/src/containers/ipfs/components/SoulCompanion/soulCompanion.module.scss b/src/containers/ipfs/components/SoulCompanion/soulCompanion.module.scss
new file mode 100644
index 000000000..d65acd3fa
--- /dev/null
+++ b/src/containers/ipfs/components/SoulCompanion/soulCompanion.module.scss
@@ -0,0 +1,24 @@
+.itemLinks {
+  display: flex;
+  margin: -10px 0;
+
+  list-style-type: none;
+  font-size: 14px;
+}
+
+.itemText {
+  font-size: 14px;
+  display: block;
+}
+
+.itemLink {
+  margin: 0 5px;
+  display: block;
+  // white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  max-width: 158px;
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+}
diff --git a/src/containers/ipfs/hooks/useGetAnswers.ts b/src/containers/ipfs/hooks/useGetAnswers.ts
index 061a7817a..d59ab85ba 100644
--- a/src/containers/ipfs/hooks/useGetAnswers.ts
+++ b/src/containers/ipfs/hooks/useGetAnswers.ts
@@ -3,12 +3,11 @@ import { useQueryClient } from 'src/contexts/queryClient';
 import { useState } from 'react';
 import { reduceParticleArr } from './useGetBackLink';
 import { searchByHash } from 'src/utils/search/utils';
-import { useBackend } from 'src/contexts/backend/backend';
 import { mapLinkToLinkDto } from 'src/services/CozoDb/mapping';
+import { enqueueLinksSave } from 'src/services/backend/channels/BackendQueueChannel/backendQueueSenders';
 
 function useGetAnswers(hash) {
   const queryClient = useQueryClient();
-  const { defferedDbApi } = useBackend();
   const [total, setTotal] = useState(0);
   const {
     status,
@@ -26,10 +25,7 @@ function useGetAnswers(hash) {
       const reduceArr = result ? reduceParticleArr(result) : [];
       setTotal(pageParam === 0 && response.pagination.total);
 
-      defferedDbApi?.importCyberlinks(
-        result.map((l) => mapLinkToLinkDto(hash, l.particle))
-      );
-
+      enqueueLinksSave(result.map((l) => mapLinkToLinkDto(hash, l.particle)));
       return { data: reduceArr, page: pageParam };
     },
     {
diff --git a/src/containers/ipfs/ipfs.tsx b/src/containers/ipfs/ipfs.tsx
index eb79cb8c3..8d5d190ad 100644
--- a/src/containers/ipfs/ipfs.tsx
+++ b/src/containers/ipfs/ipfs.tsx
@@ -1,27 +1,27 @@
 import { useParams } from 'react-router-dom';
 import ContentIpfs from 'src/components/contentIpfs/contentIpfs';
-import useQueueIpfsContent from 'src/hooks/useQueueIpfsContent';
 import { useEffect, useMemo, useState } from 'react';
 import { useAdviser } from 'src/features/adviser/context';
 import { encodeSlash } from 'src/utils/utils';
 import { PATTERN_IPFS_HASH } from 'src/constants/patterns';
 import { getIpfsHash } from 'src/utils/ipfs/helpers';
-import { parseArrayLikeToDetails } from 'src/services/ipfs/utils/content';
-import { IPFSContentDetails } from 'src/services/ipfs/types';
 import { useBackend } from 'src/contexts/backend/backend';
+
+import useParticle from 'src/hooks/useParticle';
+
 import { Dots, MainContainer } from '../../components';
 import ContentIpfsCid from './components/ContentIpfsCid';
 import styles from './IPFS.module.scss';
 import SearchResults from '../Search/SearchResults';
 import AdviserMeta from './components/AdviserMeta/AdviserMeta';
+import SoulCompanion from './components/SoulCompanion/SoulCompanion';
 
 function Ipfs() {
   const { query = '' } = useParams();
   const [cid, setCid] = useState<string>('');
+  const { details, status, content, mutated } = useParticle(cid);
 
-  const { fetchParticle, status, content } = useQueueIpfsContent(cid);
   const { ipfsApi, isIpfsInitialized, isReady } = useBackend();
-  const [ipfsDataDetails, setIpfsDatDetails] = useState<IPFSContentDetails>();
 
   const { setAdviser } = useAdviser();
 
@@ -36,32 +36,12 @@ function Ipfs() {
     } else if (isIpfsInitialized) {
       (async () => {
         const cidFromQuery = (await getIpfsHash(encodeSlash(query))) as string;
-        await ipfsApi!.addContent(query);
-
+        ipfsApi!.addContent(query);
         setCid(cidFromQuery);
       })();
     }
   }, [isText, isReady, query, ipfsApi, isIpfsInitialized]);
-
-  useEffect(() => {
-    (async () => {
-      cid && fetchParticle && (await fetchParticle(cid));
-    })();
-  }, [cid, fetchParticle]);
-
-  useEffect(() => {
-    if (status === 'completed') {
-      (async () => {
-        const details = await parseArrayLikeToDetails(
-          content,
-          cid
-          // (progress: number) => console.log(`${cid} progress: ${progress}`)
-        );
-        setIpfsDatDetails(details);
-      })();
-    }
-  }, [content, status, cid]);
-
+  useEffect(() => {}, [details]);
   useEffect(() => {
     if (!status) {
       return;
@@ -84,19 +64,19 @@ function Ipfs() {
       setAdviser(
         <AdviserMeta
           cid={cid}
-          type={ipfsDataDetails?.type}
-          size={content?.meta?.size || ipfsDataDetails?.content?.length}
+          type={details?.type}
+          size={content?.meta?.size || details?.content?.length}
         />,
         'purple'
       );
     }
-  }, [ipfsDataDetails, setAdviser, cid, content, status]);
+  }, [details, setAdviser, cid, content, status]);
 
   return (
     <MainContainer width="62%" resetMaxWidth>
       <div className={styles.wrapper}>
-        {status === 'completed' && ipfsDataDetails ? (
-          <ContentIpfs content={content} details={ipfsDataDetails} cid={cid} />
+        {status === 'completed' && details ? (
+          <ContentIpfs content={content} details={details} cid={cid} />
         ) : isText ? (
           <ContentIpfs
             details={{
@@ -116,7 +96,7 @@ function Ipfs() {
           />
         )}
       </div>
-
+      <SoulCompanion cid={cid} details={details} skip={mutated} />
       <SearchResults />
     </MainContainer>
   );
diff --git a/src/containers/market/index.jsx b/src/containers/market/index.jsx
index 858b5e5f1..0b59fe8aa 100644
--- a/src/containers/market/index.jsx
+++ b/src/containers/market/index.jsx
@@ -16,6 +16,7 @@ import { coinDecimals } from '../../utils/utils';
 import { useQueryClient } from 'src/contexts/queryClient';
 import { useBackend } from 'src/contexts/backend/backend';
 import { mapLinkToLinkDto } from 'src/services/CozoDb/mapping';
+import { enqueueLinksSave } from 'src/services/backend/channels/BackendQueueChannel/backendQueueSenders';
 
 function ContainerGrid({ children }) {
   return (
@@ -52,7 +53,6 @@ const reduceSearchResults = (data, query) => {
 function Market({ defaultAccount }) {
   const { addressActive } = useSetActiveAddress(defaultAccount);
   const queryClient = useQueryClient();
-  const { defferedDbApi } = useBackend();
 
   const { tab = 'BOOT' } = useParams();
   const { gol, cyb, boot, hydrogen, milliampere, millivolt, tocyb } =
@@ -82,7 +82,8 @@ function Market({ defaultAccount }) {
           setLoadingSearch(false);
           setAllPage(Math.ceil(parseFloat(response.pagination.total) / 10));
           setPage((item) => item + 1);
-          defferedDbApi?.importCyberlinks(
+
+          enqueueLinksSave(
             response.result.map((l) => mapLinkToLinkDto(hash, l.particle))
           );
         } else {
@@ -95,7 +96,7 @@ function Market({ defaultAccount }) {
       }
     };
     getFirstItem();
-  }, [queryClient, tab, defferedDbApi, update]);
+  }, [queryClient, tab, update]);
 
   const fetchMoreData = async () => {
     // a fake async api call like which sends
@@ -104,7 +105,8 @@ function Market({ defaultAccount }) {
     const response = await searchByHash(queryClient, keywordHash, page);
     if (response.result) {
       links = reduceSearchResults(response, tab);
-      defferedDbApi?.importCyberlinks(
+
+      enqueueLinksSave(
         response.result.map((l) => mapLinkToLinkDto(keywordHash, l.particle))
       );
     }
diff --git a/src/containers/portal/PasportMoonCitizenship.tsx b/src/containers/portal/PasportMoonCitizenship.tsx
index caa2ec608..2bd7f7934 100644
--- a/src/containers/portal/PasportMoonCitizenship.tsx
+++ b/src/containers/portal/PasportMoonCitizenship.tsx
@@ -47,9 +47,8 @@ function PassportMoonCitizenship() {
   const { isMobile: mobile } = useDevice();
   const defaultAccount = useAppSelector((state) => state.pocket.defaultAccount);
 
-  const p = useAppSelector(selectCurrentPassport);
+  const citizenship = useAppSelector(selectCurrentPassport);
   // FIXME: backward compatibility
-  const citizenship = p.data || null;
 
   const queryClient = useQueryClient();
   const { addressActive } = useSetActiveAddress(defaultAccount);
diff --git a/src/containers/sigma/hooks/useGetPassportByAddress.ts b/src/containers/sigma/hooks/useGetPassportByAddress.ts
index 2a528fa3a..a8bc4d1a6 100644
--- a/src/containers/sigma/hooks/useGetPassportByAddress.ts
+++ b/src/containers/sigma/hooks/useGetPassportByAddress.ts
@@ -12,7 +12,7 @@ function useGetPassportByAddress(accounts: any) {
   // temp for debug
   if (typeof address === 'object') {
     address = '';
-    debugger;
+    // debugger;
   }
 
   const { data, loading, error } = usePassportContract<Citizenship>({
diff --git a/src/contexts/backend/backend.tsx b/src/contexts/backend/backend.tsx
index ed215a3ff..80de1217a 100644
--- a/src/contexts/backend/backend.tsx
+++ b/src/contexts/backend/backend.tsx
@@ -3,6 +3,7 @@ import React, {
   useContext,
   useEffect,
   useMemo,
+  useRef,
   useState,
 } from 'react';
 import { useAppDispatch, useAppSelector } from 'src/redux/hooks';
@@ -18,13 +19,16 @@ import DbApiWrapper from 'src/services/backend/services/DbApi/DbApi';
 import { CozoDbWorker } from 'src/services/backend/workers/db/worker';
 import { BackgroundWorker } from 'src/services/backend/workers/background/worker';
 
-import { SyncEntryName } from 'src/services/backend/types/services';
 import { DB_NAME } from 'src/services/CozoDb/cozoDb';
 import { RESET_SYNC_STATE_ACTION_NAME } from 'src/redux/reducers/backend';
 import BroadcastChannelSender from 'src/services/backend/channels/BroadcastChannelSender';
 // import BroadcastChannelListener from 'src/services/backend/channels/BroadcastChannelListener';
 
+import { Observable } from 'rxjs';
+import { EmbeddingApi } from 'src/services/backend/workers/background/api/mlApi';
 import { SenseApi, createSenseApi } from './services/senseApi';
+import { RuneEngine } from 'src/services/scripting/engine';
+import { Option } from 'src/types';
 
 const setupStoragePersistence = async () => {
   let isPersistedStorage = await navigator.storage.persisted();
@@ -33,8 +37,8 @@ const setupStoragePersistence = async () => {
     isPersistedStorage = await navigator.storage.persisted();
   }
   const message = isPersistedStorage
-    ? `🔰 Storage is persistent.`
-    : `⚠️ Storage is non-persitent.`;
+    ? `🔰 storage is persistent`
+    : `⚠️ storage is non-persitent`;
 
   console.log(message);
 
@@ -45,22 +49,19 @@ type BackendProviderContextType = {
   cozoDbRemote: Remote<CozoDbWorker> | null;
   senseApi: SenseApi;
   ipfsApi: Remote<BackgroundWorker['ipfsApi']> | null;
-  defferedDbApi: Remote<BackgroundWorker['defferedDbApi']> | null;
   dbApi: DbApiWrapper | null;
-  ipfsNode?: Remote<CybIpfsNode> | null;
   ipfsError?: string | null;
-  loadIpfs?: () => Promise<void>;
-  restartSync?: (name: SyncEntryName) => void;
   isIpfsInitialized: boolean;
   isDbInitialized: boolean;
   isSyncInitialized: boolean;
   isReady: boolean;
+  embeddingApi$: Promise<Observable<EmbeddingApi>>;
+  rune: Remote<RuneEngine>;
 };
 
 const valueContext = {
   cozoDbRemote: null,
   senseApi: null,
-  defferedDbApi: null,
   isIpfsInitialized: false,
   isDbInitialized: false,
   isSyncInitialized: false,
@@ -80,9 +81,6 @@ window.cyb.db = {
   clear: () => indexedDB.deleteDatabase(DB_NAME),
 };
 
-// const dbApi = new DbApiWrapper();
-const bcSender = new BroadcastChannelSender();
-
 function BackendProvider({ children }: { children: React.ReactNode }) {
   const dispatch = useAppDispatch();
   // const { defaultAccount } = useAppSelector((state) => state.pocket);
@@ -111,6 +109,47 @@ function BackendProvider({ children }: { children: React.ReactNode }) {
   }, [friends, following]);
 
   const isReady = isDbInitialized && isIpfsInitialized && isSyncInitialized;
+  const [embeddingApi$, setEmbeddingApi] =
+    useState<Option<Observable<EmbeddingApi>>>(undefined);
+  // const embeddingApiRef = useRef<Observable<EmbeddingApi>>();
+  useEffect(() => {
+    console.log(
+      process.env.IS_DEV
+        ? '🧪 Starting backend in DEV mode...'
+        : '🧬 Starting backend in PROD mode...'
+    );
+
+    (async () => {
+      // embeddingApiRef.current = await backgroundWorkerInstance.embeddingApi$;
+      const embeddingApiInstance$ =
+        await backgroundWorkerInstance.embeddingApi$;
+      setEmbeddingApi(embeddingApiInstance$);
+    })();
+
+    setupStoragePersistence();
+
+    const channel = new RxBroadcastChannelListener(dispatch);
+
+    backgroundWorkerInstance.ipfsApi
+      .start(getIpfsOpts())
+      .then(() => {
+        setIpfsError(null);
+      })
+      .catch((err) => {
+        setIpfsError(err);
+        console.log(`☠️ Ipfs error: ${err}`);
+      });
+
+    cozoDbWorkerInstance.init().then(() => {
+      // const dbApi = createDbApi();
+      const dbApi = new DbApiWrapper();
+
+      dbApi.init(proxy(cozoDbWorkerInstance));
+      setDbApi(dbApi);
+      // pass dbApi into background worker
+      return backgroundWorkerInstance.injectDb(proxy(dbApi));
+    });
+  }, []);
 
   useEffect(() => {
     backgroundWorkerInstance.setParams({ myAddress });
@@ -118,7 +157,7 @@ function BackendProvider({ children }: { children: React.ReactNode }) {
   }, [myAddress, dispatch]);
 
   useEffect(() => {
-    isReady && console.log('🟢 Backend started.');
+    isReady && console.log('🟢 backend started!');
   }, [isReady]);
 
   const [dbApi, setDbApi] = useState<DbApiWrapper | null>(null);
@@ -130,118 +169,31 @@ function BackendProvider({ children }: { children: React.ReactNode }) {
     return null;
   }, [isDbInitialized, dbApi, myAddress, followings]);
 
-  const createDbApi = useCallback(() => {
-    const dbApi = new DbApiWrapper();
-
-    dbApi.init(proxy(cozoDbWorkerInstance));
-    setDbApi(dbApi);
-    return dbApi;
-  }, []);
-
-  const loadIpfs = async () => {
-    const ipfsOpts = getIpfsOpts();
-    await backgroundWorkerInstance.ipfsApi.stop();
-    console.time('🔋 Ipfs started.');
-
-    await backgroundWorkerInstance.ipfsApi
-      .start(ipfsOpts)
-      .then(() => {
-        setIpfsError(null);
-        console.timeEnd('🔋 Ipfs started.');
-      })
-      .catch((err) => {
-        setIpfsError(err);
-        console.log(`☠️ Ipfs error: ${err}`);
-      });
-  };
-
   useEffect(() => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    // const channel = new BroadcastChannelListener((msg) => {
-    // console.log('--------msg.data', msg.data);
-    //   dispatch(msg.data);
-    // });
-    const channel = new RxBroadcastChannelListener(dispatch);
-
-    const loadCozoDb = async () => {
-      console.time('🔋 CozoDb worker started.');
-      await cozoDbWorkerInstance
-        .init()
-        .then(async () => {
-          const dbApi = createDbApi();
-          // pass dbApi into background worker
-          await backgroundWorkerInstance.init(proxy(dbApi));
-        })
-        .then(() => console.timeEnd('🔋 CozoDb worker started.'));
-    };
-
     (async () => {
-      console.log(
-        process.env.IS_DEV
-          ? '🧪 Starting backend in DEV mode...'
-          : '🧬 Starting backend in PROD mode...'
-      );
-      await setupStoragePersistence();
-
-      const ipfsLoadPromise = async () => {
-        const isInitialized = await backgroundWorkerInstance.isInitialized();
-        if (isInitialized) {
-          console.log('🔋 Background worker already active.');
-          bcSender.postServiceStatus('ipfs', 'started');
-          bcSender.postServiceStatus('sync', 'started');
-          return Promise.resolve();
-        }
-        return loadIpfs();
-      };
-
-      const cozoDbLoadPromise = async () => {
-        const isInitialized = await cozoDbWorkerInstance.isInitialized();
-        if (isInitialized) {
-          console.log('🔋 CozoDb worker already active.');
-          bcSender.postServiceStatus('db', 'started');
-          createDbApi();
-          return Promise.resolve();
-        }
-        return loadCozoDb();
-      };
-
-      // Loading non-blocking, when ready  state.backend.services.* should be changef
-      Promise.all([ipfsLoadPromise(), cozoDbLoadPromise()]);
+      backgroundWorkerInstance.setRuneDeps({
+        address: myAddress,
+        // TODO: proxify particular methods
+        // senseApi: senseApi ? proxy(senseApi) : undefined,
+        // signingClient: signingClient ? proxy(signingClient) : undefined,
+      });
     })();
-
-    window.q = backgroundWorkerInstance.ipfsQueue;
-    return () => channel.close();
-  }, [dispatch, createDbApi]);
+  }, [myAddress]);
 
   const ipfsApi = useMemo(
     () => (isIpfsInitialized ? backgroundWorkerInstance.ipfsApi : null),
     [isIpfsInitialized]
   );
 
-  const ipfsNode = useMemo(
-    () =>
-      isIpfsInitialized ? backgroundWorkerInstance.ipfsApi.getIpfsNode() : null,
-    [isIpfsInitialized]
-  );
-
-  const defferedDbApi = useMemo(
-    () => (isDbInitialized ? backgroundWorkerInstance.defferedDbApi : null),
-    [isDbInitialized]
-  );
-
   const valueMemo = useMemo(
     () =>
       ({
-        // backgroundWorker: backgroundWorkerInstance,
+        rune: backgroundWorkerInstance.rune,
+        embeddingApi$: backgroundWorkerInstance.embeddingApi$,
         cozoDbRemote: cozoDbWorkerInstance,
         ipfsApi,
-        defferedDbApi,
-        ipfsNode,
-        restartSync: (name: SyncEntryName) =>
-          backgroundWorkerInstance.restartSync(name),
         dbApi,
         senseApi,
-        loadIpfs,
         ipfsError,
         isIpfsInitialized,
         isDbInitialized,
@@ -256,6 +208,7 @@ function BackendProvider({ children }: { children: React.ReactNode }) {
       ipfsError,
       senseApi,
       dbApi,
+      ipfsApi,
     ]
   );
 
diff --git a/src/contexts/backend/services/senseApi.ts b/src/contexts/backend/services/senseApi.ts
index 33c40fcde..aafc11d26 100644
--- a/src/contexts/backend/services/senseApi.ts
+++ b/src/contexts/backend/services/senseApi.ts
@@ -194,7 +194,7 @@ export const createSenseApi = (
     await dbApi.putSyncStatus(newItem);
     new BroadcastChannelSender().postSenseUpdate([newItem]);
   },
-  putCyberlinsks: (links: LinkDto | LinkDto[]) => dbApi.putCyberlinks(links),
+  putCyberlink: (links: LinkDto | LinkDto[]) => dbApi.putCyberlinks(links),
   getTransactions: (neuron: NeuronAddress) => dbApi.getTransactions(neuron),
   getFriendItems: async (userAddress: NeuronAddress) => {
     if (!myAddress) {
diff --git a/src/contexts/scripting/scripting.tsx b/src/contexts/scripting/scripting.tsx
new file mode 100644
index 000000000..418093e7f
--- /dev/null
+++ b/src/contexts/scripting/scripting.tsx
@@ -0,0 +1,135 @@
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import { UserContext } from 'src/services/scripting/types';
+import { Remote, proxy } from 'comlink';
+import { useAppDispatch, useAppSelector } from 'src/redux/hooks';
+import {
+  selectRuneEntypoints,
+  setEntrypoint,
+} from 'src/redux/reducers/scripting';
+import { selectCurrentPassport } from 'src/features/passport/passports.redux';
+import { RuneEngine } from 'src/services/scripting/engine';
+import { Option } from 'src/types';
+import { EmbeddingApi } from 'src/services/backend/workers/background/api/mlApi';
+import { useBackend } from '../backend/backend';
+
+type RuneFrontend = Omit<RuneEngine, 'isSoulInitialized$'>;
+
+type ScriptingContextType = {
+  isSoulInitialized: boolean;
+  rune: Option<Remote<RuneFrontend>>;
+  embeddingApi: Option<EmbeddingApi>;
+};
+
+const ScriptingContext = React.createContext<ScriptingContextType>({
+  isSoulInitialized: false,
+  rune: undefined,
+  embeddingApi: undefined,
+});
+
+export function useScripting() {
+  return React.useContext(ScriptingContext);
+}
+
+function ScriptingProvider({ children }: { children: React.ReactNode }) {
+  const {
+    rune: runeBackend,
+    ipfsApi,
+    isIpfsInitialized,
+    embeddingApi$,
+  } = useBackend();
+
+  const [isSoulInitialized, setIsSoulInitialized] = useState(false);
+  const runeRef = useRef<Option<Remote<RuneFrontend>>>();
+  const embeddingApiRef = useRef<Option<Remote<EmbeddingApi>>>();
+
+  const dispatch = useAppDispatch();
+
+  useEffect(() => {
+    const setupObservervable = async () => {
+      const { isSoulInitialized$ } = runeBackend;
+
+      const soulSubscription = (await isSoulInitialized$).subscribe((v) => {
+        setIsSoulInitialized(!!v);
+        if (v) {
+          runeRef.current = runeBackend;
+          console.log('👻 soul initalized');
+        }
+      });
+
+      const embeddingApiSubscription = (await embeddingApi$).subscribe(
+        proxy((embeddingApi) => {
+          if (embeddingApi) {
+            embeddingApiRef.current = embeddingApi;
+            console.log('+ embedding api initalized', embeddingApi);
+          }
+        })
+      );
+
+      return () => {
+        soulSubscription.unsubscribe();
+        embeddingApiSubscription.unsubscribe();
+      };
+    };
+
+    setupObservervable();
+  }, []);
+
+  const runeEntryPoints = useAppSelector(selectRuneEntypoints);
+
+  const citizenship = useAppSelector(selectCurrentPassport);
+
+  useEffect(() => {
+    (async () => {
+      if (citizenship) {
+        const particleCid = citizenship.extension.particle;
+
+        await runeBackend.pushContext('user', {
+          address: citizenship.owner,
+          nickname: citizenship.extension.nickname,
+          citizenship,
+          particle: particleCid,
+        } as UserContext);
+      } else {
+        await runeBackend.popContext(['user', 'secrets']);
+      }
+    })();
+  }, [citizenship, runeBackend]);
+
+  useEffect(() => {
+    (async () => {
+      if (citizenship && ipfsApi) {
+        const particleCid = citizenship.extension.particle;
+
+        if (particleCid && isIpfsInitialized) {
+          (async () => {
+            const result = await ipfsApi.fetchWithDetails(particleCid, 'text');
+
+            dispatch(
+              setEntrypoint({ name: 'particle', code: result?.content || '' })
+            );
+          })();
+        }
+      }
+    })();
+  }, [citizenship, isIpfsInitialized, ipfsApi, dispatch]);
+
+  useEffect(() => {
+    runeBackend.setEntrypoints(runeEntryPoints);
+  }, [runeEntryPoints, runeBackend]);
+
+  const value = useMemo(() => {
+    return {
+      rune: runeRef.current,
+      embeddingApi: embeddingApiRef.current,
+      isSoulInitialized,
+    };
+  }, [isSoulInitialized]);
+
+  return (
+    <ScriptingContext.Provider value={value}>
+      {children}
+    </ScriptingContext.Provider>
+  );
+}
+
+export default ScriptingProvider;
diff --git a/src/contexts/signerClient.tsx b/src/contexts/signerClient.tsx
index 7cd4b18e9..7d4eca748 100644
--- a/src/contexts/signerClient.tsx
+++ b/src/contexts/signerClient.tsx
@@ -16,6 +16,7 @@ import { addAddressPocket, setDefaultAccount } from 'src/redux/features/pocket';
 import { accountsKeplr } from 'src/utils/utils';
 import usePrevious from 'src/hooks/usePrevious';
 import { RPC_URL, BECH32_PREFIX, CHAIN_ID } from 'src/constants/config';
+
 // TODO: interface for keplr and OfflineSigner
 // type SignerType = OfflineSigner & {
 //   keplr: Keplr;
diff --git a/src/features/ipfs/Drive/BackendStatus.tsx b/src/features/ipfs/Drive/BackendStatus.tsx
index 8679c72ad..d2f155340 100644
--- a/src/features/ipfs/Drive/BackendStatus.tsx
+++ b/src/features/ipfs/Drive/BackendStatus.tsx
@@ -6,7 +6,7 @@ import Display from 'src/components/containerGradient/Display/Display';
 // import { ServiceStatus, SyncEntryStatus } from 'src/services/backend/types';
 import {
   ProgressTracking,
-  ServiceStatus,
+  ServiceStatus as ServiceStatusInfo,
   SyncEntryName,
   SyncProgress,
 } from 'src/services/backend/types/services';
@@ -16,6 +16,10 @@ import styles from './drive.scss';
 import { syncEntryNameToReadable } from 'src/services/backend/services/sync/utils';
 import { Button } from 'src/components';
 import { downloadJson } from 'src/utils/json';
+import { useBackend } from 'src/contexts/backend/backend';
+import { EmbeddinsDbEntity } from 'src/services/CozoDb/types/entities';
+import { isObject } from 'lodash';
+import { promptToOpenAI } from 'src/services/scripting/services/llmRequests/openai';
 
 const getProgressTrackingInfo = (progress?: ProgressTracking) => {
   if (!progress) {
@@ -29,13 +33,13 @@ const getProgressTrackingInfo = (progress?: ProgressTracking) => {
   )}% (${estimatedTimeStr})`;
 };
 
-function ServiceStatus({
+function ServiceStatusInfo({
   name,
   status,
   message,
 }: {
   name: string;
-  status: ServiceStatus;
+  status: ServiceStatusInfo;
   message?: string;
 }) {
   const icon = status === 'error' ? '❌' : status === 'starting' ? '⏳' : '';
@@ -52,12 +56,18 @@ function EntrySatus({
 }) {
   const msg = progress.error || progress.message ? `- ${progress.message}` : '';
   const text = `${syncEntryNameToReadable(name)}: ${progress.status} ${msg}
-  ${getProgressTrackingInfo(progress.progress)}`;
+  ${
+    !isObject(progress.progress)
+      ? progress.progress
+        ? `(${progress.progress}%)`
+        : ''
+      : getProgressTrackingInfo(progress.progress)
+  }`;
   return <div className={styles.tabbed}>{text}</div>;
 }
 
 function BackendStatus() {
-  const { syncState, dbPendingWrites, services } = useAppSelector(
+  const { syncState, dbPendingWrites, services, mlState } = useAppSelector(
     (store) => store.backend
   );
 
@@ -70,17 +80,35 @@ function BackendStatus() {
     <Display color={Colors.GREEN}>
       <div className={styles.list}>
         <h3>Backend status</h3>
-        <ServiceStatus
+        <ServiceStatusInfo
           name="db"
           status={services.db.status}
           message={services.db.error || `(queries: ${dbPendingWrites})`}
         />
-        <ServiceStatus
+        <ServiceStatusInfo
           name="ipfs"
           status={services.ipfs.status}
           message={services.ipfs.error || services.ipfs.message}
         />
-        <ServiceStatus
+        <ServiceStatusInfo
+          name="rune"
+          status={services.rune.status}
+          message={services.rune.error || services.rune.message}
+        />
+        <ServiceStatusInfo
+          name="ml"
+          status={services.sync.status}
+          message={services.sync.error || services.sync.message}
+        />
+
+        {Object.keys(mlState.entryStatus).map((name) => (
+          <EntrySatus
+            key={`ml_log_${name}`}
+            name={name}
+            progress={mlState.entryStatus[name]}
+          />
+        ))}
+        <ServiceStatusInfo
           name="sync"
           status={services.sync.status}
           message={services.sync.error || services.sync.message}
diff --git a/src/features/ipfs/Drive/cozo_presets.json b/src/features/ipfs/Drive/cozo_presets.json
index ac1d096d7..5d2c4061c 100644
--- a/src/features/ipfs/Drive/cozo_presets.json
+++ b/src/features/ipfs/Drive/cozo_presets.json
@@ -53,6 +53,7 @@
   ],
   "[sys]config": "?[key, group_key, value] := *config{key, group_key, value}",
   "[sys] sync queue": [
-    "?[id, status, priority] := *sync_queue{id, status, priority}"
+    "?[id, status, job_type, data, priority] := *sync_queue{id, status, priority, job_type, data}",
+    ":order status, -priority"
   ]
 }
diff --git a/src/features/ipfs/Drive/drive.scss b/src/features/ipfs/Drive/drive.scss
index c0bd81db1..ef56e0958 100644
--- a/src/features/ipfs/Drive/drive.scss
+++ b/src/features/ipfs/Drive/drive.scss
@@ -79,3 +79,11 @@ h3 {
   // justify-content: center;
   display: flex;
 }
+
+.centerPanel {
+  padding: 16px;
+  // justify-content: center;
+  align-items: center;
+  display: flex;
+  flex-direction: column;
+}
diff --git a/src/features/ipfs/Drive/index.tsx b/src/features/ipfs/Drive/index.tsx
index eb0e3238b..10e9fa69a 100644
--- a/src/features/ipfs/Drive/index.tsx
+++ b/src/features/ipfs/Drive/index.tsx
@@ -6,7 +6,14 @@ import { toListOfObjects } from 'src/services/CozoDb/utils';
 import { saveAs } from 'file-saver';
 
 import { Pane, Text } from '@cybercongress/gravity';
-import { Button as CybButton, Dots, Loading, Select } from 'src/components';
+import {
+  Button,
+  Button as CybButton,
+  Dots,
+  Input,
+  Loading,
+  Select,
+} from 'src/components';
 import FileInputButton from './FileInputButton';
 import { useAppSelector } from 'src/redux/hooks';
 import Display from 'src/components/containerGradient/Display/Display';
@@ -20,6 +27,9 @@ import BackendStatus from './BackendStatus';
 import cozoPresets from './cozo_presets.json';
 
 import styles from './drive.scss';
+import { EmbeddinsDbEntity } from 'src/services/CozoDb/types/entities';
+import useEmbeddingApi from 'src/hooks/useEmbeddingApi';
+import { useScripting } from 'src/contexts/scripting/scripting';
 
 const DEFAULT_PRESET_NAME = '💡 defaul commands...';
 
@@ -38,12 +48,17 @@ function Drive() {
   const [isLoaded, setIsLoaded] = useState(true);
   const [inProgress, setInProgress] = useState(false);
   const [statusMessage, setStatusMessage] = useState('');
+  const [searchEmbedding, setSearchEmbedding] = useState('');
+  // const [summarizeCid, setSummarizeCid] = useState('');
+  const [outputText, setOutputText] = useState('');
+  // const [questionText, setQuestionText] = useState('');
+  const [embeddingsProcessStatus, setEmbeddingsProcessStatus] = useState('');
+
   const [errorMessage, setErrorMessage] = useState<string | undefined>();
   const [queryResults, setQueryResults] = useState<{ rows: []; cols: [] }>();
-  const { cozoDbRemote, isReady } = useBackend();
-  const { syncState, dbPendingWrites, services } = useAppSelector(
-    (store) => store.backend
-  );
+  const { cozoDbRemote, isReady, ipfsApi } = useBackend();
+  const { embeddingApi } = useScripting();
+  // const embeddingApi = useEmbeddingApi();
 
   // console.log('-----syncStatus', syncState, dbPendingWrites);
 
@@ -140,7 +155,7 @@ function Drive() {
       });
       saveAs(blob, 'export.json');
     } catch (e) {
-      console.log('CozoDb: Failed to import', e);
+      console.log('cozoDb: Failed to import', e);
     }
   };
 
@@ -156,6 +171,77 @@ function Drive() {
     runQuery(value);
   };
 
+  // const createParticleEmbeddingsClick = async () => {
+  //   const data = await cozoDbRemote?.runCommand(
+  //     '?[cid, text] := *particle{cid, mime, text, blocks, size, size_local, type}, mime="text/plain"',
+  //     true
+  //   );
+
+  //   let index = 0;
+  //   const totalItems = data!.rows.length;
+  //   setEmbeddingsProcessStatus(`Starting... Total particles (0/${totalItems})`);
+
+  //   // eslint-disable-next-line no-restricted-syntax
+  //   for await (const row of data!.rows) {
+  //     const [cid, text] = row;
+  //     const vec = await mlApi?.createEmbedding(text as string);
+  //     const res = await cozoDbRemote?.executePutCommand('embeddings', [
+  //       {
+  //         cid,
+  //         vec,
+  //       } as EmbeddinsDbEntity,
+  //     ]);
+  //     index++;
+  //     setEmbeddingsProcessStatus(
+  //       `Processing particles (${index}/${totalItems})....`
+  //     );
+  //   }
+  //   setEmbeddingsProcessStatus(
+  //     `Embeddings complete for (0/${totalItems}) particles!`
+  //   );
+  // };
+
+  const searchByEmbeddingsClick = async () => {
+    const vec = await embeddingApi?.createEmbedding(searchEmbedding);
+    const queryText = `
+    e[dist, cid] := ~embeddings:semantic{cid | query: vec([${vec}]), bind_distance: dist, k: 20, ef: 50}
+    ?[dist, cid, text] := e[dist, cid], *particle{cid, text}
+    `;
+    setQueryText(queryText);
+    runQuery(queryText);
+  };
+
+  // const summarizeClick = async () => {
+  //   const text = (await ipfsApi!.fetchWithDetails(summarizeCid, 'text'))
+  //     ?.content;
+  //   const output = await mlApi?.getSummary(text!);
+  //   setOutputText(output);
+
+  // };
+
+  // const questionClick = async () => {
+  //   const text = (await ipfsApi!.fetchWithDetails(summarizeCid, 'text'))
+  //     ?.content;
+  //   const output = await mlApi?.getQA(questionText, text!);
+  //   setOutputText(output);
+
+  // };
+
+  function onSearchEmbeddingChange(event: React.ChangeEvent<HTMLInputElement>) {
+    const { value } = event.target;
+    setSearchEmbedding(value);
+  }
+
+  // function onSummarizeCidChange(event: React.ChangeEvent<HTMLInputElement>) {
+  //   const { value } = event.target;
+  //   setSummarizeCid(value);
+  // }
+
+  // function onQuestionChange(event: React.ChangeEvent<HTMLInputElement>) {
+  //   const { value } = event.target;
+  //   setQuestionText(value);
+  // }
+
   return (
     <>
       <div className={styles.main}>
@@ -186,7 +272,46 @@ function Drive() {
           </p>
         </Display>
         <BackendStatus />
+        <Pane width="100%">
+          {/* <div className={styles.centerPanel}>
+            <Button small onClick={createParticleEmbeddingsClick}>
+              🤖 create particle embeddings
+            </Button>
+            <div>{embeddingsProcessStatus}</div>
+          </div>
 
+          <div className={styles.buttonPanel}>
+            <Input
+              value={summarizeCid}
+              onChange={(e) => onSummarizeCidChange(e)}
+              placeholder="enter cid:<tokens>"
+            />
+            <Button small onClick={summarizeClick}>
+              🔖 Summarize CID content
+            </Button>
+          </div>
+          <div className={styles.buttonPanel}>
+            <Input
+              value={questionText}
+              onChange={(e) => onQuestionChange(e)}
+              placeholder="enter question..."
+            />
+            <Button small onClick={questionClick}>
+              🔮 Ask question about CID content
+            </Button>
+          </div> */}
+          <div>{outputText}</div>
+          <div className={styles.buttonPanel}>
+            <Input
+              value={searchEmbedding}
+              onChange={(e) => onSearchEmbeddingChange(e)}
+              placeholder="enter sentence...."
+            />
+            <Button small onClick={searchByEmbeddingsClick}>
+              🧬 Search by embedding
+            </Button>
+          </div>
+        </Pane>
         <Pane width="100%">
           <textarea
             placeholder="Enter your query here..."
diff --git a/src/features/ipfs/ipfsSettings/index.tsx b/src/features/ipfs/ipfsSettings/index.tsx
index 4afcc1341..3a29399ae 100644
--- a/src/features/ipfs/ipfsSettings/index.tsx
+++ b/src/features/ipfs/ipfsSettings/index.tsx
@@ -1,10 +1,5 @@
 import { useCallback, useEffect, useState } from 'react';
-import {
-  Input,
-  Button,
-  Display,
-  DisplayTitle,
-} from 'src/components';
+import { Input, Button, Display, DisplayTitle } from 'src/components';
 import { Pane } from '@cybercongress/gravity';
 
 import { useAdviser } from 'src/features/adviser/context';
@@ -24,6 +19,7 @@ import ComponentLoader from './ipfsComponents/ipfsLoader';
 import Drive from '../Drive';
 import { useBackend } from 'src/contexts/backend/backend';
 import { IPFSNodes } from 'src/services/ipfs/types';
+import { getIpfsOpts } from 'src/services/ipfs/config';
 
 const dataOpts = [IPFSNodes.EXTERNAL, IPFSNodes.EMBEDDED, IPFSNodes.HELIA];
 
@@ -31,7 +27,7 @@ function IpfsSettings() {
   const [valueSelect, setValueSelect] = useState(IPFSNodes.HELIA);
   const [valueInput, setValueInput] = useState('');
   const [valueInputGateway, setValueInputGateway] = useState('');
-  const { isIpfsInitialized, ipfsError: failed, loadIpfs } = useBackend();
+  const { isIpfsInitialized, ipfsError: failed, ipfsApi } = useBackend();
 
   useEffect(() => {
     const lsTypeIpfs = localStorage.getItem('ipfsState');
@@ -80,7 +76,10 @@ function IpfsSettings() {
   }, [valueInputGateway]);
 
   const onClickReConnect = () => {
-    loadIpfs();
+    ipfsApi
+      ?.stop()
+      .then(() => ipfsApi?.start(getIpfsOpts()))
+      .then();
   };
 
   const stateProps = {
diff --git a/src/features/ipfs/ipfsSettings/ipfsComponents/infoIpfsNode.tsx b/src/features/ipfs/ipfsSettings/ipfsComponents/infoIpfsNode.tsx
index 85b406b1d..b92ccca39 100644
--- a/src/features/ipfs/ipfsSettings/ipfsComponents/infoIpfsNode.tsx
+++ b/src/features/ipfs/ipfsSettings/ipfsComponents/infoIpfsNode.tsx
@@ -24,7 +24,7 @@ const PREFIXES = [
 ];
 
 export function useGetIpfsInfo() {
-  const { isIpfsInitialized, ipfsApi, ipfsNode } = useBackend();
+  const { isIpfsInitialized, ipfsApi } = useBackend();
   const [repoSizeValue, setRepoSizeValue] = useState<number | string>(0);
   const [idIpfs, setIdIpfs] = useState({ id: '', agentVersion: '' });
   const [loading, setLoading] = useState(true);
@@ -33,8 +33,6 @@ export function useGetIpfsInfo() {
     (async () => {
       setLoading(true);
       if (isIpfsInitialized) {
-        // console.log('-----uu', ipfsNode, ipfsApi.info, await ipfsApi.info());
-
         const { id, agentVersion, repoSize } = await ipfsApi.info();
         setIdIpfs({ id, agentVersion });
         const repoSizeString =
diff --git a/src/features/passport/passports.redux.ts b/src/features/passport/passports.redux.ts
index f31c40b2b..e17f8d16d 100644
--- a/src/features/passport/passports.redux.ts
+++ b/src/features/passport/passports.redux.ts
@@ -201,7 +201,7 @@ export const selectAccountsPassports = createSelector(
 export const selectCurrentPassport = createSelector(
   selectCurrentAddress,
   (state: RootState) => state.passports,
-  (address, passports) => (address ? passports[address] : undefined)
+  (address, passports) => (address ? passports[address]?.data : undefined)
 );
 
 export const { deleteAddress, addAddress } = slice.actions;
diff --git a/src/hooks/useParticle.ts b/src/hooks/useParticle.ts
new file mode 100644
index 000000000..4e2b23661
--- /dev/null
+++ b/src/hooks/useParticle.ts
@@ -0,0 +1,68 @@
+import { useEffect, useState } from 'react';
+import { useBackend } from 'src/contexts/backend/backend';
+import useQueueIpfsContent from './useQueueIpfsContent';
+import {
+  IPFSContentDetails,
+  IPFSContentDetailsMutated,
+} from 'src/services/ipfs/types';
+import { ParticleCid } from 'src/types/base';
+import { parseArrayLikeToDetails } from 'src/services/ipfs/utils/content';
+import { QueueItemStatus } from 'src/services/QueueManager/types';
+import { Option } from 'src/types';
+import useRuneMutation from './useRuneMutation';
+
+const useParticle = (
+  cid: ParticleCid,
+  parentId: Option<string> = undefined,
+  rank: Option<number> = undefined
+) => {
+  const {
+    fetchParticle,
+    status: queueItemStatus,
+    content,
+  } = useQueueIpfsContent(parentId);
+  const [details, setDetails] = useState<
+    IPFSContentDetails | IPFSContentDetailsMutated
+  >();
+  const [status, setStatus] = useState<QueueItemStatus>('pending');
+  const [hidden, setHidden] = useState(false);
+  const [mutated, setMutated] = useState(false);
+  const { state, mutatedDetails } = useRuneMutation(cid, details);
+  useEffect(() => {
+    if (cid && fetchParticle) {
+      setStatus('pending');
+      setDetails(undefined);
+      setMutated(false);
+      fetchParticle(cid, rank);
+    }
+  }, [cid, fetchParticle, rank]);
+
+  useEffect(() => {
+    if (queueItemStatus === 'completed') {
+      parseArrayLikeToDetails(
+        content,
+        cid
+        // (progress: number) => console.log(`${cid} progress: ${progress}`)
+      ).then((details) => {
+        setDetails(details);
+        setStatus('completed');
+      });
+    } else {
+      setStatus(queueItemStatus);
+    }
+  }, [content, queueItemStatus, cid]);
+
+  useEffect(() => {
+    if (state === 'done') {
+      const hiddenByRune =
+        !!mutatedDetails?.mutation && mutatedDetails.mutation === 'hidden';
+      setHidden(hiddenByRune);
+      setDetails(mutatedDetails);
+      setMutated(true);
+    }
+  }, [state, mutatedDetails]);
+
+  return { status, details, hidden, content, mutated };
+};
+
+export default useParticle;
diff --git a/src/hooks/useQueueIpfsContent.ts b/src/hooks/useQueueIpfsContent.ts
index 37ccdfbfa..d65250e25 100644
--- a/src/hooks/useQueueIpfsContent.ts
+++ b/src/hooks/useQueueIpfsContent.ts
@@ -1,7 +1,6 @@
-import { useEffect, useRef, useState, useCallback, useMemo } from 'react';
+import { useEffect, useRef, useState, useCallback } from 'react';
 import {
   FetchParticleAsync,
-  QueueItemAsyncResult,
   QueueItemOptions,
   QueueItemStatus,
   QueuePriority,
@@ -9,17 +8,18 @@ import {
 
 import {
   FetchWithDetailsFunc,
-  IPFSContentMaybe,
+  IPFSContent,
   IpfsContentSource,
 } from 'src/services/ipfs/types';
 import { useBackend } from 'src/contexts/backend/backend';
 import { proxy } from 'comlink';
+import { Option } from 'src/types';
 
 type UseIpfsContentReturn = {
   isReady: boolean;
-  status?: QueueItemStatus;
+  status: QueueItemStatus;
   source?: IpfsContentSource;
-  content: IPFSContentMaybe;
+  content: Option<IPFSContent>;
   clear?: () => Promise<void>;
   cancel?: (cid: string) => Promise<void>;
   fetchParticle?: (cid: string, rank?: number) => Promise<void>;
@@ -30,7 +30,7 @@ type UseIpfsContentReturn = {
 function useQueueIpfsContent(parentId?: string): UseIpfsContentReturn {
   const [status, setStatus] = useState<QueueItemStatus>();
   const [source, setSource] = useState<IpfsContentSource | undefined>();
-  const [content, setContent] = useState<IPFSContentMaybe>();
+  const [content, setContent] = useState<Option<IPFSContent>>();
   const prevParentIdRef = useRef<string | undefined>();
 
   const {
@@ -49,7 +49,7 @@ function useQueueIpfsContent(parentId?: string): UseIpfsContentReturn {
         cid: string,
         status: QueueItemStatus,
         source: IpfsContentSource,
-        result: IPFSContentMaybe
+        result: Option<IPFSContent>
       ) => {
         setStatus(status);
         setSource(source);
diff --git a/src/hooks/useRuneMutation.ts b/src/hooks/useRuneMutation.ts
new file mode 100644
index 000000000..91dd78291
--- /dev/null
+++ b/src/hooks/useRuneMutation.ts
@@ -0,0 +1,39 @@
+import { useEffect, useState } from 'react';
+import { useBackend } from 'src/contexts/backend/backend';
+import { useScripting } from 'src/contexts/scripting/scripting';
+import {
+  IPFSContentDetails,
+  IPFSContentDetailsMutated,
+} from 'src/services/ipfs/types';
+import { postProcessIpfContent } from 'src/services/scripting/services/postProcessing';
+import { ParticleCid } from 'src/types/base';
+
+export type RuneState = 'loading' | 'processing' | 'done';
+
+const useRuneMutation = (
+  cid: ParticleCid,
+  details?: IPFSContentDetails,
+  skip = false
+) => {
+  const { ipfsApi } = useBackend();
+  const { rune, isSoulInitialized } = useScripting();
+  const [mutatedDetails, setMutatedDetails] = useState<
+    IPFSContentDetailsMutated | undefined
+  >(details);
+  const [state, setState] = useState<RuneState>(skip ? 'done' : 'loading');
+
+  useEffect(() => {
+    if (isSoulInitialized && details && state === 'loading') {
+      setState('processing');
+
+      postProcessIpfContent(cid, details, rune, ipfsApi).then((result) => {
+        setMutatedDetails(result);
+        setState('done');
+      });
+    }
+  }, [isSoulInitialized, state, details, cid, rune, ipfsApi]);
+
+  return { state, mutatedDetails };
+};
+
+export default useRuneMutation;
diff --git a/src/index.tsx b/src/index.tsx
index 72d69b087..7e92bd538 100644
--- a/src/index.tsx
+++ b/src/index.tsx
@@ -45,6 +45,7 @@ import AdviserProvider from './features/adviser/context';
 import HubProvider from './contexts/hub';
 
 import { INDEX_HTTPS, INDEX_WEBSOCKET } from './constants/config';
+import ScriptingProvider from './contexts/scripting/scripting';
 
 const httpLink = new HttpLink({
   uri: INDEX_HTTPS,
@@ -112,12 +113,14 @@ export function Providers({ children }: { children: React.ReactNode }) {
                     <DataProvider>
                       <ApolloProvider client={client}>
                         <BackendProvider>
-                          <DeviceProvider>
-                            <AdviserProvider>
-                              {/* <ErrorBoundary>{children}</ErrorBoundary> */}
-                              {children}
-                            </AdviserProvider>
-                          </DeviceProvider>
+                          <ScriptingProvider>
+                            <DeviceProvider>
+                              <AdviserProvider>
+                                {/* <ErrorBoundary>{children}</ErrorBoundary> */}
+                                {children}
+                              </AdviserProvider>
+                            </DeviceProvider>
+                          </ScriptingProvider>
                         </BackendProvider>
                       </ApolloProvider>
                     </DataProvider>
diff --git a/src/pages/oracle/Learn/Learn.tsx b/src/pages/oracle/Learn/Learn.tsx
index fe1f5dc9e..b59d0ffd4 100644
--- a/src/pages/oracle/Learn/Learn.tsx
+++ b/src/pages/oracle/Learn/Learn.tsx
@@ -63,9 +63,9 @@ function Learn() {
 
   const { balacesResource } = useGetSlots(address);
 
-  const passport = useAppSelector(selectCurrentPassport);
+  const citizenship = useAppSelector(selectCurrentPassport);
 
-  const noPassport = CHAIN_ID === Networks.BOSTROM && !passport;
+  const noPassport = CHAIN_ID === Networks.BOSTROM && !citizenship;
 
   const [tx, setTx] = useState({
     hash: '',
diff --git a/src/pages/robot/Layout/RobotMenu/RobotMenu.tsx b/src/pages/robot/Layout/RobotMenu/RobotMenu.tsx
index 42ed6e046..5896a5ae6 100644
--- a/src/pages/robot/Layout/RobotMenu/RobotMenu.tsx
+++ b/src/pages/robot/Layout/RobotMenu/RobotMenu.tsx
@@ -126,7 +126,7 @@ const links: MenuItem[] = [
   {
     text: 'Soul',
     link: './soul',
-    isDisabled: true,
+    // isDisabled: true,
     // description: 'bytes',
     icon: '👻',
   },
diff --git a/src/pages/robot/Robot.tsx b/src/pages/robot/Robot.tsx
index 1b0fcaee9..a6894f98b 100644
--- a/src/pages/robot/Robot.tsx
+++ b/src/pages/robot/Robot.tsx
@@ -15,6 +15,7 @@ import RobotContextProvider, { useRobotContext } from './robot.context';
 import Brain from './Brain/Brain';
 import Karma from './Karma/Karma';
 import SensePage from './SensePage';
+import Soul from './Soul/Soul';
 
 function RobotRoutes() {
   const { isOwner, isLoading, address } = useRobotContext();
@@ -47,7 +48,7 @@ function RobotRoutes() {
         <Route path="swarm" element={<FollowsTab />} />
         <Route path="brain" element={<Brain />} />
         <Route path="karma" element={<Karma />} />
-        <Route path="soul" element={<UnderConstruction />} />
+        <Route path="soul" element={<Soul />} />
 
         <Route path="*" element={<p>Page should not exist</p>} />
       </Route>
diff --git a/src/pages/robot/Soul/ScriptingActionBar/ScriptingActionBar.tsx b/src/pages/robot/Soul/ScriptingActionBar/ScriptingActionBar.tsx
new file mode 100644
index 000000000..b17cc6e7b
--- /dev/null
+++ b/src/pages/robot/Soul/ScriptingActionBar/ScriptingActionBar.tsx
@@ -0,0 +1,136 @@
+import { useState } from 'react';
+// import { getIPFSContent } from 'src/utils/ipfs/utils-ipfs';
+import { isCID } from 'src/utils/ipfs/helpers';
+
+// import { Controlled as CodeMirror } from 'react-codemirror2';
+
+import ActionBarContainer from 'src/components/actionBar';
+import { Button, Input } from 'src/components';
+import { Pane } from '@cybercongress/gravity';
+
+// import { ScriptExecutionResult } from 'src/types/scripting';
+
+import StepsBar from '../StepsBar/StepsBar';
+
+// import { highlightErrors, compileScript } from '../utils';
+
+import styles from '../Soul.module.scss';
+
+import { useBackend } from 'src/contexts/backend/backend';
+
+function ScriptingActionBar({
+  isChanged,
+  nickname,
+  addToLog,
+  onSaveClick,
+  onCancelClick,
+  resetPlayGround,
+  resetToDefault,
+  compileAndTest,
+}: {
+  isChanged: boolean;
+  nickname: string;
+  addToLog: (log: string[]) => void;
+  onSaveClick: () => void;
+  onCancelClick: () => void;
+  resetPlayGround: () => void;
+  resetToDefault: () => void;
+  compileAndTest: (name: string, params?: any) => void;
+}) {
+  const [testCid, seTestCid] = useState('');
+  const { ipfsApi } = useBackend();
+
+  const [actionBarStep, setActionBarStep] = useState(0);
+
+  const onTestMoonDomainClick = async () => {
+    resetPlayGround();
+
+    compileAndTest('moon_domain_resolver');
+    setActionBarStep(0);
+  };
+
+  const onTestClick = async () => {
+    resetPlayGround();
+
+    if (!isCID(testCid)) {
+      addToLog([`🚫 '${testCid}' - is not correct CID.`]);
+      return;
+    }
+    addToLog([
+      '💡 Prepare data....',
+      '',
+      `🚧 Fetching particle '${testCid}'...`,
+    ]);
+
+    const result = await ipfsApi?.fetchWithDetails(testCid);
+    if (result) {
+      const { type, content } = result;
+
+      const preview =
+        content!.length > 144 ? `${content!.slice(1, 144)}....` : content;
+
+      addToLog([
+        `   ☑️ Content-type: ${type}`,
+        `   ☑️ Preview: ${preview}`,
+        '',
+        '💭 Execute script....',
+      ]);
+
+      compileAndTest('personal_processor', [testCid, type, content]);
+    } else {
+      addToLog([`🚫 '${testCid}' - can't resolve.`]);
+    }
+    setActionBarStep(0);
+  };
+
+  const onTestPersonalProcessorClick = () => setActionBarStep(2);
+
+  const onTestStepClick = () => setActionBarStep(1);
+
+  const actionBarSteps = [
+    <div key="step_0" className={styles.stepWraperJustified}>
+      <Button onClick={onTestStepClick}>test cybscript</Button>
+      <div>
+        {isChanged && (
+          <>
+            <Button onClick={onSaveClick}>save</Button>
+            <Button onClick={onSaveClick}>cancel</Button>
+          </>
+        )}
+        {!isChanged && (
+          <Button onClick={resetToDefault}>reset to default</Button>
+        )}
+      </div>
+    </div>,
+    <div key="step_1" className={styles.stepWrapper}>
+      <Button
+        onClick={onTestMoonDomainClick}
+      >{`test ${nickname}.moon resolver`}</Button>
+      <Button onClick={onTestPersonalProcessorClick}>
+        test personal processor
+      </Button>
+    </div>,
+    <div key="step_2" className={styles.stepWrapper}>
+      <Input
+        value={testCid}
+        onChange={(e) => seTestCid(e.target.value)}
+        placeholder="Enter particle CID to apply script...."
+      />
+      <Button onClick={onTestClick}>Test particle processor</Button>
+    </div>,
+  ];
+
+  return (
+    <ActionBarContainer>
+      <Pane className={styles.actionPanel}>
+        <StepsBar
+          steps={actionBarSteps}
+          currentStep={actionBarStep}
+          setCurrentStep={(value) => setActionBarStep(value)}
+        />
+      </Pane>
+    </ActionBarContainer>
+  );
+}
+
+export default ScriptingActionBar;
diff --git a/src/pages/robot/Soul/Soul.module.scss b/src/pages/robot/Soul/Soul.module.scss
new file mode 100644
index 000000000..5aa144257
--- /dev/null
+++ b/src/pages/robot/Soul/Soul.module.scss
@@ -0,0 +1,45 @@
+.actionPanel {
+  display: flex;
+  flex-direction: row;
+  width: 100%;
+  .stepWrapper {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    width: 100%;
+    button {
+      margin-left: 25px;
+    }
+  }
+
+  .stepWraperJustified {
+    @extend .stepWrapper;
+    justify-content: space-between;
+  }
+}
+
+.logArea {
+  margin-top: 20px;
+  padding: 10px;
+  box-shadow: none;
+  border-top: rgb(54, 214, 174) solid 1px;
+  border-radius: 0;
+  font-family: monospace !important;
+  resize: vertical;
+}
+
+.errorHighlight {
+  background: #735603;
+  border-bottom: yellow 2px dotted;
+  padding: 0px 3px;
+}
+
+.tabInner {
+  padding-top: 20px;
+}
+
+.settingsPanel {
+  display: flex;
+  justify-content: flex-end;
+  padding-bottom: 20px;
+}
diff --git a/src/pages/robot/Soul/Soul.tsx b/src/pages/robot/Soul/Soul.tsx
new file mode 100644
index 000000000..35e788cdb
--- /dev/null
+++ b/src/pages/robot/Soul/Soul.tsx
@@ -0,0 +1,308 @@
+import React, {
+  useCallback,
+  useState,
+  useMemo,
+  useRef,
+  useEffect,
+} from 'react';
+
+import { RootState } from 'src/redux/store';
+import { useAppDispatch, useAppSelector } from 'src/redux/hooks';
+
+import { useGetPassportByAddress } from 'src/containers/sigma/hooks';
+import { ContainerGradientText } from 'src/components';
+
+import { useSigningClient } from 'src/contexts/signerClient';
+
+import {
+  setEntrypoint,
+  setEntrypointEnabled,
+} from 'src/redux/reducers/scripting';
+
+import Switch from 'src/components/Switch/Switch';
+
+import { Controlled as CodeMirror } from 'react-codemirror2';
+import { saveStringToLocalStorage } from 'src/utils/localStorage';
+
+import { updatePassportParticle } from 'src/services/neuron/neuronApi';
+
+import ScriptingActionBar from './ScriptingActionBar/ScriptingActionBar';
+
+// import 'codemirror/theme/tomorrow-night-bright.css';
+// import 'codemirror/theme/the-matrix.css';
+
+import { extractRuneContent } from 'src/services/scripting/helpers';
+import { useBackend } from 'src/contexts/backend/backend';
+
+import defaultParticleScript from 'src/services/scripting/rune/default/particle.rn';
+
+// import 'codemirror/mode/rust/rust';
+import './formatting/rune';
+import 'codemirror/lib/codemirror.css';
+import 'codemirror/theme/tomorrow-night-eighties.css';
+
+import './codeMirror.css';
+import styles from './Soul.module.scss';
+
+const defaultBio =
+  'Hello, _##name##_!\r\nYou can fill any info about yourself using **markdown**.';
+
+const entrypointName = 'particle';
+
+const highlightErrors = (
+  codeMirrorRef: React.Ref<CodeMirror>,
+  diagnostics: any[],
+  styles: Record<string, string>
+) => {
+  const cm = codeMirrorRef!.editor;
+
+  cm.getAllMarks().forEach((mark) => mark.clear());
+
+  diagnostics.forEach((error) => {
+    const { start, end } = error;
+    cm.scrollIntoView({ line: start.line, ch: start.character });
+    cm.markText(
+      { line: start.line, ch: start.character },
+      { line: end.line, ch: end.character },
+      {
+        className: styles.errorHighlight,
+        clearOnEnter: true,
+      }
+    );
+  });
+};
+
+function Soul() {
+  const dispatch = useAppDispatch();
+  const { ipfsApi, rune } = useBackend();
+
+  const codeMirrorRef = useRef<CodeMirror>();
+  const outputRef = useRef();
+
+  const { signer, signingClient } = useSigningClient();
+
+  const { [entrypointName]: currentEntrypoint } = useAppSelector(
+    (store: RootState) => store.scripting.scripts.entrypoints
+  );
+
+  const { defaultAccount } = useAppSelector((store: RootState) => store.pocket);
+  const { passport } = useGetPassportByAddress(defaultAccount);
+
+  const [log, setLog] = useState<string[]>([]);
+  const [isChanged, setIsChanged] = useState(false);
+  const [code, setCode] = useState<string>('');
+  // const [bio, setBio] = useState<string>('');
+
+  const [isLoaded, setIsLoaded] = useState(true);
+
+  const addToLog = useCallback(
+    (lines: string[]) => setLog((log) => [...log, ...lines]),
+    []
+  );
+
+  const compileAndTest = async (funcName: string, funcParams = []) => {
+    outputRef.current?.scrollIntoView({ behavior: 'smooth' });
+
+    addToLog([`🚧 Execute your '${funcName}'.`]);
+    rune
+      ?.run(code, {
+        execute: true,
+        funcName,
+        funcParams,
+      })
+      .then((result) => {
+        const isOk = !result.diagnosticsOutput && !result.error;
+        highlightErrors(codeMirrorRef!.current, result.diagnostics, styles);
+        if (!isOk) {
+          console.log('----res', result);
+          addToLog(['⚠️ Errors:', `   ${result.diagnosticsOutput}`]);
+        } else {
+          addToLog([
+            '',
+            '🏁 Result:',
+            '',
+            `   ${JSON.stringify(result.result)}`,
+            '',
+            '🧪 Raw output:',
+            '',
+            result?.output || 'no output.',
+          ]);
+        }
+      });
+  };
+
+  const saveScriptToPassport = async (scriptCode: string) => {
+    addToLog(['⚓️ Saving to IPFS ...']);
+    const cid = await ipfsApi?.addContent(scriptCode);
+    // console.log('saveScriptToPassport', cid, scriptCode);
+    addToLog([`🏁 Saving '${cid}' to passport ...`]);
+    if (cid) {
+      updatePassportParticle(passport?.extension.nickname, cid, {
+        signer,
+        signingClient,
+      })
+        .then((result) => {
+          addToLog(['', `☑️ Saved as particle into your passport.`]);
+        })
+        .catch((error) => {
+          addToLog(['', `🚫 Particle was not saved: ${error}.`]);
+        });
+    }
+  };
+
+  const saveScript = async (script: string) => {
+    try {
+      addToLog(['Saving code...']);
+      setIsLoaded(false);
+
+      // const combinedScript = `${markdown}\r\n\`\`\`rune\r\n${script}\r\n\`\`\``;
+
+      saveStringToLocalStorage(entrypointName, script);
+
+      if (!currentEntrypoint.enabled) {
+        addToLog(['', '☑️ Saved to local storage.']);
+        dispatch(setEntrypoint({ name: entrypointName, code: script }));
+      } else {
+        await saveScriptToPassport(script);
+        dispatch(setEntrypoint({ name: entrypointName, code: script }));
+      }
+    } finally {
+      setIsLoaded(true);
+      setIsChanged(false);
+    }
+  };
+
+  // const saveBio = async (newBio: string) => {
+  //   setBio(newBio);
+  //   await saveScript(code, newBio);
+  // };
+
+  const onResetToDefault = async () => {
+    addToLog(['Resetting to default...']);
+    setIsLoaded(false);
+    setIsChanged(false);
+    setCode(defaultParticleScript);
+    // setBio(defaultBio);
+    await saveScript(defaultParticleScript);
+  };
+
+  useEffect(() => {
+    // resetPlayGround();
+    // const { script, markdown } = extractRuneContent(currentEntrypoint.script);
+    setCode(currentEntrypoint.script || defaultParticleScript);
+    // setBio(markdown);
+  }, [currentEntrypoint]);
+
+  const logText = useMemo(() => log.join('\r\n'), [log]);
+
+  const resetPlayGround = () => setLog([]);
+
+  const onCancelClick = () => {
+    resetPlayGround();
+    setIsChanged(false);
+    setCode(currentEntrypoint.script);
+  };
+
+  const onSaveClick = () => {
+    resetPlayGround();
+    if (!code) {
+      addToLog([`🚫 Can't save empty code`]);
+      return;
+    }
+    rune
+      ?.run(code, {
+        execute: false,
+      })
+      .then((result) => {
+        if (result.diagnosticsOutput || result.error) {
+          addToLog(['⚠️ Errors:', `   ${result.diagnosticsOutput}`]);
+
+          highlightErrors(codeMirrorRef.current, result.diagnostics, styles);
+        } else {
+          addToLog(['🏁 Compiled - OK.']);
+          saveScript(code);
+        }
+      });
+  };
+
+  const changeScriptEnabled = async (isOn: boolean) => {
+    setIsLoaded(false);
+    saveScriptToPassport(isOn ? code : '')
+      .then(() => {
+        dispatch(
+          setEntrypointEnabled({
+            name: entrypointName,
+            enabled: isOn,
+          })
+        );
+      })
+      .finally(() => {
+        setIsLoaded(true);
+      });
+  };
+
+  if (!signer || !signingClient) {
+    return (
+      <ContainerGradientText>Wallet is not connected.</ContainerGradientText>
+    );
+  }
+
+  if (!passport) {
+    return (
+      <ContainerGradientText>
+        Passport required, for this action.
+      </ContainerGradientText>
+    );
+  }
+
+  return (
+    <ContainerGradientText>
+      <div>
+        <div className={styles.settingsPanel}>
+          <Switch
+            value={currentEntrypoint.enabled}
+            onChange={changeScriptEnabled}
+            label="cybscript enabled"
+          />
+        </div>
+
+        <CodeMirror
+          ref={codeMirrorRef}
+          editorDidMount={(editor) => {
+            editor.setSize('', '400px');
+          }}
+          value={code}
+          options={{
+            readOnly: !isLoaded,
+            mode: 'rune',
+            theme: 'tomorrow-night-eighties',
+            lineNumbers: true,
+          }}
+          onBeforeChange={(editor, data, value) => {
+            setCode(value);
+            setIsChanged(true);
+          }}
+        />
+
+        <textarea
+          ref={outputRef}
+          value={logText}
+          className={styles.logArea}
+          rows={18}
+        />
+      </div>
+      <ScriptingActionBar
+        isChanged={isChanged}
+        onSaveClick={onSaveClick}
+        onCancelClick={onCancelClick}
+        resetPlayGround={resetPlayGround}
+        addToLog={addToLog}
+        nickname={passport.extension.nickname}
+        resetToDefault={onResetToDefault}
+        compileAndTest={compileAndTest}
+      />
+    </ContainerGradientText>
+  );
+}
+
+export default Soul;
diff --git a/src/pages/robot/Soul/StepsBar/StepsBar.module.scss b/src/pages/robot/Soul/StepsBar/StepsBar.module.scss
new file mode 100644
index 000000000..8fb45cfd7
--- /dev/null
+++ b/src/pages/robot/Soul/StepsBar/StepsBar.module.scss
@@ -0,0 +1,5 @@
+.stepsPanel {
+  display: flex;
+  width: 100%;
+  align-items: center;
+}
diff --git a/src/pages/robot/Soul/StepsBar/StepsBar.tsx b/src/pages/robot/Soul/StepsBar/StepsBar.tsx
new file mode 100644
index 000000000..29aea8f2f
--- /dev/null
+++ b/src/pages/robot/Soul/StepsBar/StepsBar.tsx
@@ -0,0 +1,29 @@
+import React from 'react';
+
+import { ButtonIcon } from 'src/components';
+import back from 'src/image/arrow-left-img.svg';
+
+import styles from './StepsBar.module.scss';
+
+function StepsBar({
+  steps,
+  currentStep,
+  setCurrentStep,
+}: {
+  steps: React.ReactNode[];
+  currentStep: number;
+  setCurrentStep: (step: number) => void;
+}) {
+  const onBack = () => setCurrentStep(currentStep - 1);
+
+  return (
+    <div className={styles.stepsPanel}>
+      {!!currentStep && (
+        <ButtonIcon img={back} onClick={onBack} text="previous step" />
+      )}
+      {steps[currentStep]}
+    </div>
+  );
+}
+
+export default StepsBar;
diff --git a/src/pages/robot/Soul/codeMirror.css b/src/pages/robot/Soul/codeMirror.css
new file mode 100644
index 000000000..7336d9845
--- /dev/null
+++ b/src/pages/robot/Soul/codeMirror.css
@@ -0,0 +1,8 @@
+.react-codemirror2 {
+  .CodeMirror {
+    line-height: 1.3em;
+  }
+}
+.react-codemirror2 * {
+  text-transform: none;
+}
diff --git a/src/pages/robot/Soul/formatting/rune.js b/src/pages/robot/Soul/formatting/rune.js
new file mode 100644
index 000000000..92ad92d74
--- /dev/null
+++ b/src/pages/robot/Soul/formatting/rune.js
@@ -0,0 +1,100 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: https://codemirror.net/LICENSE
+
+//TODO: process template literals (look "quasi" in js mode)
+
+(function (mod) {
+  if (typeof exports == 'object' && typeof module == 'object')
+    // CommonJS
+    mod(
+      require('codemirror/lib/codemirror'),
+      require('codemirror/addon/mode/simple')
+    );
+  else if (typeof define == 'function' && define.amd)
+    // AMD
+    define(['codemirror/lib/codemirror', 'codemirror/addon/mode/simple'], mod);
+  // Plain browser env
+  else mod(CodeMirror);
+})(function (CodeMirror) {
+  'use strict';
+
+  CodeMirror.defineSimpleMode('rune', {
+    start: [
+      // string and byte string
+      { regex: /b?"/, token: 'string', next: 'string' },
+      // raw string and raw byte string
+      { regex: /b?r"/, token: 'string', next: 'string_raw' },
+      { regex: /b?r#+"/, token: 'string', next: 'string_raw_hash' },
+      // character
+      {
+        regex: /'(?:[^'\\]|\\(?:[nrt0'"]|x[\da-fA-F]{2}|u\{[\da-fA-F]{6}\}))'/,
+        token: 'string-2',
+      },
+      // byte
+      {
+        regex: /b'(?:[^']|\\(?:['\\nrt0]|x[\da-fA-F]{2}))'/,
+        token: 'string-2',
+      },
+
+      {
+        regex:
+          /(?:(?:[0-9][0-9_]*)(?:(?:[Ee][+-]?[0-9_]+)|\.[0-9_]+(?:[Ee][+-]?[0-9_]+)?)(?:f32|f64)?)|(?:0(?:b[01_]+|(?:o[0-7_]+)|(?:x[0-9a-fA-F_]+))|(?:[0-9][0-9_]*))(?:u8|u16|u32|u64|i8|i16|i32|i64|isize|usize)?/,
+        token: 'number',
+      },
+      {
+        regex:
+          /(let(?:\s+mut)?|fn|enum|mod|struct|type|union)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)/,
+        token: ['keyword', null, 'def'],
+      },
+      {
+        regex:
+          /(?:abstract|alignof|as|async|await|box|break|continue|const|crate|do|dyn|else|enum|extern|fn|for|final|if|impl|in|loop|macro|match|mod|move|offsetof|override|priv|proc|pub|pure|ref|return|self|sizeof|static|struct|super|trait|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/,
+        token: 'keyword',
+      },
+      {
+        regex:
+          /\b(?:Self|isize|usize|char|bool|u8|u16|u32|u64|f16|f32|f64|i8|i16|i32|i64|str|Option)\b/,
+        token: 'atom',
+      },
+      { regex: /\b(?:true|false|Some|None|Ok|Err)\b/, token: 'builtin' },
+      {
+        regex: /\b(fn)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)/,
+        token: ['keyword', null, 'def'],
+      },
+      { regex: /#!?\[.*\]/, token: 'meta' },
+      { regex: /\/\/.*/, token: 'comment' },
+      { regex: /\/\*/, token: 'comment', next: 'comment' },
+      { regex: /[-+\/*=<>!]+/, token: 'operator' },
+      { regex: /[a-zA-Z_]\w*!/, token: 'variable-3' },
+      { regex: /[a-zA-Z_]\w*/, token: 'variable' },
+      { regex: /[\{\[\(]/, indent: true },
+      { regex: /[\}\]\)]/, dedent: true },
+    ],
+    string: [
+      { regex: /"/, token: 'string', next: 'start' },
+      { regex: /(?:[^\\"]|\\(?:.|$))*/, token: 'string' },
+    ],
+    string_raw: [
+      { regex: /"/, token: 'string', next: 'start' },
+      { regex: /[^"]*/, token: 'string' },
+    ],
+    string_raw_hash: [
+      { regex: /"#+/, token: 'string', next: 'start' },
+      { regex: /(?:[^"]|"(?!#))*/, token: 'string' },
+    ],
+    comment: [
+      { regex: /.*?\*\//, token: 'comment', next: 'start' },
+      { regex: /.*/, token: 'comment' },
+    ],
+    meta: {
+      dontIndentStates: ['comment'],
+      electricInput: /^\s*\}$/,
+      blockCommentStart: '/*',
+      blockCommentEnd: '*/',
+      lineComment: '//',
+      fold: 'brace',
+    },
+  });
+
+  CodeMirror.defineMIME('text/rune', 'rune');
+});
diff --git a/src/redux/reducers/backend.ts b/src/redux/reducers/backend.ts
index 8d82683bb..379911db4 100644
--- a/src/redux/reducers/backend.ts
+++ b/src/redux/reducers/backend.ts
@@ -3,6 +3,7 @@ import {
   SyncState,
   ServiceStatus,
   BroadcastChannelMessage,
+  MlSyncState,
 } from 'src/services/backend/types/services';
 import { assocPath } from 'ramda';
 import { CommunityDto } from 'src/services/CozoDb/types/dto';
@@ -18,6 +19,7 @@ export const RESET_SYNC_STATE_ACTION_NAME = 'reset_sync_entry';
 type BackendState = {
   dbPendingWrites: number;
   syncState: SyncState;
+  mlState: MlSyncState;
   community: {
     isLoaded: boolean;
     raw: CommunityDto[];
@@ -54,10 +56,13 @@ const initialState: BackendState = {
     friends: [],
   },
   syncState: initialSyncState,
+  mlState: { entryStatus: {} },
   services: {
     db: { status: 'inactive' },
     ipfs: { status: 'inactive' },
     sync: { status: 'inactive' },
+    ml: { status: 'inactive' },
+    rune: { status: 'inactive' },
   },
 };
 
@@ -178,6 +183,18 @@ function backendReducer(
       return { ...state, community };
     }
 
+    case 'sync_ml_entry': {
+      const { entry, state: entryState } = action.value;
+
+      // console.log('------sync_ml_entry', action, entryState);
+      const newState = assocPath(
+        ['mlState', 'entryStatus', entry],
+        entryState,
+        state
+      );
+      return newState;
+    }
+
     default:
       return state;
   }
diff --git a/src/redux/reducers/index.ts b/src/redux/reducers/index.ts
index 260dc108c..45e87c398 100644
--- a/src/redux/reducers/index.ts
+++ b/src/redux/reducers/index.ts
@@ -1,6 +1,8 @@
 // import { combineReducers } from 'redux';
 
 import commanderReducer from 'src/containers/application/Header/Commander/commander.redux';
+import scriptingReducer from 'src/redux/reducers/scripting';
+
 import golReducer from './gol';
 import bandwidthReducer from './bandwidth';
 import pocketReducer from '../features/pocket';
@@ -23,6 +25,7 @@ const rootReducer = {
   sense: senseReducer,
   warp: warpReducer,
   ibcDenom: ibcDenomReducer,
+  scripting: scriptingReducer,
   hub: hubReducer,
 };
 
diff --git a/src/redux/reducers/scripting.ts b/src/redux/reducers/scripting.ts
new file mode 100644
index 000000000..0d1938c41
--- /dev/null
+++ b/src/redux/reducers/scripting.ts
@@ -0,0 +1,121 @@
+/* eslint-disable camelcase */
+import { PayloadAction, createSlice } from '@reduxjs/toolkit';
+import {
+  loadJsonFromLocalStorage,
+  saveJsonToLocalStorage,
+  loadStringFromLocalStorage,
+  saveStringToLocalStorage,
+  getEntrypointKeyName,
+} from 'src/utils/localStorage';
+
+import {
+  ScriptEntrypointNames,
+  ScriptContext,
+  ScriptEntrypoints,
+} from 'src/services/scripting/types';
+
+import { TabularKeyValues } from 'src/types/data';
+
+import type { AppThunk, SliceActions } from 'src/redux/types';
+
+import defaultParticleScript from 'src/services/scripting/rune/default/particle.rn';
+import { RootState } from '../store';
+
+type SliceState = {
+  context: ScriptContext; // Omit<ScriptContext, 'secrets' | 'user'>;
+  scripts: {
+    entrypoints: ScriptEntrypoints;
+  };
+};
+
+const particleEnabled = loadStringFromLocalStorage(
+  getEntrypointKeyName('particle', 'enabled'),
+  undefined
+);
+
+const isParticleScriptEnabled =
+  particleEnabled !== undefined ? !!particleEnabled : true;
+
+console.log('----isParticleScriptEnabled', isParticleScriptEnabled);
+
+const initialScriptEntrypoints: ScriptEntrypoints = {
+  particle: {
+    title: 'Personal processor',
+    script: loadStringFromLocalStorage('particle', defaultParticleScript),
+    enabled: !!isParticleScriptEnabled,
+  },
+  // myParticle: {
+  //   title: 'Social inference',
+  //   script: '',
+  //   enabled: true,
+  // },
+};
+
+const initialState: SliceState = {
+  context: {
+    secrets: loadJsonFromLocalStorage('secrets', {}) as TabularKeyValues,
+    params: {},
+    user: {},
+  },
+  scripts: {
+    entrypoints: initialScriptEntrypoints,
+  },
+};
+
+export function setSecrets(secrets: TabularKeyValues): AppThunk {
+  return (dispatch) => {
+    saveJsonToLocalStorage('secrets', secrets);
+    dispatch(setContext({ name: 'secrets', item: secrets }));
+  };
+}
+
+const slice = createSlice({
+  name: 'scripting',
+  initialState,
+  reducers: {
+    setContext: (
+      state,
+      {
+        payload,
+      }: PayloadAction<{
+        name: keyof ScriptContext;
+        item: ScriptContext[keyof ScriptContext];
+      }>
+    ) => {
+      state.context = { ...state.context, [payload.name]: payload.item };
+    },
+    setEntrypoint: (
+      state,
+      { payload }: PayloadAction<{ name: ScriptEntrypointNames; code: string }>
+    ) => {
+      const { name, code } = payload;
+      if (code) {
+        state.scripts.entrypoints[name].script = code;
+      }
+    },
+    setEntrypointEnabled: (
+      state,
+      {
+        payload,
+      }: PayloadAction<{ name: ScriptEntrypointNames; enabled: boolean }>
+    ) => {
+      const { name, enabled } = payload;
+      saveStringToLocalStorage(
+        getEntrypointKeyName(name, 'enabled'),
+        enabled ? 'true' : ''
+      );
+
+      state.scripts.entrypoints[name].enabled = enabled;
+    },
+  },
+});
+
+export const selectRuneEntypoints = (store: RootState) =>
+  store.scripting.scripts.entrypoints;
+
+export type ScriptingActionTypes = SliceActions<typeof slice.actions>;
+
+export const { setEntrypoint, setEntrypointEnabled, setContext } =
+  slice.actions;
+
+export default slice.reducer;
diff --git a/src/redux/types.d.ts b/src/redux/types.d.ts
index 7b9bc184e..424be501c 100644
--- a/src/redux/types.d.ts
+++ b/src/redux/types.d.ts
@@ -8,3 +8,7 @@ export type AppThunk<ReturnType = void> = ThunkAction<
   unknown,
   AnyAction
 >;
+
+export type SliceActions<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => infer A ? A : never;
+}[keyof T];
diff --git a/src/services/CozoDb/cozoDb.ts b/src/services/CozoDb/cozoDb.ts
index 3105ff513..9a8df5879 100644
--- a/src/services/CozoDb/cozoDb.ts
+++ b/src/services/CozoDb/cozoDb.ts
@@ -16,14 +16,18 @@ import { clearIndexedDBStore, toListOfObjects } from './utils';
 import { createCozoDbCommandFactory } from './cozoDbCommandFactory';
 
 import initializeScript from './migrations/schema.cozo';
+import { fetchInitialEmbeddings } from './migrations/migrations';
 
 export const DB_NAME = 'cyb-cozo-idb';
 
 const DB_STORE_NAME = 'cozodb';
-const DB_VERSION = '1.1';
+
+export const DB_VERSION = 1.2;
 
 type OnWrite = (writesCount: number) => void;
 
+let shouldInitialize = false;
+
 function createCozoDb() {
   let db: CozoDb | undefined;
 
@@ -40,7 +44,6 @@ function createCozoDb() {
       onIndexedDbWrite
     );
     await initDbSchema();
-    commandFactory = createCozoDbCommandFactory(dbSchema);
   };
 
   async function init(onWrite?: OnWrite): Promise<void> {
@@ -48,7 +51,7 @@ function createCozoDb() {
     await initCozoDb();
     await loadCozoDb();
 
-    await migrate();
+    await performHardReset();
   }
 
   const getRelations = async (): Promise<string[]> => {
@@ -79,30 +82,49 @@ function createCozoDb() {
     return tableSchema;
   };
 
-  const initDbSchema = async (): Promise<void> => {
-    let relations = await getRelations();
-
-    if (relations.length === 0) {
-      cyblogCh.info('CozoDb: apply DB schema', initializeScript);
-      const result = await runCommand(initializeScript);
-
-      relations = await getRelations();
-    }
-
+  const loadDbSchema = async () => {
+    const relations = await getRelations();
     const schemasMap = await Promise.all(
       relations.map(async (table) => {
         const tableSchema = await createSchema(table);
         return [table, tableSchema];
       })
     );
-
     dbSchema = Object.fromEntries(schemasMap);
-    cyblogCh.info('CozoDb schema initialized: ', {
+    cyblogCh.info('cozoDb schema initialized: ', {
       data: [dbSchema, relations, schemasMap],
     });
+
+    commandFactory = createCozoDbCommandFactory(dbSchema);
+
+    cyblogCh.info('cozoDb schema initialized: ', {
+      data: [dbSchema, relations, schemasMap],
+    });
+
+    return dbSchema;
   };
 
-  const getVersion = async () => {
+  const initDbSchema = async (): Promise<void> => {
+    await loadDbSchema();
+
+    shouldInitialize = Object.keys(dbSchema).length === 0;
+    if (shouldInitialize) {
+      cyblogCh.info('   cozoDb - apply DB schema', initializeScript);
+      const result = await runCommand(initializeScript);
+
+      await loadDbSchema();
+
+      // if initialized set initial version
+      await setDbVersion(DB_VERSION);
+
+      await fetchInitialEmbeddings(async (items: Partial<DbEntity>[]) => {
+        console.log(' [initial]save initial particles...');
+        await put('sync_queue', items);
+      });
+    }
+  };
+
+  const getDbVersion = async () => {
     const versionData = await get(
       'config',
       ['value'],
@@ -110,27 +132,35 @@ function createCozoDb() {
       ['key']
     );
 
-    return (versionData.rows[0][0] as string) || DB_VERSION;
+    return (versionData.rows?.[0]?.[0] as number) || 0;
   };
 
-  const migrate = async () => {
+  const setDbVersion = async (version: number) => {
+    const result = await put('config', [
+      {
+        key: 'DB_VERSION',
+        group_key: 'system',
+        value: version,
+      },
+    ]);
+
+    // console.log('CozoDb >>> setDbVersion', version, result);
+    return result;
+  };
+
+  const performHardReset = async () => {
     // if (!dbSchema.community) {
     //   const result = await runCommand(communityScript);
     //   console.log('CozoDb >>> migration: creating community relation....');
     //   dbSchema.community = await createSchema('community');
     // }
-
     if (!dbSchema.transaction.values.includes('block_height')) {
       cyblogCh.info('💀 HARD RESET experemental db...');
       await clearIndexedDBStore(DB_NAME, DB_STORE_NAME);
       await init(onIndexedDbWrite);
-      await put('config', [
-        {
-          key: 'DB_VERSION',
-          group_key: 'system',
-          value: DB_VERSION,
-        },
-      ]);
+      await setDbVersion(DB_VERSION);
+
+      // await setDbVersion(DB_VERSION);
     }
     // const version = await getVersion();
     // console.log(`DB Version ${version}`);
@@ -145,7 +175,6 @@ function createCozoDb() {
     }
     const resultStr = await db.run(command, '', immutable);
     const result = JSON.parse(resultStr);
-    // console.log('----> runCommand ', command, result);
 
     if (!result.ok) {
       console.log('----> runCommand error ', command, result);
@@ -158,8 +187,18 @@ function createCozoDb() {
   const put = async (
     tableName: string,
     array: Partial<DbEntity>[]
-  ): Promise<IDBResult> =>
-    runCommand(commandFactory!.generatePut(tableName, array));
+  ): Promise<IDBResult> => {
+    if (array.length === 0) {
+      throw new DBResultError({
+        code: '-1',
+        message: `cant PUT [] into ${tableName}`,
+        display: '',
+        severity: '',
+        ok: false,
+      });
+    }
+    return runCommand(commandFactory!.generatePut(tableName, array));
+  };
 
   const rm = async (
     tableName: string,
@@ -183,8 +222,8 @@ function createCozoDb() {
     runCommand(
       commandFactory!.generateGet(
         tableName,
-        conditions,
         selectFields,
+        conditions,
         conditionFields,
         options
       ),
@@ -207,7 +246,14 @@ function createCozoDb() {
     getCommandFactory: () => commandFactory,
     importRelations,
     exportRelations,
+    getDbVersion,
+    setDbVersion,
+    loadDbSchema,
   };
 }
 
+// const cozoDb = createCozoDb();
+
+export type CybCozoDb = ReturnType<typeof createCozoDb>;
+
 export default createCozoDb();
diff --git a/src/services/CozoDb/mapping.ts b/src/services/CozoDb/mapping.ts
index 96ebc00c0..ef1a8f2e3 100644
--- a/src/services/CozoDb/mapping.ts
+++ b/src/services/CozoDb/mapping.ts
@@ -6,12 +6,17 @@ import { LinkDbEntity, PinTypeMap } from './types/entities';
 import { Transaction } from '../backend/services/indexer/types';
 import { LinkDto, ParticleDto, PinDto, TransactionDto } from './types/dto';
 import { CyberlinksByParticleQuery } from 'src/generated/graphql';
+import { removeMarkdownFormatting, replaceQuotes } from 'src/utils/string';
 
 export const mapParticleToEntity = (particle: IPFSContent): ParticleDto => {
-  const { cid, result, meta, textPreview } = particle;
+  const { cid, meta, textPreview } = particle;
   const { size, mime, type, blocks, sizeLocal } = meta;
+
   // hack to fix string command
-  const text = textPreview?.replace(/"/g, "'") || '';
+  const text = textPreview
+    ? replaceQuotes(removeMarkdownFormatting(textPreview))
+    : '';
+
   return {
     cid,
     size: size || 0,
diff --git a/src/services/CozoDb/migrations/migrations.ts b/src/services/CozoDb/migrations/migrations.ts
new file mode 100644
index 000000000..4e8065db5
--- /dev/null
+++ b/src/services/CozoDb/migrations/migrations.ts
@@ -0,0 +1,86 @@
+import { getRelevance } from 'src/utils/search/utils';
+import { DB_VERSION, type CybCozoDb } from '../cozoDb';
+import { DbEntity, SyncQueueJobType } from '../types/entities';
+import { QueuePriority } from 'src/services/QueueManager/types';
+import { SyncQueueDto } from '../types/dto';
+import { dtoListToEntity } from 'src/utils/dto';
+import { ParticleCid } from 'src/types/base';
+
+export const fetchInitialEmbeddings = async (
+  saveSyncQueue: (syncItems: Partial<DbEntity>[]) => Promise<void>
+) => {
+  console.log(' [initial]fetch initial particles...');
+  const relevancePaticles = await getRelevance(0, 400);
+
+  const items = relevancePaticles.result.map(
+    ({ particle }: { particle: ParticleCid }) => ({
+      id: particle,
+      data: '',
+      jobType: SyncQueueJobType.particle,
+      priority: QueuePriority.LOW,
+    })
+  ) as SyncQueueDto[];
+
+  await saveSyncQueue(dtoListToEntity(items));
+};
+
+const migrate = async (db: CybCozoDb) => {
+  const version = await db.getDbVersion();
+  console.log(`* db version - ${version}`);
+  if (version < 1.2) {
+    //
+    console.log('⚡️ Migrating to 1.1');
+    console.log('    add job_type field to sync_queue');
+    const res1 = await db.runCommand(`
+        ?[id,status,priority, job_type, data] := *sync_queue{id,status,priority}, job_type=0, data='';
+        :replace sync_queue {
+            id: String,
+            job_type: Int default 0 =>
+            data: String default '',
+            status: Int default 0,
+            priority: Float default 0,
+        }
+    `);
+    console.log(`       ok: ${res1.ok}`);
+
+    console.log('    create embeddings relation');
+    const res2 = await db.runCommand(`
+        :create embeddings {
+            cid: String =>
+            vec: <F32; 384>
+        }
+    `);
+    console.log(`       ok: ${res2.ok}`);
+    console.log('    create embeddings:semantic index');
+    const res3 = await db.runCommand(`
+        ::hnsw create embeddings:semantic{
+            fields: [vec],
+            dim: 384,
+            ef: 100,
+            m: 16
+        }
+    `);
+    console.log(`       ok: ${res3.ok}`);
+
+    console.log('    fill queue to calculate embeddings for all particles');
+    const res4 = await db.runCommand(`
+        ?[id, data, job_type, status, priority] := *particle{cid, text, mime}, mime="text/plain", job_type=1, status=0, priority=0.5, id = cid, data=text
+
+        :put sync_queue {
+            id,
+            job_type =>
+            data,
+            status,
+            priority,
+        }
+    `);
+    console.log(`       ok: ${res4.ok}`);
+    await db.setDbVersion(DB_VERSION);
+
+    return true;
+  }
+
+  return false;
+};
+
+export default migrate;
diff --git a/src/services/CozoDb/migrations/schema.cozo b/src/services/CozoDb/migrations/schema.cozo
index 1a67e4bc8..950bcd4d4 100644
--- a/src/services/CozoDb/migrations/schema.cozo
+++ b/src/services/CozoDb/migrations/schema.cozo
@@ -62,7 +62,9 @@
 
 {
     :create sync_queue {
-        id: String =>
+        id: String,
+        job_type: Int =>
+        data: String default '',
         status: Int default 0,
         priority: Float default 0,
     }
@@ -77,4 +79,18 @@
         following: Bool,
         follower: Bool
     }
+}
+{
+    :create embeddings {
+        cid: String =>
+        vec: <F32; 384>
+    }
+}
+{
+    ::hnsw create embeddings:semantic{
+        fields: [vec],
+        dim: 384,
+        ef: 100,
+        m: 16
+    }
 }
\ No newline at end of file
diff --git a/src/services/CozoDb/types/dto.ts b/src/services/CozoDb/types/dto.ts
index a9caac626..941206b21 100644
--- a/src/services/CozoDb/types/dto.ts
+++ b/src/services/CozoDb/types/dto.ts
@@ -8,6 +8,7 @@ import {
   LinkDbEntity,
   SyncQueueDbEntity,
   CommunityDbEntity,
+  SyncQueueKey,
 } from './entities';
 
 export type PinDto = EntityToDto<PinDbEntity>;
@@ -17,4 +18,6 @@ export type ParticleDto = EntityToDto<ParticleDbEntity>;
 export type ConfigDto = EntityToDto<ConfigDbEntity>;
 export type LinkDto = EntityToDto<LinkDbEntity>;
 export type SyncQueueDto = EntityToDto<SyncQueueDbEntity>;
+export type SyncQueueKeyDto = EntityToDto<SyncQueueKey>;
+
 export type CommunityDto = EntityToDto<CommunityDbEntity>;
diff --git a/src/services/CozoDb/types/entities.ts b/src/services/CozoDb/types/entities.ts
index 513d2bbf7..86a99c738 100644
--- a/src/services/CozoDb/types/entities.ts
+++ b/src/services/CozoDb/types/entities.ts
@@ -92,8 +92,18 @@ export enum SyncQueueStatus {
   error = -1,
 }
 
-export type SyncQueueDbEntity = {
+export enum SyncQueueJobType {
+  particle = 0,
+  embedding = 1,
+}
+
+export type SyncQueueKey = {
   id: string;
+  job_type: SyncQueueJobType;
+};
+
+export type SyncQueueDbEntity = SyncQueueKey & {
+  data: string;
   status: SyncQueueStatus;
   priority: QueuePriority | number;
 };
@@ -107,9 +117,15 @@ export type CommunityDbEntity = {
   follower: boolean;
 };
 
+export type EmbeddinsDbEntity = {
+  cid: ParticleCid;
+  vec: number[];
+};
+
 export type DbEntity =
   | TransactionDbEntity
   | ParticleDbEntity
   | SyncStatusDbEntity
   | ConfigDbEntity
-  | SyncQueueDbEntity;
+  | SyncQueueDbEntity
+  | EmbeddinsDbEntity;
diff --git a/src/services/CozoDb/utils.ts b/src/services/CozoDb/utils.ts
index dd2dc8b82..ca800365c 100644
--- a/src/services/CozoDb/utils.ts
+++ b/src/services/CozoDb/utils.ts
@@ -5,6 +5,7 @@ import { entityToDto, snakeToCamel } from 'src/utils/dto';
 
 import { Column, IDBResult } from './types/types';
 import { DbEntity } from './types/entities';
+import { serializeString } from 'src/utils/string';
 
 export function dbResultToDtoList<T>(dbResult: IDBResult): T[] {
   const { headers, rows } = dbResult;
@@ -89,10 +90,14 @@ export const entityToArray = (
     .map((col) => {
       const key = col.column as keyof DbEntity;
       const value = obj[key];
+
+      if (/<[a-z]+\d*;\d+>/i.test(col.type)) {
+        return `[${value}]`;
+      }
       return col.type === 'Json'
         ? `parse_json('${JSON.stringify(value)}')`
         : col.type === 'String'
-        ? `"${value}"`
+        ? `"${serializeString(value)}"`
         : value;
     })
     .join(', ')}]`;
diff --git a/src/services/QueueManager/QueueManager.ts b/src/services/QueueManager/QueueManager.ts
index 916b6a127..bb3683932 100644
--- a/src/services/QueueManager/QueueManager.ts
+++ b/src/services/QueueManager/QueueManager.ts
@@ -3,15 +3,20 @@ import {
   EMPTY,
   Observable,
   catchError,
+  combineLatest,
   debounceTime,
+  distinctUntilChanged,
   filter,
   interval,
   map,
   merge,
   mergeMap,
   of,
+  share,
+  tap,
   throwError,
   timeout,
+  withLatestFrom,
 } from 'rxjs';
 
 import * as R from 'ramda';
@@ -23,7 +28,6 @@ import { ParticleCid } from 'src/types/base';
 import { promiseToObservable } from '../../utils/rxjs/helpers';
 
 import type {
-  IDeferredDbSaver,
   QueueItem,
   QueueItemAsyncResult,
   QueueItemCallback,
@@ -35,12 +39,15 @@ import type {
 
 import { QueueStrategy } from './QueueStrategy';
 
+import { enqueueParticleSave } from '../backend/channels/BackendQueueChannel/backendQueueSenders';
 import BroadcastChannelSender from '../backend/channels/BroadcastChannelSender';
+import { RuneEngine } from '../scripting/engine';
+
 import { QueueItemTimeoutError } from './QueueItemTimeoutError';
 import { CustomHeaders, XCybSourceValues } from './constants';
 
 const QUEUE_DEBOUNCE_MS = 33;
-const CONNECTION_KEEPER_RETRY_MS = 5000;
+const CONNECTION_KEEPER_RETRY_MS = 15000;
 
 function getQueueItemTotalPriority(item: QueueItem): number {
   return (item.priority || 0) + (item.viewPortPriority || 0);
@@ -54,15 +61,15 @@ const strategies = {
   external: new QueueStrategy(
     {
       db: { timeout: 5000, maxConcurrentExecutions: 999 },
-      node: { timeout: 60 * 1000, maxConcurrentExecutions: 50 },
-      gateway: { timeout: 21000, maxConcurrentExecutions: 11 },
+      node: { timeout: 60 * 1000, maxConcurrentExecutions: 30 },
+      gateway: { timeout: 10000, maxConcurrentExecutions: 11 },
     },
     ['db', 'node', 'gateway']
   ),
   embedded: new QueueStrategy(
     {
       db: { timeout: 5000, maxConcurrentExecutions: 999 },
-      node: { timeout: 60 * 1000, maxConcurrentExecutions: 50 },
+      node: { timeout: 60 * 1000, maxConcurrentExecutions: 30 },
       gateway: { timeout: 21000, maxConcurrentExecutions: 11 },
     },
     ['db', 'gateway', 'node']
@@ -70,8 +77,8 @@ const strategies = {
   helia: new QueueStrategy(
     {
       db: { timeout: 5000, maxConcurrentExecutions: 999 },
-      node: { timeout: 6 * 1000, maxConcurrentExecutions: 50 }, // TODO: set to 60
-      gateway: { timeout: 3 * 1000, maxConcurrentExecutions: 11 },
+      node: { timeout: 60 * 1000, maxConcurrentExecutions: 50 },
+      gateway: { timeout: 10000, maxConcurrentExecutions: 11 },
     },
     ['db', 'node', 'gateway']
   ),
@@ -84,8 +91,6 @@ class QueueManager {
 
   private node: CybIpfsNode | undefined = undefined;
 
-  private defferedDbSaver?: IDeferredDbSaver;
-
   private strategy: QueueStrategy;
 
   private queueDebounceMs: number;
@@ -105,7 +110,11 @@ class QueueManager {
   }
 
   public async setNode(node: CybIpfsNode, customStrategy?: QueueStrategy) {
-    console.log(`switch node from ${this.node?.nodeType} to ${node.nodeType}`);
+    console.log(
+      `* switch node from ${this.node?.nodeType || '<none>'} to ${
+        node.nodeType
+      }`
+    );
     this.node = node;
     this.switchStrategy(customStrategy || strategies[node.nodeType]);
   }
@@ -125,15 +134,12 @@ class QueueManager {
       const executeCount =
         settings.maxConcurrentExecutions -
         this.executing[queueSource as IpfsContentSource].size;
-
       const itemsByPriority = items
         .sort(
           (a, b) => getQueueItemTotalPriority(b) - getQueueItemTotalPriority(a)
         )
         .slice(0, executeCount);
 
-      // console.log('---itemsByPriority', itemsByPriority);
-
       itemsToExecute.push(...itemsByPriority);
     }
 
@@ -142,7 +148,6 @@ class QueueManager {
 
   private postSummary() {
     const summary = `(total: ${this.queue$.value.size} |  db - ${this.executing.db.size} node - ${this.executing.node.size} gateway - ${this.executing.gateway.size})`;
-
     this.channel.postServiceStatus('ipfs', 'started', summary);
   }
 
@@ -164,29 +169,27 @@ class QueueManager {
     callbacks.map((callback) => callback(cid, 'executing', source));
 
     return promiseToObservable(async () => {
-      try {
-        const res = await fetchIpfsContent(cid, source, {
-          controller,
-          node: this.node,
-          headers: {
-            [CustomHeaders.XCybSource]: XCybSourceValues.sharedWorker,
-          },
-        }).then((content) => {
-          this.defferedDbSaver?.enqueueIpfsContent(content);
-
-          return content;
-        });
-        return res;
-      } catch (e) {
-        // console.log('---promtoo', e);
-        throw e;
-      }
+      return fetchIpfsContent(cid, source, {
+        controller,
+        node: this.node,
+        headers: {
+          [CustomHeaders.XCybSource]: XCybSourceValues.sharedWorker,
+        },
+      }).then((content) => {
+        // put saveto db msg into bus
+        if (content && source !== 'db') {
+          enqueueParticleSave(content);
+        }
+
+        return content;
+      });
     }).pipe(
       timeout({
         each: settings.timeout,
         with: () =>
           throwError(() => {
             controller?.abort('timeout');
+
             return new QueueItemTimeoutError(settings.timeout);
           }),
       }),
@@ -279,11 +282,9 @@ class QueueManager {
     {
       strategy,
       queueDebounceMs,
-      defferedDbSaver,
     }: {
       strategy?: QueueStrategy;
       queueDebounceMs?: number;
-      defferedDbSaver?: IDeferredDbSaver;
     }
   ) {
     ipfsInstance$.subscribe((node) => {
@@ -294,25 +295,49 @@ class QueueManager {
 
     this.strategy = strategy || strategies.embedded;
     this.queueDebounceMs = queueDebounceMs || QUEUE_DEBOUNCE_MS;
-    this.defferedDbSaver = defferedDbSaver;
 
     // Little hack to handle keep-alive connection to swarm cyber node
     // Fix some lag with node peers(when it shown swarm node in peers but not  connected anymore)
     interval(CONNECTION_KEEPER_RETRY_MS)
-      .pipe(filter(() => this.queue$.value.size > 0 && !!this.node))
-      .subscribe(() => this.node!.reconnectToSwarm(this.lastNodeCallTime));
+      .pipe(
+        filter(
+          () =>
+            !!this.node &&
+            !![...this.queue$.value.values()].find((i) => i.source === 'node')
+        )
+      )
+      .subscribe(() => {
+        // console.log(
+        //   '-----reconnect cnt',
+        //   this.queue$.value.size,
+        //   this.queue$.value
+        // );
+        this.node!.reconnectToSwarm(true);
+      });
+
+    const isInitialized$ = combineLatest([ipfsInstance$]).pipe(
+      map(([ipfsInstance]) => !!ipfsInstance && ipfsInstance?.isStarted),
+      distinctUntilChanged(),
+      share()
+    );
+
+    isInitialized$.subscribe((isInitialized) => {
+      isInitialized && console.log('🚦 ipfs queue initialized');
+      this.node?.reconnectToSwarm(true);
+    });
 
     this.queue$
       .pipe(
-        // tap(() => console.log('----QUEUE')),
+        withLatestFrom(isInitialized$),
+        filter(([, isInitialized]) => isInitialized),
         debounceTime(this.queueDebounceMs),
-        map((queue) => this.cancelDeprioritizedItems(queue)),
+        map(([queue]) => this.cancelDeprioritizedItems(queue)),
         mergeMap((queue) => {
           const workItems = this.getItemBySourceAndPriority(queue);
           // console.log('---workItems', workItems);
           if (workItems.length > 0) {
             // wake up connnection to swarm cyber node
-            this.node?.reconnectToSwarm(this.lastNodeCallTime);
+            this.node?.reconnectToSwarm(false);
 
             return merge(...workItems.map((item) => this.fetchData$(item)));
           }
@@ -471,12 +496,4 @@ class QueueManager {
   }
 }
 
-// TODO: MOVE TO SEPARATE FILE AS GLOBAL VARIABLE
-// const queueManager = new QueueManager<IPFSContentMaybe>();
-
-// if (typeof window !== 'undefined') {
-//   window.qm = queueManager;
-// }
-
-// export { queueManager };
 export default QueueManager;
diff --git a/src/services/QueueManager/__tests__/QueueManager.fake-timer.test.ts b/src/services/QueueManager/__tests__/QueueManager.fake-timer.test.ts
index 659dc30ac..e1725c8eb 100644
--- a/src/services/QueueManager/__tests__/QueueManager.fake-timer.test.ts
+++ b/src/services/QueueManager/__tests__/QueueManager.fake-timer.test.ts
@@ -2,7 +2,6 @@ import QueueManager from '../QueueManager';
 import { of } from 'rxjs';
 import { CybIpfsNode } from '../../ipfs/types';
 import { QueueStrategy } from '../QueueStrategy';
-import { IDeferredDbSaver } from '../types';
 import { valuesExpected } from 'src/utils/test-utils/test-utils';
 import { fetchIpfsContent } from 'src/services/ipfs/utils/utils-ipfs';
 
@@ -22,7 +21,6 @@ jest.mock('rxjs', () => {
   };
 });
 
-jest.mock('../../backend/services/DeferredDbSaver/DeferredDbSaver'); // adjust the path as needed
 jest.mock('../../ipfs/utils/ipfsCacheDb');
 
 jest.mock('src/services/ipfs/utils/cluster.ts', () => ({ add: jest.fn() }));
@@ -97,14 +95,10 @@ describe('QueueManager without timers', () => {
 
   beforeEach(() => {
     // setup QueueManager instance before each test
-    const deferredDbSaverMock: IDeferredDbSaver = {
-      enqueueIpfsContent: jest.fn(),
-      enqueueLinks: jest.fn(),
-    };
+
     queueManager = new QueueManager(of(mockNode), {
       strategy: queueStrategy,
       queueDebounceMs: 0,
-      defferedDbSaver: deferredDbSaverMock,
     });
   });
 
diff --git a/src/services/QueueManager/__tests__/QueueManager.test.ts b/src/services/QueueManager/__tests__/QueueManager.test.ts
index 04d0feb3c..2ad5ad4cf 100644
--- a/src/services/QueueManager/__tests__/QueueManager.test.ts
+++ b/src/services/QueueManager/__tests__/QueueManager.test.ts
@@ -2,7 +2,7 @@ import QueueManager from '../QueueManager';
 import { BehaviorSubject, of } from 'rxjs';
 import { CybIpfsNode } from '../../ipfs/types';
 import { QueueStrategy } from '../QueueStrategy';
-import { IDeferredDbSaver } from '../types';
+import { I } from '../types';
 import { valuesExpected } from 'src/utils/test-utils/test-utils';
 import { fetchIpfsContent } from 'src/services/ipfs/utils/utils-ipfs';
 
@@ -22,7 +22,6 @@ import { fetchIpfsContent } from 'src/services/ipfs/utils/utils-ipfs';
 //   };
 // });
 
-jest.mock('../../backend/services/DeferredDbSaver/DeferredDbSaver'); // adjust the path as needed
 jest.mock('../../ipfs/utils/ipfsCacheDb');
 
 jest.mock('src/services/ipfs/utils/cluster.ts', () => ({ add: jest.fn() }));
@@ -105,14 +104,10 @@ describe('QueueManager without timers', () => {
 
   beforeEach(() => {
     // setup QueueManager instance before each test
-    const deferredDbSaverMock: IDeferredDbSaver = {
-      enqueueIpfsContent: jest.fn(),
-      enqueueLinks: jest.fn(),
-    };
+
     queueManager = new QueueManager(of(mockNode), {
       strategy: queueStrategy,
       queueDebounceMs: 1,
-      defferedDbSaver: deferredDbSaverMock,
     });
   });
 
diff --git a/src/services/QueueManager/types.ts b/src/services/QueueManager/types.ts
index fa042044d..0fd9da1db 100644
--- a/src/services/QueueManager/types.ts
+++ b/src/services/QueueManager/types.ts
@@ -1,6 +1,5 @@
-import { IPFSContentMaybe, IpfsContentSource } from '../ipfs/types';
-import { LinkDbEntity } from '../CozoDb/types/entities';
-import { LinkDto } from '../CozoDb/types/dto';
+import { Option } from 'src/types';
+import { IPFSContent, IpfsContentSource } from '../ipfs/types';
 
 /* eslint-disable import/no-unused-modules */
 export type QueueItemStatus =
@@ -51,7 +50,7 @@ export type QueueItemCallback = (
   cid: string,
   status: QueueItemStatus,
   source: QueueSource,
-  result?: IPFSContentMaybe
+  result?: Option<IPFSContent>
 ) => void;
 
 export type QueueItem = {
@@ -67,20 +66,14 @@ export type QueueItemResult = {
   item: QueueItem;
   status: QueueItemStatus;
   source: QueueSource;
-  result?: IPFSContentMaybe;
+  result?: Option<IPFSContent>;
 };
 
 export type QueueItemAsyncResult = Omit<QueueItemResult, 'item'>;
 
 export type QueueItemPostProcessor = (
-  content: IPFSContentMaybe
-) => Promise<IPFSContentMaybe>;
-
-export interface IDeferredDbSaver {
-  // postProcess: (content: IPFSContentMaybe) => Promise<IPFSContentMaybe>;
-  enqueueIpfsContent: (content: IPFSContentMaybe) => void;
-  enqueueLinks: (links: LinkDto[]) => void;
-}
+  content: Option<IPFSContent>
+) => Promise<Option<IPFSContent>>;
 
 export type FetchParticleAsync = (
   cid: string,
diff --git a/src/services/backend/channels/BackendQueueChannel/BackendQueueChannel.ts b/src/services/backend/channels/BackendQueueChannel/BackendQueueChannel.ts
new file mode 100644
index 000000000..beaa3f815
--- /dev/null
+++ b/src/services/backend/channels/BackendQueueChannel/BackendQueueChannel.ts
@@ -0,0 +1,99 @@
+import { BehaviorSubject, Observable, first } from 'rxjs';
+import { LinkDto } from 'src/services/CozoDb/types/dto';
+import { IPFSContent } from 'src/services/ipfs/types';
+import { mapParticleToEntity } from 'src/services/CozoDb/mapping';
+import { QueueChannelMessage } from './types';
+import { CYB_QUEUE_CHANNEL } from '../consts';
+
+import { enqueueParticleEmbeddingMaybe } from './backendQueueSenders';
+import ParticlesResolverQueue from '../../services/sync/services/ParticlesResolverQueue/ParticlesResolverQueue';
+import DbApi from '../../services/DbApi/DbApi';
+
+import { SyncQueueItem } from '../../services/sync/services/ParticlesResolverQueue/types';
+import { Option } from 'src/types';
+
+class BackendQueueChannelListener {
+  private channel = new BroadcastChannel(CYB_QUEUE_CHANNEL);
+
+  private particlesResolver: ParticlesResolverQueue;
+
+  private dbInstance$: BehaviorSubject<Option<DbApi>>;
+
+  constructor(
+    particlesResolver: ParticlesResolverQueue,
+    dbInstance$: Observable<DbApi | undefined>
+  ) {
+    this.particlesResolver = particlesResolver;
+    dbInstance$.subscribe((v) => {
+      this.dbInstance$.next(v);
+    });
+    this.dbInstance$ = new BehaviorSubject<Option<DbApi>>(undefined);
+
+    this.channel.onmessage = (event) => this.onMessage(event);
+
+    this.channel.onmessageerror = (event) =>
+      console.error(`${CYB_QUEUE_CHANNEL} error`, event);
+  }
+
+  private async getDeffredDbApi(): Promise<DbApi> {
+    return new Promise((resolve) => {
+      const dbApi = this.dbInstance$.getValue();
+      if (dbApi) {
+        resolve(dbApi);
+      }
+
+      this.dbInstance$
+        .pipe(
+          first((value) => value !== undefined) // Automatically unsubscribes after the first valid value
+        )
+        .subscribe((value) => {
+          resolve(value as DbApi);
+        });
+    });
+  }
+
+  private async saveLinks(links: LinkDto[]) {
+    const dbApi = await this.getDeffredDbApi();
+    const res = await dbApi.putCyberlinks(links);
+    // console.log('---saveLinks done', links, res);
+  }
+
+  private async saveParticles(content: IPFSContent) {
+    try {
+      const dbApi = await this.getDeffredDbApi();
+      const entity = mapParticleToEntity(content);
+      const result = await dbApi.putParticles(entity);
+      if (result.ok) {
+        await enqueueParticleEmbeddingMaybe(content);
+      }
+    } catch (e) {
+      console.log(
+        '---saveParticle e',
+        content,
+        content.textPreview,
+        e.toString()
+      );
+      throw e;
+    }
+  }
+
+  private async enquueSync(data: SyncQueueItem | SyncQueueItem[]) {
+    // TODO: TMP ASYNC WAIT TO INIT DB
+    await this.getDeffredDbApi();
+
+    this.particlesResolver.enqueue(Array.isArray(data) ? data : [data]);
+  }
+
+  private onMessage(msg: MessageEvent<QueueChannelMessage>) {
+    const { type, data } = msg.data;
+    if (type === 'link') {
+      this.saveLinks(data);
+    } else if (type === 'particle') {
+      this.saveParticles(data);
+    } else if (type === 'sync') {
+      this.enquueSync(data);
+    }
+  }
+}
+
+export default BackendQueueChannelListener;
diff --git a/src/services/backend/channels/BackendQueueChannel/backendQueueSenders.ts b/src/services/backend/channels/BackendQueueChannel/backendQueueSenders.ts
new file mode 100644
index 000000000..d58b8783d
--- /dev/null
+++ b/src/services/backend/channels/BackendQueueChannel/backendQueueSenders.ts
@@ -0,0 +1,55 @@
+import { SyncQueueJobType } from 'src/services/CozoDb/types/entities';
+import { QueuePriority } from 'src/services/QueueManager/types';
+import { IPFSContent } from 'src/services/ipfs/types';
+import { LinkDto } from 'src/services/CozoDb/types/dto';
+
+import { getTextContentIfShouldEmbed } from '../../services/sync/services/ParticlesResolverQueue/ParticlesResolverQueue';
+import { CYB_QUEUE_CHANNEL } from '../consts';
+import { QueueChannelMessage } from './types';
+
+export const createBackendQueueSender = () => {
+  const channel = new BroadcastChannel(CYB_QUEUE_CHANNEL);
+
+  return {
+    enqueue: (msg: QueueChannelMessage) => {
+      channel.postMessage(msg);
+    },
+  };
+};
+
+const busSender = createBackendQueueSender();
+
+export const enqueueParticleEmbeddingMaybe = async (content: IPFSContent) => {
+  const contentToEmbed = await getTextContentIfShouldEmbed(content);
+
+  if (contentToEmbed) {
+    busSender.enqueue({
+      type: 'sync',
+      data: {
+        id: content.cid,
+        data: contentToEmbed,
+        jobType: SyncQueueJobType.embedding,
+        priority: QueuePriority.MEDIUM,
+      },
+    });
+  }
+
+  return !!contentToEmbed;
+};
+
+export const enqueueParticleSave = (content: IPFSContent) => {
+  busSender.enqueue({
+    type: 'particle',
+    // TODO: add AsyncIterator serializer
+    data: { ...content, result: undefined } as IPFSContent,
+  });
+
+  return true;
+};
+
+export const enqueueLinksSave = (links: LinkDto[]) => {
+  busSender.enqueue({
+    type: 'link',
+    data: links,
+  });
+};
diff --git a/src/services/backend/channels/BackendQueueChannel/types.ts b/src/services/backend/channels/BackendQueueChannel/types.ts
new file mode 100644
index 000000000..0897ada2f
--- /dev/null
+++ b/src/services/backend/channels/BackendQueueChannel/types.ts
@@ -0,0 +1,19 @@
+import { LinkDto } from 'src/services/CozoDb/types/dto';
+import { IPFSContent } from 'src/services/ipfs/types';
+import { SyncQueueItem } from '../../services/sync/services/ParticlesResolverQueue/types';
+
+type DbQueueMessageType = 'link' | 'particle' | 'sync';
+type DbSaveMessage<N extends DbQueueMessageType, T> = {
+  type: N;
+  data: T;
+};
+export type DbSaveLinkMessage = DbSaveMessage<'link', LinkDto[]>;
+export type DbSaveParticleMessage = DbSaveMessage<'particle', IPFSContent>;
+export type DbSyncQueueMessage = DbSaveMessage<
+  'sync',
+  SyncQueueItem[] | SyncQueueItem
+>;
+export type QueueChannelMessage =
+  | DbSyncQueueMessage
+  | DbSaveLinkMessage
+  | DbSaveParticleMessage;
diff --git a/src/services/backend/channels/BroadcastChannelSender.ts b/src/services/backend/channels/BroadcastChannelSender.ts
index eed45a0d4..b680c6c12 100644
--- a/src/services/backend/channels/BroadcastChannelSender.ts
+++ b/src/services/backend/channels/BroadcastChannelSender.ts
@@ -34,6 +34,14 @@ class BroadcastChannelSender {
     this.channel.postMessage({ type: 'sync_entry', value: { entry, state } });
   }
 
+  public postMlSyncEntryProgress(entry: string, state: SyncProgress) {
+    // console.log('postMlSyncEntryProgress', entry, state);
+    this.channel.postMessage({
+      type: 'sync_ml_entry',
+      value: { entry, state },
+    });
+  }
+
   public postSenseUpdate(senseList: SenseListItem[]) {
     // console.log('postSenseUpdate', senseList);
     if (senseList.length > 0) {
diff --git a/src/services/backend/channels/RxBroadcastChannelListener.ts b/src/services/backend/channels/RxBroadcastChannelListener.ts
index 46dc3add1..0fb721c60 100644
--- a/src/services/backend/channels/RxBroadcastChannelListener.ts
+++ b/src/services/backend/channels/RxBroadcastChannelListener.ts
@@ -11,9 +11,13 @@ import {
 import { CYB_BROADCAST_CHANNEL } from './consts';
 
 const shouldTrottle = (msg: MessageEvent<BroadcastChannelMessage>) =>
-  ['sync_entry', 'service_status', 'sync_status', 'indexeddb_write'].some(
-    (name) => name === msg.data.type
-  );
+  [
+    'sync_entry',
+    'service_status',
+    'sync_status',
+    'indexeddb_write',
+    'sync_ml_entry',
+  ].some((name) => name === msg.data.type);
 
 class RxBroadcastChannelListener {
   private subscription: Subscription;
diff --git a/src/services/backend/channels/consts.ts b/src/services/backend/channels/consts.ts
index 5d0aab867..2f45105bd 100644
--- a/src/services/backend/channels/consts.ts
+++ b/src/services/backend/channels/consts.ts
@@ -1 +1,2 @@
 export const CYB_BROADCAST_CHANNEL = 'cyb-broadcast-channel';
+export const CYB_QUEUE_CHANNEL = 'cyb-queue-channel';
diff --git a/src/services/backend/services/DbApi/DbApi.ts b/src/services/backend/services/DbApi/DbApi.ts
index 3e3648f64..b8130d3c8 100644
--- a/src/services/backend/services/DbApi/DbApi.ts
+++ b/src/services/backend/services/DbApi/DbApi.ts
@@ -1,11 +1,13 @@
 import {
+  EmbeddinsDbEntity,
   EntryType,
   PinDbEntity,
+  SyncQueueKey,
   SyncQueueStatus,
 } from 'src/services/CozoDb/types/entities';
 import { NeuronAddress, ParticleCid } from 'src/types/base';
 
-import { dbResultToDtoList } from 'src/services/CozoDb/utils';
+import { dbResultToDtoList, toListOfObjects } from 'src/services/CozoDb/utils';
 import {
   removeUndefinedFields,
   dtoListToEntity,
@@ -18,6 +20,7 @@ import {
   LinkDto,
   ParticleDto,
   SyncQueueDto,
+  SyncQueueKeyDto,
   SyncStatusDto,
   TransactionDto,
 } from 'src/services/CozoDb/types/dto';
@@ -156,7 +159,7 @@ class DbApiWrapper {
     const entitites = dtoListToEntity(
       Array.isArray(particles) ? particles : [particles]
     );
-    await this.db!.executePutCommand('particle', entitites);
+    return this.db!.executePutCommand('particle', entitites);
   }
 
   public async getParticlesRaw(fields: string[]) {
@@ -235,14 +238,35 @@ class DbApiWrapper {
   }
 
   public async putSyncQueue(item: SyncQueueItem[] | SyncQueueItem) {
-    const entitites = Array.isArray(item) ? item : [item];
+    const entitites = dtoListToEntity(Array.isArray(item) ? item : [item]);
     return this.db!.executePutCommand('sync_queue', entitites);
   }
 
+  public async existSyncQueueItem({ id, jobType }: SyncQueueKeyDto) {
+    const result = await this.db!.executeGetCommand(
+      'sync_queue',
+      ['id'],
+      [`id = '${id}'`, `job_type = ${jobType}`],
+      ['id', 'job_type']
+    );
+
+    return result.rows.length > 0;
+  }
+
+  public async existEmbedding(cid: ParticleCid) {
+    const result = await this.db!.executeGetCommand(
+      'embeddings',
+      ['cid'],
+      [`cid = '${cid}'`]
+    );
+
+    return result.rows.length > 0;
+  }
+
   public async updateSyncQueue(
     item: Partial<SyncQueueDto>[] | Partial<SyncQueueDto>
   ) {
-    const entitites = Array.isArray(item) ? item : [item];
+    const entitites = dtoListToEntity(Array.isArray(item) ? item : [item]);
     try {
       return this.db!.executeUpdateCommand('sync_queue', entitites);
     } catch (e) {
@@ -253,23 +277,21 @@ class DbApiWrapper {
       });
       // eslint-disable-next-line no-restricted-syntax
       for (const entity of entitites) {
-        // eslint-disable-next-line no-await-in-loop
-        await this.removeSyncQueue(entity.id!);
+        if (entity) {
+          const { id, job_type: jobType = 0 } = entity;
+          // eslint-disable-next-line no-await-in-loop
+          await this.removeSyncQueue({ id: id!, jobType });
+        }
       }
 
       return { ok: true };
     }
   }
 
-  public async removeSyncQueue(id: ParticleCid | ParticleCid[]) {
-    const ids = Array.isArray(id) ? id : [id];
+  public async removeSyncQueue(id: SyncQueueKeyDto | SyncQueueKeyDto[]) {
+    const ids = dtoListToEntity(Array.isArray(id) ? id : [id]);
 
-    return this.db!.executeRmCommand(
-      'sync_queue',
-      ids.map((id) => ({
-        id,
-      }))
-    );
+    return this.db!.executeRmCommand('sync_queue', ids);
   }
 
   public async getSyncQueue({
@@ -281,7 +303,7 @@ class DbApiWrapper {
   }): Promise<SyncQueueDto[]> {
     const result = await this.db!.executeGetCommand(
       'sync_queue',
-      ['id', 'status', 'priority'],
+      ['id', 'status', 'priority', 'job_type'],
       [`status in [${statuses.join(',')}]`],
       [],
       { orderBy: ['-priority'], limit }
@@ -291,6 +313,7 @@ class DbApiWrapper {
       id: row[0] as string,
       status: row[1] as SyncQueueStatus,
       priority: row[2] as number,
+      jobType: row[3] as number,
     }));
   }
 
@@ -327,6 +350,25 @@ class DbApiWrapper {
 
     return dbResultToDtoList<LinkDto>(result);
   }
+
+  public async searchByEmbedding(vec: number[], count?: number) {
+    const queryText = `
+    e[dist, cid] := ~embeddings:semantic{cid | query: vec([${vec}]), bind_distance: dist, k: 20, ef: 50}
+    ?[dist, cid, text] := e[dist, cid], *particle{cid, text}
+    ${count ? `\r\n:limit ${count}` : ''}`;
+
+    const result = await this.db!.runCommand(queryText);
+    return toListOfObjects(result);
+  }
+
+  public async putEmbedding(cid: string, vec: number[]) {
+    return this.db!.executePutCommand('embeddings', [
+      {
+        cid,
+        vec,
+      } as EmbeddinsDbEntity,
+    ]);
+  }
 }
 
 export default DbApiWrapper;
diff --git a/src/services/backend/services/DeferredDbSaver/DeferredDbSaver.test.ts b/src/services/backend/services/DeferredDbSaver/DeferredDbSaver.test.ts
deleted file mode 100644
index a1e69939b..000000000
--- a/src/services/backend/services/DeferredDbSaver/DeferredDbSaver.test.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import DeferredDbSaver from './DeferredDbSaver';
-import DbApi from '../DbApi/DbApi';
-import { IPFSContent } from 'src/services/ipfs/types';
-import { BehaviorSubject, of } from 'rxjs';
-
-describe('DeferredDbSaver', () => {
-  const dbApiMock$: BehaviorSubject<DbApi | undefined> = new BehaviorSubject(
-    undefined
-  );
-
-  // beforeEach(() => {
-  //   dbApiMock = {
-  //     putParticles: jest.fn(),
-  //     putCyberlinks: jest.fn(),
-  //   } as jest.Mocked<DbApi>;
-
-  //   deferredDbSaver = new DeferredDbSaver(of(dbApiMock));
-  // });
-
-  // afterEach(() => {
-  //   jest.clearAllMocks();
-  // });
-  const deferredDbSaver = new DeferredDbSaver(dbApiMock$);
-
-  it('should enqueue IPFS content', async () => {
-    const content: IPFSContent = {
-      cid: 'Qm1234567890',
-      textPreview: 'Hello, World!',
-      source: 'node',
-      meta: { size: 123, mime: 'text/plain', type: 'file' },
-    };
-    deferredDbSaver.enqueueIpfsContent(content);
-    deferredDbSaver.enqueueIpfsContent({ ...content, cid: 'Qm1111' });
-
-    expect(deferredDbSaver.queue.size).toBe(2);
-
-    const queueItem = deferredDbSaver.queue.get(content?.cid);
-    expect(queueItem).toBeDefined();
-
-    dbApiMock$.next({} as DbApi);
-
-    expect(deferredDbSaver.queue.size).toBe(0);
-    return Promise.resolve();
-  });
-});
diff --git a/src/services/backend/services/DeferredDbSaver/DeferredDbSaver.ts b/src/services/backend/services/DeferredDbSaver/DeferredDbSaver.ts
deleted file mode 100644
index 28ebede05..000000000
--- a/src/services/backend/services/DeferredDbSaver/DeferredDbSaver.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-import {
-  BehaviorSubject,
-  defer,
-  Observable,
-  filter,
-  from,
-  mergeMap,
-  tap,
-} from 'rxjs';
-import { IDeferredDbSaver } from 'src/services/QueueManager/types';
-import { IPFSContent, IPFSContentMaybe } from 'src/services/ipfs/types';
-
-import { v4 as uuidv4 } from 'uuid';
-import { ParticleCid } from 'src/types/base';
-import { mapParticleToEntity } from 'src/services/CozoDb/mapping';
-import DbApi from '../DbApi/DbApi';
-import { LinkDto } from 'src/services/CozoDb/types/dto';
-
-type QueueItem = {
-  content?: IPFSContent;
-  links?: LinkDto[];
-};
-
-type QueueMap = Map<ParticleCid | typeof uuidv4, QueueItem>;
-
-class DeferredDbSaver implements IDeferredDbSaver {
-  private queue$ = new BehaviorSubject<QueueMap>(new Map());
-
-  private dbApi: DbApi | undefined;
-
-  public get queue(): QueueMap {
-    return this.queue$.getValue();
-  }
-
-  constructor(dbInstance$: Observable<DbApi | undefined>) {
-    dbInstance$.subscribe((db) => {
-      this.dbApi = db;
-    });
-
-    dbInstance$
-      .pipe(
-        filter((dbInstance) => !!dbInstance),
-        tap(() => cyblog.info('DeferredDbSaver - initialized')),
-        mergeMap(() => this.queue$), // Merge the queue$ stream here.
-        filter((queue) => queue.size > 0),
-        mergeMap((queue) => defer(() => from(this.processQueue(queue))))
-      )
-      .subscribe({
-        // next: () => console.log('Queue processed'),
-        error: (err) => console.error('Error processing IPFS queue', err),
-      });
-  }
-
-  public enqueueIpfsContent(content: IPFSContentMaybe) {
-    if (!content) {
-      return;
-    }
-    const { cid } = content;
-
-    this.queue$.next(new Map(this.queue$.value).set(cid, { content }));
-  }
-
-  public enqueueLinks(links: LinkDto[]) {
-    if (!links || !links.length) {
-      return;
-    }
-    const id = uuidv4();
-    this.queue$.next(new Map(this.queue$.value).set(id, { links }));
-  }
-
-  private async processQueue(queue: QueueMap) {
-    // const processingQueue = new Map(this.queue$.value); // Snapshot of the current queue
-    this.queue$.next(new Map());
-    // eslint-disable-next-line no-restricted-syntax
-    for (const [cid, item] of queue) {
-      // eslint-disable-next-line no-await-in-loop
-      await this.processQueueItem(item);
-      // console.log(' deffered DB done ', cid, item);
-
-      queue.delete(cid);
-    }
-    // this.queue$.next(queue);
-  }
-
-  private async processQueueItem(queueItem: QueueItem) {
-    const { content, links } = queueItem;
-    // console.log(`PostProcessing queue item: ${cid}`, item);
-    if (content) {
-      // eslint-disable-next-line no-await-in-loop
-      const entity = mapParticleToEntity(content);
-      await this.dbApi!.putParticles(entity);
-    }
-
-    if (links && links.length > 0) {
-      // eslint-disable-next-line no-await-in-loop
-      await this.dbApi!.putCyberlinks(links);
-    }
-  }
-}
-
-export default DeferredDbSaver;
diff --git a/src/services/backend/services/sync/services/ParticlesResolverQueue/ParticlesResolverQueue.test.ts b/src/services/backend/services/sync/services/ParticlesResolverQueue/ParticlesResolverQueue.test.ts
index 0c0c3c261..fe552344b 100644
--- a/src/services/backend/services/sync/services/ParticlesResolverQueue/ParticlesResolverQueue.test.ts
+++ b/src/services/backend/services/sync/services/ParticlesResolverQueue/ParticlesResolverQueue.test.ts
@@ -29,6 +29,7 @@ describe('ParticlesResolverQueue', () => {
       {
         id: 'mockId',
         priority: 1,
+        jobType: 1,
       },
     ];
     const mockServiceDeps: ServiceDeps = {
@@ -83,10 +84,12 @@ describe('ParticlesResolverQueue', () => {
       {
         id: 'mockToOk',
         priority: 1,
+        jobType: 1,
       },
       {
         id: 'mockToNotFound',
         priority: 1,
+        jobType: 1,
       },
     ];
     syncQueue.enqueue(mockItems);
diff --git a/src/services/backend/services/sync/services/ParticlesResolverQueue/ParticlesResolverQueue.ts b/src/services/backend/services/sync/services/ParticlesResolverQueue/ParticlesResolverQueue.ts
index e3a4e5b3c..0380b8162 100644
--- a/src/services/backend/services/sync/services/ParticlesResolverQueue/ParticlesResolverQueue.ts
+++ b/src/services/backend/services/sync/services/ParticlesResolverQueue/ParticlesResolverQueue.ts
@@ -8,27 +8,68 @@ import {
   combineLatest,
   share,
   EMPTY,
+  Subject,
+  first,
 } from 'rxjs';
 import BroadcastChannelSender from 'src/services/backend/channels/BroadcastChannelSender';
 import { broadcastStatus } from 'src/services/backend/channels/broadcastStatus';
 import { ParticleCid } from 'src/types/base';
-import { SyncQueueStatus } from 'src/services/CozoDb/types/entities';
+import {
+  SyncQueueJobType,
+  SyncQueueStatus,
+} from 'src/services/CozoDb/types/entities';
 import { QueuePriority } from 'src/services/QueueManager/types';
 import { asyncIterableBatchProcessor } from 'src/utils/async/iterable';
 
-import DbApi from '../../../DbApi/DbApi';
+import { enqueueParticleEmbeddingMaybe } from 'src/services/backend/channels/BackendQueueChannel/backendQueueSenders';
+
+import { PATTERN_COSMOS, PATTERN_CYBER } from 'src/constants/patterns';
+import { EmbeddingApi } from 'src/services/backend/workers/background/api/mlApi';
+import { Option } from 'src/types';
 
+import { IPFSContent } from 'src/services/ipfs/types';
 import { FetchIpfsFunc } from '../../types';
 import { ServiceDeps } from '../types';
 import { SyncQueueItem } from './types';
 import { MAX_DATABASE_PUT_SIZE } from '../consts';
 
+import DbApi from '../../../DbApi/DbApi';
+
 const QUEUE_BATCH_SIZE = 100;
 
+const getContentToEmbed = async (content: IPFSContent) => {
+  const contentType = content?.meta?.contentType || '';
+
+  // create embedding for allowed content
+  if (contentType === 'text') {
+    return [contentType, content.textPreview];
+  }
+
+  return [contentType, undefined];
+};
+
+export const getTextContentIfShouldEmbed = async (content: IPFSContent) => {
+  const [contentType, data] = await getContentToEmbed(content);
+
+  let shouldEmbed = contentType === 'text' && !!data;
+
+  shouldEmbed =
+    shouldEmbed &&
+    (!data!.match(PATTERN_COSMOS) || !data!.match(PATTERN_CYBER));
+
+  return shouldEmbed ? data : undefined;
+};
+
 class ParticlesResolverQueue {
   public isInitialized$: Observable<boolean>;
 
-  private db: DbApi | undefined;
+  private db: Option<DbApi>;
+
+  private embeddingApi: Option<EmbeddingApi>;
+
+  private get canEmbed() {
+    return !!this.embeddingApi;
+  }
 
   private waitForParticleResolve: FetchIpfsFunc;
 
@@ -55,11 +96,23 @@ class ParticlesResolverQueue {
 
     this.waitForParticleResolve = deps.waitForParticleResolve;
 
-    deps.dbInstance$.subscribe(async (db) => {
-      this.db = db;
-      await this.loadSyncQueue();
+    deps.embeddingApi$.subscribe((embeddingApi) => {
+      this.embeddingApi = embeddingApi;
+      // if embedding function is provided, retriger the queue
+      if (this.queue.size > 0) {
+        this._syncQueue$.next(this.queue);
+      }
     });
 
+    deps.dbInstance$
+      .pipe(
+        first((value) => value !== undefined) // Automatically unsubscribes after the first valid value
+      )
+      .subscribe(async (db) => {
+        this.db = db;
+        await this.loadSyncQueue();
+      });
+
     this.isInitialized$ = combineLatest([
       deps.dbInstance$,
       deps.ipfsInstance$,
@@ -68,6 +121,37 @@ class ParticlesResolverQueue {
     );
   }
 
+  private async resolveIpfsParticle(id: ParticleCid, priority: QueuePriority) {
+    return this.waitForParticleResolve(id, priority)
+      .then(async ({ status, result }) => {
+        const isResolved = status !== 'not_found';
+        if (!isResolved || !result) {
+          return false;
+        }
+
+        await enqueueParticleEmbeddingMaybe(result);
+        return true;
+      })
+      .catch(() => false);
+  }
+
+  private async saveEmbedding(cid: ParticleCid, text: string) {
+    try {
+      const hasItem = await this.db!.existEmbedding(cid);
+
+      if (!hasItem) {
+        const vec = await this.embeddingApi!.createEmbedding(text);
+
+        const result = await this.db!.putEmbedding(cid, vec);
+      }
+
+      return true;
+    } catch (err) {
+      console.error(`saveEmbedding error: ${cid} - ${text} `, err.toString());
+      return false;
+    }
+  }
+
   private async processSyncQueue(pendingItems: SyncQueueItem[]) {
     // console.log('------processSyncQueue ', pendingItems);
 
@@ -81,32 +165,40 @@ class ParticlesResolverQueue {
     let i = batchSize;
     await Promise.all(
       pendingItems.map(async (item) => {
-        const { id } = item;
-        // eslint-disable-next-line no-await-in-loop
-        return this.waitForParticleResolve(id, QueuePriority.MEDIUM).then(
-          async (result) => {
-            if (result.status === 'not_found') {
-              await this.db!.updateSyncQueue({
-                id,
-                status: SyncQueueStatus.error,
-              });
-            } else {
-              await this.db!.removeSyncQueue(id);
-            }
+        const { id, jobType, data } = item;
 
-            const queue = this._syncQueue$.value;
-            queue.delete(id);
-            i--;
-            this._syncQueue$.next(queue);
+        let jobPromise = Promise.resolve(false);
 
-            this.statusApi.sendStatus(
-              'in-progress',
-              `processing batch ${batchSize - i}/${batchSize} batch. ${
-                this.queue.size
-              } pending...`
-            );
+        if (jobType === SyncQueueJobType.embedding && data) {
+          jobPromise = this.saveEmbedding(id, data as string);
+        } else if (jobType === SyncQueueJobType.particle) {
+          jobPromise = this.resolveIpfsParticle(id, QueuePriority.MEDIUM);
+        }
+
+        // eslint-disable-next-line no-await-in-loop
+        return jobPromise.then(async (result) => {
+          if (result) {
+            await this.db!.removeSyncQueue({ id, jobType });
+          } else {
+            await this.db!.updateSyncQueue({
+              id,
+              jobType,
+              status: SyncQueueStatus.error,
+            });
           }
-        );
+
+          const queue = this._syncQueue$.value;
+          queue.delete(id);
+          i--;
+          this._syncQueue$.next(queue);
+
+          this.statusApi.sendStatus(
+            'in-progress',
+            `processing batch ${batchSize - i}/${batchSize} batch. ${
+              this.queue.size
+            } pending...`
+          );
+        });
       })
     );
   }
@@ -127,9 +219,15 @@ class ParticlesResolverQueue {
 
         const batchSize = QUEUE_BATCH_SIZE - executingCount;
 
+        const jobTypeFilter = (i: SyncQueueItem) =>
+          i.jobType === SyncQueueJobType.particle ||
+          (i.jobType === SyncQueueJobType.embedding && this.canEmbed);
+
         if (batchSize > 0) {
           const pendingItems = list
-            .filter((i) => i.status === SyncQueueStatus.pending)
+            .filter(
+              (i) => i.status === SyncQueueStatus.pending && jobTypeFilter(i)
+            )
             .sort((a, b) => {
               return a.priority - b.priority;
             })
@@ -166,11 +264,11 @@ class ParticlesResolverQueue {
     return this;
   }
 
-  public async fetchDirect(cid: ParticleCid) {
-    return this.waitForParticleResolve(cid, QueuePriority.URGENT);
-  }
-
-  public async enqueueBatch(cids: ParticleCid[], priority: QueuePriority) {
+  public async enqueueBatch(
+    cids: ParticleCid[],
+    jobType: SyncQueueJobType,
+    priority: QueuePriority
+  ) {
     return asyncIterableBatchProcessor(
       cids,
       (cids) =>
@@ -178,6 +276,7 @@ class ParticlesResolverQueue {
           cids.map((cid) => ({
             id: cid /* from is tweet */,
             priority,
+            jobType,
           }))
         ),
       MAX_DATABASE_PUT_SIZE
@@ -188,7 +287,9 @@ class ParticlesResolverQueue {
     if (items.length === 0) {
       return;
     }
-    await this.db!.putSyncQueue(items);
+
+    const result = await this.db!.putSyncQueue(items);
+
     const queue = this._syncQueue$.value;
 
     items.forEach((item) =>
diff --git a/src/services/backend/services/sync/services/SyncIpfsLoop/SyncIpfsLoop.ts b/src/services/backend/services/sync/services/SyncIpfsLoop/SyncIpfsLoop.ts
index a8649847d..f9db00282 100644
--- a/src/services/backend/services/sync/services/SyncIpfsLoop/SyncIpfsLoop.ts
+++ b/src/services/backend/services/sync/services/SyncIpfsLoop/SyncIpfsLoop.ts
@@ -12,6 +12,7 @@ import { createLoopObservable } from '../utils/rxjs/loop';
 import { IPFS_SYNC_INTERVAL } from '../consts';
 import { fetchPins } from './services';
 import ParticlesResolverQueue from '../ParticlesResolverQueue/ParticlesResolverQueue';
+import { SyncQueueJobType } from 'src/services/CozoDb/types/entities';
 
 class SyncIpfsLoop {
   private isInitialized$: Observable<boolean>;
@@ -112,6 +113,7 @@ class SyncIpfsLoop {
         await this.particlesResolver!.enqueue(
           particlesToAdd.map((cid) => ({
             id: cid,
+            jobType: SyncQueueJobType.particle,
             priority: QueuePriority.LOW,
           }))
         );
diff --git a/src/services/backend/services/sync/services/SyncMyFriendsLoop/SyncMyFriendsLoop.ts b/src/services/backend/services/sync/services/SyncMyFriendsLoop/SyncMyFriendsLoop.ts
index a8323f972..2fe3123d4 100644
--- a/src/services/backend/services/sync/services/SyncMyFriendsLoop/SyncMyFriendsLoop.ts
+++ b/src/services/backend/services/sync/services/SyncMyFriendsLoop/SyncMyFriendsLoop.ts
@@ -6,7 +6,10 @@ import {
   BehaviorSubject,
 } from 'rxjs';
 
-import { EntryType } from 'src/services/CozoDb/types/entities';
+import {
+  EntryType,
+  SyncQueueJobType,
+} from 'src/services/CozoDb/types/entities';
 
 import { NeuronAddress } from 'src/types/base';
 import { QueuePriority } from 'src/services/QueueManager/types';
@@ -170,6 +173,7 @@ class SyncMyFriendsLoop extends BaseSyncLoop {
           const particles = links.map((t) => t.to);
           await this.particlesResolver!.enqueueBatch(
             particles,
+            SyncQueueJobType.particle,
             QueuePriority.HIGH
           );
 
diff --git a/src/services/backend/services/sync/services/SyncTransactionsLoop/SyncTransactionsLoop.ts b/src/services/backend/services/sync/services/SyncTransactionsLoop/SyncTransactionsLoop.ts
index 6be187646..bb479f265 100644
--- a/src/services/backend/services/sync/services/SyncTransactionsLoop/SyncTransactionsLoop.ts
+++ b/src/services/backend/services/sync/services/SyncTransactionsLoop/SyncTransactionsLoop.ts
@@ -11,7 +11,10 @@ import {
 } from 'rxjs';
 import { isEmpty } from 'lodash';
 
-import { EntryType } from 'src/services/CozoDb/types/entities';
+import {
+  EntryType,
+  SyncQueueJobType,
+} from 'src/services/CozoDb/types/entities';
 import { mapIndexerTransactionToEntity } from 'src/services/CozoDb/mapping';
 import { numberToUtcDate } from 'src/utils/date';
 import { NeuronAddress } from 'src/types/base';
@@ -338,6 +341,7 @@ class SyncTransactionsLoop extends BaseSyncClient {
     // pre-resolve 'tweets' particles
     await this.particlesResolver!.enqueueBatch(
       tweetParticles,
+      SyncQueueJobType.particle,
       QueuePriority.HIGH
     );
 
@@ -345,6 +349,7 @@ class SyncTransactionsLoop extends BaseSyncClient {
     if (nonTweetParticles.length > 0) {
       await this.particlesResolver!.enqueueBatch(
         nonTweetParticles,
+        SyncQueueJobType.particle,
         QueuePriority.LOW
       );
     }
diff --git a/src/services/backend/services/sync/services/types.ts b/src/services/backend/services/sync/services/types.ts
index ffd05ca4d..b63415257 100644
--- a/src/services/backend/services/sync/services/types.ts
+++ b/src/services/backend/services/sync/services/types.ts
@@ -1,13 +1,16 @@
 import { Observable } from 'rxjs';
 import { CybIpfsNode } from 'src/services/ipfs/types';
+import { NeuronAddress } from 'src/types/base';
+import { EmbeddingApi } from 'src/services/backend/workers/background/api/mlApi';
+
 import DbApi from '../../DbApi/DbApi';
 import { FetchIpfsFunc, SyncServiceParams } from '../types';
-import { NeuronAddress } from 'src/types/base';
 
 export type ServiceDeps = {
   dbInstance$: Observable<DbApi | undefined>;
   ipfsInstance$: Observable<CybIpfsNode | undefined>;
   params$: Observable<SyncServiceParams> | undefined;
-  followings$: Observable<NeuronAddress[]> | undefined;
+  followings$?: Observable<NeuronAddress[]>;
+  embeddingApi$: Observable<EmbeddingApi>;
   waitForParticleResolve?: FetchIpfsFunc;
 };
diff --git a/src/services/backend/services/sync/services/utils/links.ts b/src/services/backend/services/sync/services/utils/links.ts
index 9e0138a71..6b338f3e8 100644
--- a/src/services/backend/services/sync/services/utils/links.ts
+++ b/src/services/backend/services/sync/services/utils/links.ts
@@ -11,6 +11,7 @@ import {
   CYBER_LINK_TRANSACTION_TYPE,
   CyberLinkValue,
 } from '../../../indexer/types';
+import { SyncQueueJobType } from 'src/services/CozoDb/types/entities';
 
 const getUniqueParticlesFromLinks = (links: CyberLinkSimple[]) =>
   [
@@ -42,7 +43,11 @@ export const fetchCyberlinksAndResolveParticles = async (
       await asyncIterableBatchProcessor(
         particles,
         (cids: ParticleCid[]) =>
-          particlesResolver!.enqueueBatch(cids, queuePriority),
+          particlesResolver!.enqueueBatch(
+            cids,
+            SyncQueueJobType.particle,
+            queuePriority
+          ),
         MAX_LINKS_RESOLVE_BATCH
       );
     }
diff --git a/src/services/backend/services/sync/sync.ts b/src/services/backend/services/sync/sync.ts
index 2d58233c4..713c51583 100644
--- a/src/services/backend/services/sync/sync.ts
+++ b/src/services/backend/services/sync/sync.ts
@@ -20,6 +20,7 @@ import { SyncEntryName } from '../../types/services';
 import BaseSyncLoop from './services/BaseSyncLoop/BaseSyncLoop';
 import createCommunitySync$ from './services/CommunitySync/CommunitySync';
 import { createCyblogChannel } from 'src/utils/logging/cyblog';
+import BackendQueueChannelListener from '../../channels/BackendQueueChannel/BackendQueueChannel';
 
 const cyblogCh = createCyblogChannel({ thread: 'bckd' });
 
@@ -33,6 +34,14 @@ export class SyncService {
 
   constructor(deps: ServiceDeps) {
     const { dbInstance$, ipfsInstance$ } = deps;
+
+    const particlesResolver = new ParticlesResolverQueue(deps).start();
+
+    const queueListener = new BackendQueueChannelListener(
+      particlesResolver,
+      dbInstance$
+    );
+
     this.isInitialized$ = combineLatest([dbInstance$, ipfsInstance$]).pipe(
       map(([dbInstance, ipfsInstance]) => !!dbInstance && !!ipfsInstance)
     );
@@ -44,8 +53,6 @@ export class SyncService {
       error: (err) => this.channelApi.postServiceStatus('sync', 'error', err),
     });
 
-    const particlesResolver = new ParticlesResolverQueue(deps).start();
-
     const communitySync$ = createCommunitySync$(deps);
     communitySync$.subscribe((community) => {
       cyblogCh.info('--> community fetched', {
diff --git a/src/services/backend/types/services.ts b/src/services/backend/types/services.ts
index 38b7a8dc8..afb6a7862 100644
--- a/src/services/backend/types/services.ts
+++ b/src/services/backend/types/services.ts
@@ -34,6 +34,7 @@ export type SyncProgress = Partial<{
 export type ServiceStatus = 'inactive' | 'starting' | 'started' | 'error';
 
 export type SyncEntryStatus = Record<SyncEntryName, SyncProgress>;
+export type SyncMlEntryStatus = Record<string, SyncProgress>;
 
 export type SyncState = {
   entryStatus: Partial<SyncEntryStatus>;
@@ -41,10 +42,14 @@ export type SyncState = {
   totalEstimatedTime: number;
   message: string;
   inProgress: boolean;
-  completeIntialSyncEntries: SyncEntryName[];
+  completeIntialSyncEntries: SyncEntryName[] | string[];
   initialSyncDone: boolean;
 };
 
+export type MlSyncState = {
+  entryStatus: Partial<SyncMlEntryStatus>;
+};
+
 export type SyncStatusMessage = {
   type: 'sync_status';
   value: Omit<SyncState, 'entryStatus'>;
@@ -58,7 +63,15 @@ export type SyncEntryMessage = {
   };
 };
 
-export type ServiceName = 'db' | 'ipfs' | 'sync';
+export type SyncMlEntryMessage = {
+  type: 'sync_ml_entry';
+  value: {
+    entry: string;
+    state: SyncProgress;
+  };
+};
+
+export type ServiceName = 'db' | 'ipfs' | 'sync' | 'ml' | 'rune';
 
 export type ServiceStatusMessage = {
   type: 'service_status';
@@ -87,6 +100,7 @@ export type BroadcastChannelMessage =
   | IndexedDbWriteMessage
   | ServiceStatusMessage
   | LoadCommunityMessage
+  | SyncMlEntryMessage
   | SetDefaultAccountMessage;
 // | SenseListUpdate
 // | SenseListRemove;
@@ -98,6 +112,8 @@ export const getBroadcastChannemMessageKey = (msg: BroadcastChannelMessage) => {
       return `${type}_${value.name}`;
     case 'sync_entry':
       return `${type}_${value.entry}`;
+    case 'sync_ml_entry':
+      return `${type}_${value.entry}`;
     case 'sync_status':
     default:
       return type;
diff --git a/src/services/backend/workers/background/api/ipfsApi.ts b/src/services/backend/workers/background/api/ipfsApi.ts
new file mode 100644
index 000000000..9006eb6ad
--- /dev/null
+++ b/src/services/backend/workers/background/api/ipfsApi.ts
@@ -0,0 +1,96 @@
+import { proxy } from 'comlink';
+import { BehaviorSubject, Subject } from 'rxjs';
+import QueueManager from 'src/services/QueueManager/QueueManager';
+import {
+  QueueItemCallback,
+  QueueItemOptions,
+} from 'src/services/QueueManager/types';
+import BroadcastChannelSender from 'src/services/backend/channels/BroadcastChannelSender';
+import { initIpfsNode } from 'src/services/ipfs/node/factory';
+
+import {
+  CybIpfsNode,
+  IpfsContentType,
+  IpfsOptsType,
+} from 'src/services/ipfs/types';
+import { RuneEngine } from 'src/services/scripting/engine';
+
+// eslint-disable-next-line import/prefer-default-export
+export const createIpfsApi = (
+  rune: RuneEngine,
+  broadcastApi: BroadcastChannelSender
+) => {
+  const ipfsInstance$ = new BehaviorSubject<CybIpfsNode | undefined>(undefined);
+  const ipfsQueue = new QueueManager(ipfsInstance$, {
+    rune,
+  });
+  const stopIpfs = async () => {
+    const ipfsNode = ipfsInstance$.getValue();
+
+    if (ipfsNode) {
+      await ipfsNode.stop();
+    }
+    ipfsInstance$.next(undefined);
+    broadcastApi.postServiceStatus('ipfs', 'inactive');
+  };
+
+  const startIpfs = async (ipfsOpts: IpfsOptsType) => {
+    try {
+      const ipfsNode = ipfsInstance$.getValue();
+      if (ipfsNode) {
+        // console.log('Ipfs node already started!');
+        setTimeout(() => broadcastApi.postServiceStatus('ipfs', 'started'), 0);
+        return Promise.resolve();
+        // await ipfsNode.stop();
+      }
+      broadcastApi.postServiceStatus('ipfs', 'starting');
+      console.time('🔋 ipfs initialized');
+
+      const newIpfsNode = await initIpfsNode(ipfsOpts);
+      console.timeEnd('🔋 ipfs initialized');
+
+      ipfsInstance$.next(newIpfsNode);
+      setTimeout(() => broadcastApi.postServiceStatus('ipfs', 'started'), 0);
+      return true;
+    } catch (err) {
+      console.log('----ipfs node init error ', err);
+      const msg = err instanceof Error ? err.message : (err as string);
+      broadcastApi.postServiceStatus('ipfs', 'error', msg);
+      throw Error(msg);
+    }
+  };
+
+  const api = {
+    start: startIpfs,
+    stop: stopIpfs,
+    config: async () => ipfsInstance$.getValue()?.config,
+    info: async () => ipfsInstance$.getValue()?.info(),
+    fetchWithDetails: async (
+      cid: string,
+      parseAs?: IpfsContentType,
+      controller?: AbortController
+    ) => {
+      const ipfsNode = ipfsInstance$.getValue();
+      if (!ipfsNode) {
+        throw new Error('ipfs node not initialized');
+      }
+      return ipfsNode.fetchWithDetails(cid, parseAs, controller);
+    },
+    enqueue: async (
+      cid: string,
+      callback: QueueItemCallback,
+      options: QueueItemOptions
+    ) => ipfsQueue.enqueue(cid, callback, options),
+    enqueueAndWait: async (cid: string, options?: QueueItemOptions) =>
+      ipfsQueue!.enqueueAndWait(cid, options),
+    dequeue: async (cid: string) => ipfsQueue.cancel(cid),
+    dequeueByParent: async (parent: string) => ipfsQueue.cancelByParent(parent),
+    clearQueue: async () => ipfsQueue.clear(),
+    addContent: async (content: string | File) =>
+      ipfsInstance$.getValue()?.addContent(content),
+  };
+
+  return { ipfsInstance$, ipfsQueue, api };
+};
+
+export type IpfsApi = ReturnType<typeof createIpfsApi>['api'];
diff --git a/src/services/backend/workers/background/api/mlApi.ts b/src/services/backend/workers/background/api/mlApi.ts
new file mode 100644
index 000000000..a61c801f8
--- /dev/null
+++ b/src/services/backend/workers/background/api/mlApi.ts
@@ -0,0 +1,167 @@
+import {
+  PipelineType,
+  pipeline,
+  env,
+  FeatureExtractionPipeline,
+} from '@xenova/transformers';
+import BroadcastChannelSender from 'src/services/backend/channels/BroadcastChannelSender';
+import DbApiWrapper from 'src/services/backend/services/DbApi/DbApi';
+import {
+  Subject,
+  combineLatest,
+  Observable,
+  shareReplay,
+  ReplaySubject,
+  filter,
+} from 'rxjs';
+import { proxy } from 'comlink';
+
+env.allowLocalModels = false;
+
+type MlModelParams = {
+  name: PipelineType;
+  model: string;
+};
+const mlModelMap: Record<string, MlModelParams> = {
+  featureExtractor: {
+    name: 'feature-extraction',
+    model: 'Xenova/all-MiniLM-L6-v2',
+  },
+  // summarization: {
+  //   name: 'summarization',
+  //   model: 'ahmedaeb/distilbart-cnn-6-6-optimised',
+  // },
+  // qa: {
+  //   name: 'question-answering',
+  //   model: 'Xenova/distilbert-base-uncased-distilled-squad',
+  // },
+};
+
+const loadPipeline = (
+  name: PipelineType,
+  model: string,
+  onProgress: (data: any) => void
+) => {
+  return pipeline(name, model, {
+    progress_callback: (progressData: any) => {
+      try {
+        const {
+          status,
+          progress,
+          // name: modelName,
+          loaded,
+          total,
+        } = progressData;
+
+        const message = loaded ? `${model} - ${loaded}/${total} bytes` : model;
+
+        const done = ['ready', 'error'].some((s) => s === status);
+
+        const progrssStateItem = {
+          status,
+          message,
+          done,
+          progress: progress ? Math.round(progress) : 0,
+        };
+        // console.log('progress_callback', name, progressData);
+
+        onProgress(progrssStateItem);
+      } catch (e) {
+        console.log('-------progresss error', model, e.toString());
+      }
+    },
+  });
+};
+
+export type EmbeddingApi = {
+  createEmbedding: (text: string) => Promise<number[]>;
+  searchByEmbedding: (
+    text: string,
+    count?: number
+  ) => ReturnType<DbApiWrapper['searchByEmbedding']>;
+};
+
+const createEmbeddingApi$ = (
+  dbInstance$: Subject<DbApiWrapper>,
+  featureExtractor$: Subject<FeatureExtractionPipeline>
+) => {
+  const replaySubject = new ReplaySubject(1);
+
+  combineLatest([dbInstance$, featureExtractor$]).subscribe(
+    ([dbInstance, featureExtractor]) => {
+      if (dbInstance && featureExtractor) {
+        const createEmbedding = async (text: string) => {
+          const output = await featureExtractor(text, {
+            pooling: 'mean',
+            normalize: true,
+          });
+
+          return output.data as number[];
+        };
+
+        const searchByEmbedding = async (text: string, count?: number) => {
+          const vec = await createEmbedding(text);
+          // console.log('----searchByEmbedding', vec);
+
+          const rows = await dbInstance.searchByEmbedding(vec, count);
+          //   console.log('----searcByEmbedding rows', rows);
+
+          return rows;
+        };
+
+        const api = {
+          createEmbedding,
+          searchByEmbedding,
+        };
+        replaySubject.next(proxy(api));
+      }
+    }
+  );
+  // .pipe(filter((v) => !!v))
+  return replaySubject as Observable<EmbeddingApi>;
+};
+
+// eslint-disable-next-line import/no-unused-modules, import/prefer-default-export
+export const createMlApi = (
+  dbInstance$: Subject<DbApiWrapper>,
+  broadcastApi: BroadcastChannelSender
+) => {
+  const featureExtractor$ = new Subject<FeatureExtractionPipeline>();
+  const embeddingApi$ = createEmbeddingApi$(dbInstance$, featureExtractor$);
+
+  const initPipelineInstance = async (alias: keyof typeof mlModelMap) => {
+    const { name, model } = mlModelMap[alias];
+
+    const pipeline = await loadPipeline(name, model, (data) =>
+      broadcastApi.postMlSyncEntryProgress(alias, data)
+    );
+    if (name === 'feature-extraction') {
+      featureExtractor$.next(pipeline as FeatureExtractionPipeline);
+    }
+    console.log(`${alias} - loaded`);
+  };
+
+  const init = async () => {
+    broadcastApi.postServiceStatus('ml', 'starting');
+    console.time('🔋 ml initialized');
+
+    return Promise.all([
+      initPipelineInstance('featureExtractor'),
+      // initMlInstance('summarization'),
+      // initMlInstance('qa'),
+    ])
+      .then((result) => {
+        setTimeout(() => broadcastApi.postServiceStatus('ml', 'started'), 0);
+        console.timeEnd('🔋 ml initialized');
+
+        return result;
+      })
+      .catch((e) =>
+        broadcastApi.postServiceStatus('ml', 'error', e.toString())
+      );
+  };
+
+  init();
+
+  return { embeddingApi$, init };
+};
diff --git a/src/services/backend/workers/background/api/runeApi.ts b/src/services/backend/workers/background/api/runeApi.ts
new file mode 100644
index 000000000..8eb2ecbeb
--- /dev/null
+++ b/src/services/backend/workers/background/api/runeApi.ts
@@ -0,0 +1,41 @@
+import { Observable, Subject } from 'rxjs';
+import BroadcastChannelSender from 'src/services/backend/channels/BroadcastChannelSender';
+import rune, { LoadParams, RuneEngine } from 'src/services/scripting/engine';
+import runeDeps, { RuneInnerDeps } from 'src/services/scripting/runeDeps';
+import DbApiWrapper from 'src/services/backend/services/DbApi/DbApi';
+import { EmbeddingApi } from './mlApi';
+
+// eslint-disable-next-line import/no-unused-modules, import/prefer-default-export
+export const createRuneApi = (
+  embeddingApi$: Observable<EmbeddingApi>,
+  dbInstance$: Observable<DbApiWrapper>,
+  broadcastApi: BroadcastChannelSender
+) => {
+  const setInnerDeps = (deps: Partial<RuneInnerDeps>) =>
+    runeDeps.setInnerDeps(deps);
+
+  embeddingApi$.subscribe((embeddingApi) => {
+    setInnerDeps({ embeddingApi });
+  });
+
+  dbInstance$.subscribe((dbApi) => {
+    setInnerDeps({ dbApi });
+  });
+
+  rune.isSoulInitialized$.subscribe((value) => {
+    value
+      ? setTimeout(() => broadcastApi.postServiceStatus('rune', 'started'), 0)
+      : broadcastApi.postServiceStatus('rune', 'inactive');
+  });
+
+  const init = async () => {
+    broadcastApi.postServiceStatus('rune', 'starting');
+
+    await rune.init();
+    setInnerDeps({ rune });
+  };
+
+  init();
+
+  return { rune, setInnerDeps };
+};
diff --git a/src/services/backend/workers/background/worker.ts b/src/services/backend/workers/background/worker.ts
index b842f4282..0ac846fad 100644
--- a/src/services/backend/workers/background/worker.ts
+++ b/src/services/backend/workers/background/worker.ts
@@ -1,25 +1,9 @@
-import { ProxyMarked, Remote, proxy } from 'comlink';
+import { proxy } from 'comlink';
 
-import { initIpfsNode } from 'src/services/ipfs/node/factory';
-
-import {
-  CybIpfsNode,
-  IpfsContentType,
-  IpfsOptsType,
-} from 'src/services/ipfs/types';
-
-import QueueManager from 'src/services/QueueManager/QueueManager';
-
-// import { CozoDbWorkerApi } from 'src/services/backend/workers/db/worker';
-
-import {
-  QueueItemCallback,
-  QueueItemOptions,
-  QueuePriority,
-} from 'src/services/QueueManager/types';
+import { QueuePriority } from 'src/services/QueueManager/types';
 import { ParticleCid } from 'src/types/base';
-import { LinkDto } from 'src/services/CozoDb/types/dto';
 import { BehaviorSubject, Subject } from 'rxjs';
+import { RuneInnerDeps } from 'src/services/scripting/runeDeps';
 
 import { exposeWorkerApi } from '../factoryMethods';
 
@@ -29,113 +13,76 @@ import { SyncServiceParams } from '../../services/sync/types';
 import DbApi from '../../services/DbApi/DbApi';
 
 import BroadcastChannelSender from '../../channels/BroadcastChannelSender';
-import DeferredDbSaver from '../../services/DeferredDbSaver/DeferredDbSaver';
-import { SyncEntryName } from '../../types/services';
+import { createIpfsApi } from './api/ipfsApi';
+import { createMlApi } from './api/mlApi';
+import { createRuneApi } from './api/runeApi';
+
+// import { initRuneDeps } from 'src/services/scripting/wasmBindings';
 
 const createBackgroundWorkerApi = () => {
-  const dbInstance$ = new Subject<DbApi | undefined>();
+  const broadcastApi = new BroadcastChannelSender();
 
-  const ipfsInstance$ = new BehaviorSubject<CybIpfsNode | undefined>(undefined);
+  const dbInstance$ = new Subject<DbApi>();
+
+  const injectDb = (db: DbApi) => dbInstance$.next(db);
 
   const params$ = new BehaviorSubject<SyncServiceParams>({
     myAddress: null,
   });
 
-  let ipfsNode: CybIpfsNode | undefined;
-  const defferedDbSaver = new DeferredDbSaver(dbInstance$);
-
-  const ipfsQueue = new QueueManager(ipfsInstance$, {
-    defferedDbSaver,
-  });
-  const broadcastApi = new BroadcastChannelSender();
+  const { embeddingApi$ } = createMlApi(dbInstance$, broadcastApi);
 
-  // service to sync updates about cyberlinks, transactions, swarm etc.
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const syncService = new SyncService({
-    waitForParticleResolve: async (
-      cid: ParticleCid,
-      priority: QueuePriority = QueuePriority.MEDIUM
-    ) => ipfsQueue.enqueueAndWait(cid, { postProcessing: true, priority }),
+  const { setInnerDeps, rune } = createRuneApi(
+    embeddingApi$,
     dbInstance$,
-    ipfsInstance$,
-    params$,
-  });
+    broadcastApi
+  );
 
-  const init = async (dbApiProxy: DbApi & ProxyMarked) => {
-    dbInstance$.next(dbApiProxy);
-  };
+  const {
+    ipfsQueue,
+    ipfsInstance$,
+    api: ipfsApi,
+  } = createIpfsApi(rune, broadcastApi);
 
-  const stopIpfs = async () => {
-    if (ipfsNode) {
-      await ipfsNode.stop();
-    }
-    ipfsInstance$.next(undefined);
-    broadcastApi.postServiceStatus('ipfs', 'inactive');
-  };
+  const waitForParticleResolve = (
+    cid: ParticleCid,
+    priority: QueuePriority = QueuePriority.MEDIUM
+  ) => ipfsQueue.enqueueAndWait(cid, { postProcessing: false, priority });
 
-  const startIpfs = async (ipfsOpts: IpfsOptsType) => {
-    try {
-      if (ipfsNode) {
-        console.log('Ipfs node already started!');
-        await ipfsNode.stop();
-      }
-      broadcastApi.postServiceStatus('ipfs', 'starting');
-      ipfsNode = await initIpfsNode(ipfsOpts);
-
-      ipfsInstance$.next(ipfsNode);
-
-      setTimeout(() => broadcastApi.postServiceStatus('ipfs', 'started'), 0);
-      return true;
-    } catch (err) {
-      console.log('----ipfs node init error ', err);
-      const msg = err instanceof Error ? err.message : (err as string);
-      broadcastApi.postServiceStatus('ipfs', 'error', msg);
-      throw Error(msg);
-    }
+  const serviceDeps = {
+    waitForParticleResolve,
+    dbInstance$,
+    ipfsInstance$,
+    embeddingApi$,
+    params$,
   };
 
-  const defferedDbApi = {
-    importCyberlinks: (links: LinkDto[]) => {
-      defferedDbSaver.enqueueLinks(links);
-    },
-  };
+  // service to sync updates about cyberlinks, transactions, swarm etc.
+  const syncService = new SyncService(serviceDeps);
 
-  const ipfsApi = {
-    start: startIpfs,
-    stop: stopIpfs,
-    getIpfsNode: async () => ipfsNode && proxy(ipfsNode),
-    config: async () => ipfsNode?.config,
-    info: async () => ipfsNode?.info(),
-    fetchWithDetails: async (cid: string, parseAs?: IpfsContentType) =>
-      ipfsNode?.fetchWithDetails(cid, parseAs),
-    enqueue: async (
-      cid: string,
-      callback: QueueItemCallback,
-      options: QueueItemOptions
-    ) => ipfsQueue!.enqueue(cid, callback, options),
-    enqueueAndWait: async (cid: string, options?: QueueItemOptions) =>
-      ipfsQueue!.enqueueAndWait(cid, options),
-    dequeue: async (cid: string) => ipfsQueue.cancel(cid),
-    dequeueByParent: async (parent: string) => ipfsQueue.cancelByParent(parent),
-    clearQueue: async () => ipfsQueue.clear(),
-    addContent: async (content: string | File) => ipfsNode?.addContent(content),
-  };
+  // INITIALIZATION
+  setInnerDeps({ ipfsApi });
 
   return {
-    init,
-    isInitialized: () => !!ipfsInstance$.value,
+    injectDb,
+    isIpfsInitialized: () => !!ipfsInstance$.getValue(),
     // syncDrive,
     ipfsApi: proxy(ipfsApi),
-    defferedDbApi: proxy(defferedDbApi),
+    rune: proxy(rune),
+    embeddingApi$,
+    // ipfsInstance$,
     ipfsQueue: proxy(ipfsQueue),
-    restartSync: (name: SyncEntryName) => syncService.restart(name),
+    setRuneDeps: (
+      deps: Partial<Omit<RuneInnerDeps, 'embeddingApi' | 'dbApi'>>
+    ) => setInnerDeps(deps),
+    // restartSync: (name: SyncEntryName) => syncService.restart(name),
     setParams: (params: Partial<SyncServiceParams>) =>
       params$.next({ ...params$.value, ...params }),
   };
 };
 
 const backgroundWorker = createBackgroundWorkerApi();
-export type IpfsApi = Remote<typeof backgroundWorker.ipfsApi>;
+
 export type BackgroundWorker = typeof backgroundWorker;
 
 // Expose the API to the main thread as shared/regular worker
diff --git a/src/services/backend/workers/db/worker.ts b/src/services/backend/workers/db/worker.ts
index 0b7feb663..6588e6b66 100644
--- a/src/services/backend/workers/db/worker.ts
+++ b/src/services/backend/workers/db/worker.ts
@@ -5,6 +5,7 @@ import { GetCommandOptions } from 'src/services/CozoDb/types/types';
 import { exposeWorkerApi } from '../factoryMethods';
 import BroadcastChannelSender from '../../channels/BroadcastChannelSender';
 import { ServiceStatus } from '../../types/services';
+import migrate from 'src/services/CozoDb/migrations/migrations';
 
 const createDbWorkerApi = () => {
   let isInitialized = false;
@@ -17,21 +18,29 @@ const createDbWorkerApi = () => {
     postServiceStatus('starting');
 
     if (isInitialized) {
-      console.log('Db: already initialized!');
+      console.log('cozo db - already initialized!');
       postServiceStatus('started');
-      return;
+      return Promise.resolve();
     }
 
     // callback to sync writes count worker -> main thread
     const onWriteCallback = (writesCount: number) => {};
     // channel.post({ type: 'indexeddb_write', value: writesCount });
+    console.time('🔋 cozo db initialized');
 
     await cozoDb.init(onWriteCallback);
+    const reinitializeDbSchema = await migrate(cozoDb);
+    if (reinitializeDbSchema) {
+      await cozoDb.loadDbSchema();
+    }
+    console.timeEnd('🔋 cozo db initialized');
+
     isInitialized = true;
 
     setTimeout(() => {
       postServiceStatus('started');
     }, 0);
+    return Promise.resolve();
   };
 
   const runCommand = async (command: string, immutable?: boolean) =>
@@ -59,7 +68,7 @@ const createDbWorkerApi = () => {
     conditionFields?: string[],
     options: GetCommandOptions = {}
   ) =>
-    cozoDb.get(tableName, conditions, selectFields, conditionFields, options);
+    cozoDb.get(tableName, selectFields, conditions, conditionFields, options);
 
   const importRelations = async (content: string) =>
     cozoDb.importRelations(content);
@@ -77,7 +86,6 @@ const createDbWorkerApi = () => {
 
     const commandFactory = getCommandFactory();
     const putCommand = commandFactory!.generateModifyCommand(tableName, 'put');
-    let isOk = true;
     for (let i = 0; i < array.length; i += batchSize) {
       const batch = array.slice(i, i + batchSize);
 
diff --git a/src/services/backend/workers/factoryMethods.ts b/src/services/backend/workers/factoryMethods.ts
index 3497a534f..cac31ac0c 100644
--- a/src/services/backend/workers/factoryMethods.ts
+++ b/src/services/backend/workers/factoryMethods.ts
@@ -1,6 +1,13 @@
-import { wrap, Remote, expose, transferHandlers } from 'comlink';
+import {
+  wrap,
+  Remote,
+  proxy,
+  releaseProxy,
+  expose,
+  transferHandlers,
+} from 'comlink';
 import { IPFSContentTransferHandler } from './serializers';
-
+import { Observable, Observer, Subscribable, Subscription } from 'rxjs'; // v7.8.0
 type WorkerType = SharedWorker | Worker;
 
 const isSharedWorkersSupported = typeof SharedWorker !== 'undefined';
@@ -10,6 +17,65 @@ const isSharedWorkerUsed = isSharedWorkersSupported && !process.env.IS_DEV;
 // apply serializers for custom types
 function installTransferHandlers() {
   transferHandlers.set('IPFSContent', IPFSContentTransferHandler);
+  transferHandlers.set('observable', {
+    canHandle: (value: unknown): value is Observable<unknown> => {
+      return value instanceof Observable;
+    },
+    deserialize: (value: MessagePort) => {
+      return new Observable<unknown>((observer) => {
+        const remote = transferHandlers
+          .get('proxy')!
+          .deserialize(value) as Remote<Subscribable<unknown>>;
+
+        remote
+          .subscribe(
+            proxy({
+              next: (next: unknown) => observer.next(next),
+              error: (error: unknown) => observer.error(error),
+              complete: () => observer.complete(),
+            })
+          )
+          .then((subscription) =>
+            observer.add(() => {
+              subscription.unsubscribe();
+              remote[releaseProxy]();
+            })
+          );
+      });
+    },
+    serialize: (value: Observable<unknown>) => {
+      return transferHandlers.get('proxy')!.serialize({
+        subscribe: (observer: Remote<Observer<unknown>>) =>
+          value.subscribe({
+            next: (next: unknown) => observer.next(next).then(),
+            error: (error: unknown) => observer.error(error).then(),
+            complete: () => observer.complete().then(),
+          }),
+      });
+    },
+  });
+
+  transferHandlers.set('subscription', {
+    canHandle: (value: unknown): value is Subscription => {
+      return value instanceof Subscription;
+    },
+    deserialize: (value: MessagePort) => {
+      return new Subscription(() => {
+        const remote = transferHandlers
+          .get('proxy')!
+          .deserialize(value) as Remote<Subscription>;
+
+        remote.unsubscribe().then(() => {
+          remote[releaseProxy]();
+        });
+      });
+    },
+    serialize: (value: Subscription) => {
+      return transferHandlers.get('proxy')!.serialize({
+        unsubscribe: () => value.unsubscribe(),
+      });
+    },
+  });
 }
 
 function safeStringify(obj: any): string {
diff --git a/src/services/backend/workers/serializers.ts b/src/services/backend/workers/serializers.ts
index 230485ccd..ac0afe086 100644
--- a/src/services/backend/workers/serializers.ts
+++ b/src/services/backend/workers/serializers.ts
@@ -1,7 +1,7 @@
 import type { TransferHandler } from 'comlink';
 import { IPFSContent } from 'src/services/ipfs/types';
 
-type IPFSContentTransferable = Omit<IPFSContent, 'result'> & {
+export type IPFSContentTransferable = Omit<IPFSContent, 'result'> & {
   port: MessagePort;
 };
 
@@ -75,4 +75,8 @@ const IPFSContentTransferHandler: TransferHandler<
   },
 };
 
-export { IPFSContentTransferHandler };
+export {
+  IPFSContentTransferHandler,
+  // serializeIPFSContent,
+  // deserializeIPFSContent,
+};
diff --git a/src/services/ipfs/node/factory.ts b/src/services/ipfs/node/factory.ts
index dab87caec..d04d5a29e 100644
--- a/src/services/ipfs/node/factory.ts
+++ b/src/services/ipfs/node/factory.ts
@@ -42,8 +42,6 @@ export async function initIpfsNode(
   //   instance.connMgrGracePeriod = await getNodeAutoDialInterval(instance);
   // window.ipfs = instance;
 
-  console.log('----init', ipfsNodeType);
-
   await instance.reconnectToSwarm();
   return instance;
 }
diff --git a/src/services/ipfs/node/impl/js-ipfs.ts b/src/services/ipfs/node/impl/js-ipfs.ts
index 21db61c54..50fd8a451 100644
--- a/src/services/ipfs/node/impl/js-ipfs.ts
+++ b/src/services/ipfs/node/impl/js-ipfs.ts
@@ -20,7 +20,7 @@ class JsIpfsNode implements IpfsNode {
     return { gatewayUrl: CYBER_GATEWAY_URL };
   }
 
-  private _isStarted: boolean = false;
+  private _isStarted = false;
 
   get isStarted() {
     return this._isStarted;
diff --git a/src/services/ipfs/node/mixins/withCybFeatures.ts b/src/services/ipfs/node/mixins/withCybFeatures.ts
index 1045c1d61..9db39368d 100644
--- a/src/services/ipfs/node/mixins/withCybFeatures.ts
+++ b/src/services/ipfs/node/mixins/withCybFeatures.ts
@@ -12,10 +12,14 @@ function withCybFeatures<TBase extends new (...args: any[]) => IpfsNode>(
   options: WithCybFeaturesOptions
 ) {
   return class CybIpfsNodeMixin extends Base implements CybIpfsNode {
-    async fetchWithDetails(cid: string, parseAs?: IpfsContentType) {
-      const response = await getIPFSContent(cid, this);
-      const details = await parseArrayLikeToDetails(response, cid);
+    async fetchWithDetails(
+      cid: string,
+      parseAs?: IpfsContentType,
+      abortController?: AbortController
+    ) {
+      const content = await getIPFSContent(cid, this, abortController);
 
+      const details = await parseArrayLikeToDetails(content, cid);
       return !parseAs
         ? details
         : details?.type === parseAs
@@ -28,13 +32,13 @@ function withCybFeatures<TBase extends new (...args: any[]) => IpfsNode>(
     }
 
     async isConnectedToSwarm() {
-      return !!(await super.getPeers()).find(
-        (peerId) => peerId === options.swarmPeerId
-      );
+      const peers = await super.getPeers();
+      return !!peers.find((peerId) => peerId === options.swarmPeerId);
     }
 
-    async reconnectToSwarm(lastConnectedTimestamp?: number) {
-      if (!(await this.isConnectedToSwarm())) {
+    async reconnectToSwarm(forced = false) {
+      const isConnectedToSwarm = await this.isConnectedToSwarm();
+      if (!isConnectedToSwarm || forced) {
         // TODO: refactor using timeout for node config
 
         //   const needToReconnect =
diff --git a/src/services/ipfs/types.ts b/src/services/ipfs/types.ts
index b025f9357..da46511d0 100644
--- a/src/services/ipfs/types.ts
+++ b/src/services/ipfs/types.ts
@@ -1,5 +1,6 @@
 /* eslint-disable import/no-unused-modules */
 import { LsResult } from 'ipfs-core-types/dist/src/pin';
+import { Option } from 'src/types';
 
 export type CallBackFuncStatus = (a: string) => void;
 
@@ -56,25 +57,6 @@ export type getIpfsUserGatewanAndNodeType = {
   userGateway: string | undefined;
 };
 
-export type IPFSContentMeta = IpfsFileStats & {
-  blockSizes?: never[]; // ???
-  data?: string; // ???
-  mime?: string;
-  local?: boolean;
-  statsTime?: number;
-  catTime?: number;
-  pinTime?: number;
-};
-
-type IPFSData =
-  | Blob
-  | Buffer
-  | string
-  | ReadableStream<Uint8Array>
-  | Uint8Array
-  | File
-  | Blob[];
-
 export type Uint8ArrayWithMime = {
   mime: string;
   rawData: Uint8Array;
@@ -83,26 +65,42 @@ export type Uint8ArrayWithMime = {
 export type Uint8ArrayLike = Uint8Array | AsyncIterator<Uint8Array>; // | ReadableStream<Uint8Array>
 
 export type IpfsContentSource = 'db' | 'node' | 'gateway';
-export type IpfsContentType =
+
+export type IpfsGatewayContentType = 'video' | 'audio';
+export type MimeBasedContentType = 'image' | 'pdf' | 'text' | 'other';
+export type IpfsBaseContentType =
+  | IpfsGatewayContentType
   | 'image'
   | 'pdf'
-  | 'link'
   | 'text'
-  | 'video'
-  | 'audio'
-  | 'html'
   | 'other';
 
-export type IPFSContentDetails =
-  | {
-      text?: string;
-      type?: IpfsContentType;
-      content?: string;
-      link?: string;
-      gateway: boolean;
-      cid: string;
-    }
-  | undefined;
+export type IpfsContentType = IpfsBaseContentType | 'link' | 'html' | 'cid';
+
+export type IPFSContentMeta = IpfsFileStats & {
+  blockSizes?: never[]; // ???
+  data?: string; // ???
+  mime?: string;
+  local?: boolean;
+  statsTime?: number;
+  catTime?: number;
+  pinTime?: number;
+  contentType?: IpfsContentType;
+};
+
+export type IPFSContentDetails = {
+  text?: string;
+  type?: IpfsContentType;
+  content?: string;
+  link?: string;
+  gateway: boolean;
+  cid: string;
+};
+
+export type IPFSContentDetailsMutated = IPFSContentDetails & {
+  mutation?: 'hidden' | 'modified' | 'error'; // rune pipeline result
+  cidBefore?: string;
+};
 
 export type IPFSContent = {
   availableDownload?: boolean;
@@ -112,13 +110,13 @@ export type IPFSContent = {
   source: IpfsContentSource;
   contentUrl?: string;
   textPreview?: string;
+  contentType?: IpfsContentType;
 };
 
-export type IPFSContentMaybe = IPFSContent | undefined;
-
 export type FetchWithDetailsFunc = (
   cid: string,
-  type?: IpfsContentType
+  type?: IpfsContentType,
+  controller?: AbortController
 ) => Promise<IPFSContentDetails>;
 
 export interface IpfsNode {
@@ -140,7 +138,7 @@ export interface IpfsNode {
 
 export interface CybIpfsNode extends IpfsNode {
   isConnectedToSwarm(): Promise<boolean>;
-  reconnectToSwarm(lastConnectedTimestamp?: number): Promise<void>;
+  reconnectToSwarm(forced: Option<boolean>): Promise<void>;
   fetchWithDetails: FetchWithDetailsFunc;
   addContent(content: File | string): Promise<string | undefined>;
 }
diff --git a/src/services/ipfs/utils/content.ts b/src/services/ipfs/utils/content.ts
index 98e62db89..19fd8a61f 100644
--- a/src/services/ipfs/utils/content.ts
+++ b/src/services/ipfs/utils/content.ts
@@ -1,12 +1,16 @@
 import { toString as uint8ArrayToAsciiString } from 'uint8arrays/to-string';
 import isSvg from 'is-svg';
 import { PATTERN_HTTP, PATTERN_IPFS_HASH } from 'src/constants/patterns';
+import { Option } from 'src/types';
+
 import {
   IPFSContentDetails,
-  IPFSContentMaybe,
+  IPFSContent,
   IpfsContentType,
+  IpfsGatewayContentType,
 } from '../types';
 import { getResponseResult, onProgressCallback } from './stream';
+import { shortenString } from 'src/utils/string';
 
 function createObjectURL(rawData: Uint8Array, type: string) {
   const blob = new Blob([rawData], { type });
@@ -20,9 +24,9 @@ function createImgData(rawData: Uint8Array, type: string) {
 }
 
 // eslint-disable-next-line import/no-unused-modules
-export const detectContentType = (
+export const detectGatewayContentType = (
   mime: string | undefined
-): IpfsContentType => {
+): Option<IpfsGatewayContentType> => {
   if (mime) {
     if (mime.includes('video')) {
       return 'video';
@@ -32,105 +36,170 @@ export const detectContentType = (
       return 'audio';
     }
   }
-  return 'other';
+  return undefined;
 };
 
 const basic = /\s?<!doctype html>|(<html\b[^>]*>|<body\b[^>]*>|<x-[^>]+>)+/i;
 
-function isHtml(string) {
+function isHtml(string: string) {
   const newString = string.trim().slice(0, 1000);
   return basic.test(newString);
 }
 
-function shortenString(string: string, length = 300) {
-  return string.length > length ? `${string.slice(0, length)}...` : string;
-}
-
 // eslint-disable-next-line import/no-unused-modules
 export const chunksToBlob = (
   chunks: Array<Uint8Array>,
   mime: string | undefined
 ) => new Blob(chunks, mime ? { type: mime } : {});
 
+// eslint-disable-next-line import/no-unused-modules
+export const mimeToBaseContentType = (
+  mime: string | undefined
+): IpfsContentType => {
+  if (!mime) {
+    return 'other';
+  }
+
+  const initialType = detectGatewayContentType(mime);
+  if (initialType) {
+    return initialType;
+  }
+
+  if (
+    mime.indexOf('text/plain') !== -1 ||
+    mime.indexOf('application/xml') !== -1
+  ) {
+    return 'text';
+  }
+  if (mime.indexOf('image') !== -1) {
+    return 'image';
+  }
+  if (mime.indexOf('application/pdf') !== -1) {
+    return 'pdf';
+  }
+  return 'other';
+};
+
 // eslint-disable-next-line import/no-unused-modules, import/prefer-default-export
 export const parseArrayLikeToDetails = async (
-  content: IPFSContentMaybe,
-  // rawDataResponse: Uint8ArrayLike | undefined,
-  // mime: string | undefined,
+  content: Option<IPFSContent>,
   cid: string,
   onProgress?: onProgressCallback
 ): Promise<IPFSContentDetails> => {
-  try {
-    // console.log('------parseArrayLikeToDetails', cid, content);
-    const mime = content?.meta?.mime;
-    const response: IPFSContentDetails = {
-      link: `/ipfs/${cid}`,
-      gateway: false,
+  // try {
+  if (!content || !content?.result) {
+    return {
+      gateway: true,
+      text: cid.toString(),
+      cid,
+    };
+  }
+
+  const { result, meta } = content;
+
+  const { mime, contentType } = meta;
+
+  if (!mime) {
+    return {
       cid,
+      gateway: true,
+      text: `Can't detect MIME for ${cid.toString()}`,
     };
-    const initialType = detectContentType(mime);
-    if (['video', 'audio'].indexOf(initialType) > -1) {
-      return { ...response, type: initialType, gateway: true };
+  }
+  const contentCid = content.cid;
+
+  const response: IPFSContentDetails = {
+    link: `/ipfs/${cid}`,
+    gateway: false,
+    cid: contentCid,
+    type: contentType,
+  };
+
+  if (detectGatewayContentType(mime)) {
+    return { ...response, gateway: true };
+  }
+
+  const rawData =
+    typeof result !== 'string'
+      ? await getResponseResult(result, onProgress)
+      : result;
+
+  const isStringData = typeof rawData === 'string';
+
+  // console.log(rawData);
+  if (!rawData) {
+    return {
+      ...response,
+      gateway: true,
+      text: `Can't parse content for ${cid.toString()}`,
+    };
+  }
+
+  // clarify text-content subtypes
+  if (response.type === 'text') {
+    // render svg as image
+    if (!isStringData && isSvg(Buffer.from(rawData))) {
+      return {
+        ...response,
+        type: 'image',
+        content: createImgData(rawData, 'image/svg+xml'),
+      };
     }
 
-    const rawData = content?.result
-      ? await getResponseResult(content.result, onProgress)
-      : undefined;
-
-    // console.log(rawData);
-
-    if (!mime) {
-      response.text = `Can't detect MIME for ${cid.toString()}`;
-      response.gateway = true; // ???
-    } else if (
-      mime.indexOf('text/plain') !== -1 ||
-      mime.indexOf('application/xml') !== -1
-    ) {
-      if (isSvg(Buffer.from(rawData))) {
-        response.type = 'image';
-        response.content = createImgData(rawData, 'image/svg+xml'); // file
-      } else {
-        const dataBase64 = uint8ArrayToAsciiString(rawData);
-        // TODO: search can bel longer for 42???!
-        // also cover ipns links
-        response.link =
-          dataBase64.length > 42 ? `/ipfs/${cid}` : `/search/${dataBase64}`;
-
-        if (dataBase64.match(PATTERN_IPFS_HASH)) {
-          response.gateway = true;
-          response.type = 'other';
-          response.content = dataBase64;
-          response.link = `/ipfs/${cid}`;
-        } else if (dataBase64.match(PATTERN_HTTP)) {
-          response.type = 'link';
-          response.gateway = false;
-          response.content = dataBase64;
-          response.link = `/ipfs/${cid}`;
-        } else if (isHtml(dataBase64)) {
-          response.type = 'other';
-          response.gateway = true;
-          response.content = cid.toString();
-        } else {
-          response.type = 'text';
-          response.content = dataBase64;
-          response.text = shortenString(dataBase64);
-        }
-      }
-    } else if (mime.indexOf('image') !== -1) {
-      response.content = createImgData(rawData, mime); // file
-      response.type = 'image';
-      response.gateway = false;
-    } else if (mime.indexOf('application/pdf') !== -1) {
-      response.type = 'pdf';
-      response.content = createObjectURL(rawData, mime); // file
-      response.gateway = true; // ???
+    const str = isStringData ? rawData : uint8ArrayToAsciiString(rawData);
+
+    if (str.match(PATTERN_IPFS_HASH)) {
+      return {
+        ...response,
+        type: 'cid',
+        content: str,
+      };
+    }
+    if (str.match(PATTERN_HTTP)) {
+      return {
+        ...response,
+        type: 'link',
+        content: str,
+      };
+    }
+    if (isHtml(str)) {
+      return {
+        ...response,
+        type: 'html',
+        gateway: true,
+        content: cid.toString(),
+      };
     }
 
-    return response;
-  } catch (e) {
-    console.log('----parseRawIpfsData', e, cid);
-    return undefined;
+    // TODO: search can bel longer for 42???!
+    // also cover ipns links
+    return {
+      ...response,
+      link: str.length > 42 ? `/ipfs/${cid}` : `/search/${str}`,
+      type: 'text',
+      text: shortenString(str),
+      content: str,
+    };
   }
+
+  if (!isStringData) {
+    if (response.type === 'image') {
+      return { ...response, content: createImgData(rawData, mime) }; // file
+    }
+    if (response.type === 'pdf') {
+      return {
+        ...response,
+        content: createObjectURL(rawData, mime),
+        gateway: true,
+      }; // file
+    }
+  }
+
+  return response;
+  // } catch (e) {
+  //   console.log('----parseRawIpfsData', e, cid);
+  //   return undefined;
+  // }
 };
 
 export const contentToUint8Array = async (
@@ -144,11 +213,17 @@ export const contentToUint8Array = async (
 };
 
 export const createTextPreview = (
-  array: Uint8Array | undefined,
-  mime?: string,
+  array: Uint8Array | undefined | string,
+  contentType: IpfsContentType,
   previewLength = 150
 ) => {
-  return array && mime && mime === 'text/plain'
+  if (!array) {
+    return undefined;
+  }
+  if (typeof array === 'string') {
+    return array.slice(0, previewLength);
+  }
+  return contentType && contentType === 'text'
     ? uint8ArrayToAsciiString(array).slice(0, previewLength)
     : undefined;
 };
diff --git a/src/services/ipfs/utils/stream.ts b/src/services/ipfs/utils/stream.ts
index 5e59b3b8d..e2ecae2e1 100644
--- a/src/services/ipfs/utils/stream.ts
+++ b/src/services/ipfs/utils/stream.ts
@@ -132,27 +132,32 @@ export const getResponseResult = async (
       return readArray;
     }
 
-    const reader = response[Symbol.asyncIterator]();
-
-    // if (cid === 'QmRqms6Utkk6L4mtyLQXY2spcQ8Pk7fBBTNjvxa9jTNrXp') {
-    //   debugger;
-    // }
-    // eslint-disable-next-line no-restricted-syntax
-    for await (const chunk of reader) {
-      if (chunk instanceof Uint8Array) {
-        chunks.push(chunk);
-        bytesDownloaded += chunk.byteLength;
-        onProgress && onProgress(bytesDownloaded);
+    if (Symbol.asyncIterator in response) {
+      const reader = response[Symbol.asyncIterator]();
+
+      // if (cid === 'QmRqms6Utkk6L4mtyLQXY2spcQ8Pk7fBBTNjvxa9jTNrXp') {
+      //   debugger;
+      // }
+      // eslint-disable-next-line no-restricted-syntax
+      for await (const chunk of reader) {
+        if (chunk instanceof Uint8Array) {
+          chunks.push(chunk);
+          bytesDownloaded += chunk.byteLength;
+          onProgress && onProgress(bytesDownloaded);
+        }
       }
+      const result = uint8ArrayConcat(chunks);
+      return result;
     }
-    const result = uint8ArrayConcat(chunks);
-    return result;
+    return undefined;
   } catch (error) {
     console.error(
       `Error reading stream/iterable.\r\n Probably Hot reload error!`,
       error
     );
 
+    // throw error;
+
     return undefined;
   }
 };
diff --git a/src/services/ipfs/utils/utils-ipfs.ts b/src/services/ipfs/utils/utils-ipfs.ts
index f38c614d3..8c3d2792d 100644
--- a/src/services/ipfs/utils/utils-ipfs.ts
+++ b/src/services/ipfs/utils/utils-ipfs.ts
@@ -4,11 +4,11 @@ import { concat as uint8ArrayConcat } from 'uint8arrays/concat';
 import { Option } from 'src/types';
 import {
   // getIpfsUserGatewanAndNodeType,
-  IPFSContentMaybe,
   IPFSContentMeta,
   CallBackFuncStatus,
   IpfsContentSource,
   IpfsNode,
+  IpfsFileStats,
 } from '../types';
 
 import { getMimeFromUint8Array, toAsyncIterableWithMime } from './stream';
@@ -16,14 +16,18 @@ import { getMimeFromUint8Array, toAsyncIterableWithMime } from './stream';
 import ipfsCacheDb from './ipfsCacheDb';
 import cyberCluster from './cluster';
 
-import { contentToUint8Array, createTextPreview } from './content';
+import {
+  contentToUint8Array,
+  createTextPreview,
+  mimeToBaseContentType,
+} from './content';
 
 import { CYBER_GATEWAY_URL, FILE_SIZE_DOWNLOAD } from '../config';
 
 // Get data by CID from local storage
 const loadIPFSContentFromDb = async (
   cid: string
-): Promise<IPFSContentMaybe> => {
+): Promise<Option<IPFSContent>> => {
   // TODO: enable, disabled for tests
 
   // TODO: use cursor
@@ -31,13 +35,16 @@ const loadIPFSContentFromDb = async (
   if (data && data.length) {
     // TODO: use cursor
     const mime = await getMimeFromUint8Array(data);
-    const textPreview = createTextPreview(data, mime);
+    const contentType = mimeToBaseContentType(mime);
+
+    const textPreview = createTextPreview(data, contentType);
 
     const meta: IPFSContentMeta = {
       type: 'file', // `TODO: ipfs refactor dir support ?
       size: data.length,
       sizeLocal: data.length,
       mime,
+      contentType,
     };
     return { result: data, cid, meta, source: 'db', textPreview };
   }
@@ -45,30 +52,30 @@ const loadIPFSContentFromDb = async (
   return undefined;
 };
 
-const emptyMeta: IPFSContentMeta = {
+const emptyStats: IpfsFileStats = {
   type: 'file',
   size: undefined,
-  local: undefined,
   sizeLocal: undefined,
+  blocks: undefined,
 };
 
-const fetchIPFSContentMeta = async (
+const fetchIPFSContentStat = async (
   cid: string,
   node?: IpfsNode,
   signal?: AbortSignal
-): Promise<IPFSContentMeta> => {
+): Promise<IpfsFileStats> => {
   if (node) {
-    const meta = await node.stat(cid, { signal });
-    return meta;
+    const stats = await node.stat(cid, { signal });
+    return stats;
   }
-  return emptyMeta;
+  return emptyStats;
 };
 
 const fetchIPFSContentFromNode = async (
   cid: string,
   node?: IpfsNode,
   controller?: AbortController
-): Promise<IPFSContentMaybe> => {
+): Promise<Option<IPFSContent>> => {
   const controllerLegacy = controller || new AbortController();
   const { signal } = controllerLegacy;
   let timer: NodeJS.Timeout | undefined;
@@ -88,16 +95,17 @@ const fetchIPFSContentFromNode = async (
   try {
     // const stat = await node.files.stat(path, { signal });
     const startTime = Date.now();
-    const meta = await fetchIPFSContentMeta(cid, node, signal);
+    const stats = await fetchIPFSContentStat(cid, node, signal);
+    const meta = stats as IPFSContentMeta;
     const statsDoneTime = Date.now();
     meta.statsTime = statsDoneTime - startTime;
-    const allowedSize = meta.size ? meta.size < FILE_SIZE_DOWNLOAD : false;
+    const allowedSize = stats.size ? stats.size < FILE_SIZE_DOWNLOAD : false;
     timer && clearTimeout(timer);
 
-    switch (meta.type) {
+    switch (stats.type) {
       case 'directory': {
         // TODO: return directory structure
-        return { cid, availableDownload: true, source: 'node', meta };
+        return { cid, availableDownload: true, source: 'node', meta: stats };
       }
       default: {
         // Get sample of content
@@ -106,11 +114,12 @@ const fetchIPFSContentFromNode = async (
           [Symbol.asyncIterator]()
           .next();
 
-        const mime = await getMimeFromUint8Array(firstChunk);
+        meta.mime = await getMimeFromUint8Array(firstChunk);
+        meta.contentType = mimeToBaseContentType(meta.mime);
         const fullyDownloaded =
-          meta.size && meta.size > -1 && firstChunk.length >= meta.size;
+          stats.size && stats.size > -1 && firstChunk.length >= stats.size;
 
-        const textPreview = createTextPreview(firstChunk, mime);
+        const textPreview = createTextPreview(firstChunk, meta.contentType);
 
         if (fullyDownloaded) {
           await ipfsCacheDb.add(cid, uint8ArrayConcat([firstChunk]));
@@ -139,7 +148,7 @@ const fetchIPFSContentFromNode = async (
           result: stream,
           textPreview,
           cid,
-          meta: { ...meta, mime },
+          meta,
           source: 'node',
         };
         // }
@@ -147,7 +156,12 @@ const fetchIPFSContentFromNode = async (
     }
   } catch (error) {
     console.debug('error fetchIPFSContentFromNode', error);
-    return { cid, availableDownload: true, source: 'node', meta: emptyMeta };
+    return {
+      cid,
+      availableDownload: true,
+      source: 'node',
+      meta: { ...emptyStats } as IPFSContentMeta,
+    };
   }
 };
 
@@ -156,12 +170,12 @@ const fetchIPFSContentFromGateway = async (
   node?: IpfsNode,
   controller?: AbortController,
   headers?: Record<string, string>
-): Promise<IPFSContentMaybe> => {
+): Promise<Option<IPFSContent>> => {
   // fetch META only from external node(toooo slow), TODO: fetch meta from cybernode
   const isExternalNode = node?.nodeType === 'external';
-  const meta = isExternalNode
-    ? await fetchIPFSContentMeta(cid, node, controller?.signal)
-    : emptyMeta;
+  const stats = isExternalNode
+    ? await fetchIPFSContentStat(cid, node, controller?.signal)
+    : emptyStats;
 
   const contentUrl = `${CYBER_GATEWAY_URL}/ipfs/${cid}`;
   const response = await fetch(contentUrl, {
@@ -169,7 +183,6 @@ const fetchIPFSContentFromGateway = async (
     signal: controller?.signal,
     headers,
   });
-
   if (response && response.body) {
     // fetch doesn't provide any headers in our case :(
 
@@ -195,11 +208,13 @@ const fetchIPFSContentFromGateway = async (
       flushResults
     );
 
-    const textPreview = createTextPreview(firstChunk, mime);
+    const contentType = mimeToBaseContentType(mime);
+
+    const textPreview = createTextPreview(firstChunk, contentType);
     return {
       cid,
       textPreview,
-      meta: { ...meta, mime },
+      meta: { ...stats, mime, contentType },
       result,
       source: 'gateway',
       contentUrl,
@@ -219,7 +234,7 @@ async function fetchIpfsContent(
   cid: string,
   source: IpfsContentSource,
   options: fetchContentOptions
-): Promise<IPFSContentMaybe> {
+): Promise<Option<IPFSContent>> {
   const { node, controller, headers } = options;
 
   try {
@@ -244,7 +259,7 @@ const getIPFSContent = async (
   node?: IpfsNode,
   controller?: AbortController,
   callBackFuncStatus?: CallBackFuncStatus
-): Promise<IPFSContentMaybe> => {
+): Promise<Option<IPFSContent>> => {
   const dataRsponseDb = await loadIPFSContentFromDb(cid);
   if (dataRsponseDb !== undefined) {
     return dataRsponseDb;
diff --git a/src/services/neuron/neuronApi.ts b/src/services/neuron/neuronApi.ts
index 9d43f22ee..56b67f730 100644
--- a/src/services/neuron/neuronApi.ts
+++ b/src/services/neuron/neuronApi.ts
@@ -1,5 +1,5 @@
 /* eslint-disable import/no-unused-modules */
-import { Coin, StdFee } from '@cosmjs/launchpad';
+import { Coin, OfflineSigner, StdFee } from '@cosmjs/launchpad';
 import { SigningCyberClient } from '@cybercongress/cyber-js';
 import { SenseApi } from 'src/contexts/backend/services/senseApi';
 import { NeuronAddress, ParticleCid } from 'src/types/base';
@@ -9,6 +9,8 @@ import { DEFAULT_GAS_LIMITS } from 'src/constants/config';
 import { LinkDto } from '../CozoDb/types/dto';
 import { throwErrorOrResponse } from './errors';
 
+import { CONTRACT_ADDRESS_PASSPORT } from 'src/containers/portal/utils';
+
 const defaultFee = {
   amount: [],
   gas: DEFAULT_GAS_LIMITS.toString(),
@@ -39,7 +41,8 @@ export const sendCyberlink = async (
     neuron,
   } as LinkDto;
 
-  await senseApi?.putCyberlinsks(link);
+  // TODO: add from/toparticle to DB ??
+  await senseApi?.putCyberlink(link);
   await senseApi?.addCyberlinkLocal(link);
 
   return transactionHash;
@@ -94,3 +97,30 @@ export const investmint = async (
   const { transactionHash } = throwErrorOrResponse(response);
   return transactionHash;
 };
+
+export const updatePassportParticle = async (
+  nickname: string,
+  particle: ParticleCid,
+  {
+    signer,
+    signingClient,
+  }: {
+    signer: OfflineSigner;
+    signingClient: SigningCyberClient;
+  }
+) => {
+  const [{ address }] = await signer.getAccounts();
+
+  const msgObject = {
+    update_particle: {
+      nickname,
+      particle,
+    },
+  };
+  return signingClient.execute(
+    address,
+    CONTRACT_ADDRESS_PASSPORT,
+    msgObject,
+    'auto'
+  );
+};
diff --git a/src/services/scripting/engine.ts b/src/services/scripting/engine.ts
new file mode 100644
index 000000000..a000a6d9f
--- /dev/null
+++ b/src/services/scripting/engine.ts
@@ -0,0 +1,358 @@
+import initAsync, { compile } from 'cyb-rune-wasm';
+
+import { v4 as uuidv4 } from 'uuid';
+
+import { TabularKeyValues } from 'src/types/data';
+import { keyValuesToObject } from 'src/utils/localStorage';
+
+import { mapObjIndexed } from 'ramda';
+import { removeBrokenUnicode } from 'src/utils/string';
+
+import { extractRuneScript } from './helpers';
+
+import {
+  ScriptCallback,
+  ScriptParticleParams,
+  ScriptContext,
+  ScriptParticleResult,
+  // ScriptMyParticleParams,
+  ScriptEntrypoints,
+  EntrypointParams,
+  EngineContext,
+  ScriptMyCampanion,
+} from './types';
+
+import runtimeScript from './rune/runtime.rn';
+import {
+  BehaviorSubject,
+  ReplaySubject,
+  combineLatest,
+  distinctUntilChanged,
+  map,
+  share,
+} from 'rxjs';
+
+const compileConfig = {
+  budget: 1_000_000,
+  experimental: false,
+  instructions: true,
+  options: [],
+};
+
+type CompilerParams = {
+  readOnly: boolean;
+  execute: boolean;
+  funcName: string;
+  funcParams: EntrypointParams;
+  config: typeof compileConfig;
+};
+
+const toRecord = (item: TabularKeyValues) =>
+  keyValuesToObject(Object.values(item));
+
+export type LoadParams = {
+  entrypoints: ScriptEntrypoints;
+  secrets: TabularKeyValues;
+};
+
+// export interface RuneEngine {
+//   pushContext<K extends keyof ScriptContext>(
+//     key: K,
+//     value: ScriptContext[K]
+//   ): void;
+//   popContext(names: (keyof ScriptContext)[]): void;
+//   setEntrypoints(entrypoints: ScriptEntrypoints): void;
+//   // getSingleDep<T extends keyof EngineDeps>(name: T): EngineDeps[T];
+
+//   load(params: LoadParams): Promise<void>;
+//   init(): Promise<void>;
+//   run(
+//     script: string,
+//     compileParams: Partial<CompilerParams>,
+//     callback?: ScriptCallback
+//   ): Promise<ScriptExecutionResult>;
+//   askCompanion(
+//     cid: string,
+//     contentType: string,
+//     content: string,
+//     callback?: ScriptCallback
+//   ): Promise<ScriptMyCampanion>;
+//   personalProcessor(
+//     params: ScriptParticleParams
+//   ): Promise<ScriptParticleResult>;
+//   executeFunction(
+//     script: string,
+//     funcName: string,
+//     params: EntrypointParams
+//   ): Promise<ScriptParticleResult>;
+//   executeCallback(refId: string, data: any): Promise<void>;
+// }
+
+// eslint-disable-next-line import/prefer-default-export
+function enigine() {
+  let entrypoints: Partial<ScriptEntrypoints> = {};
+  let context: EngineContext = { params: {}, user: {}, secrets: {} };
+  const isInitialized$ = new BehaviorSubject<boolean>(false);
+  const entrypoints$ = new BehaviorSubject<Partial<ScriptEntrypoints>>({});
+
+  const scriptCallbacks = new Map<string, ScriptCallback>();
+
+  const isSoulInitialized$ = new ReplaySubject(1);
+  combineLatest([isInitialized$, entrypoints$])
+    .pipe(
+      map(
+        ([isInitialized, entrypoints]) =>
+          !!(isInitialized && entrypoints.particle)
+      ),
+      distinctUntilChanged()
+    )
+    .subscribe((v) => {
+      isSoulInitialized$.next(v);
+    });
+
+  entrypoints$.subscribe((v) => {
+    entrypoints = v;
+  });
+
+  const init = async () => {
+    console.time('🔋 rune initialized');
+    await initAsync();
+    // window.rune = rune; // debug
+    console.timeEnd('🔋 rune initialized');
+    isInitialized$.next(true);
+  };
+
+  const pushContext = <K extends keyof ScriptContext>(
+    name: K,
+    value: ScriptContext[K] | TabularKeyValues
+  ) => {
+    if (name === 'secrets') {
+      context[name] = toRecord(value as TabularKeyValues);
+      return;
+    }
+
+    context[name] = value;
+  };
+
+  const popContext = (names: (keyof ScriptContext)[]) => {
+    const newContext = context;
+    names.forEach((name) => {
+      newContext[name] = {};
+    });
+    context = newContext;
+  };
+
+  const setEntrypoints = (scriptEntrypoints: ScriptEntrypoints) => {
+    entrypoints = mapObjIndexed(
+      (v) => ({ ...v, script: extractRuneScript(v.script) }),
+      scriptEntrypoints
+    );
+    entrypoints$.next(entrypoints);
+  };
+
+  const defaultCompilerParams: CompilerParams = {
+    readOnly: false,
+    execute: true,
+    funcName: 'main',
+    funcParams: {},
+    config: compileConfig,
+  };
+
+  const run = async (
+    script: string,
+    compileParams: Partial<CompilerParams>,
+    callback?: ScriptCallback
+  ) => {
+    const refId = uuidv4().toString();
+
+    callback && scriptCallbacks.set(refId, callback);
+    const scriptParams = {
+      app: context,
+      refId,
+    };
+    const compilerParams = {
+      ...defaultCompilerParams,
+      ...compileParams,
+    };
+    const outputData = await compile(
+      script,
+      runtimeScript,
+      scriptParams,
+      compilerParams
+    );
+    const { result, error } = outputData;
+
+    try {
+      scriptCallbacks.delete(refId);
+
+      return {
+        ...outputData,
+        error,
+        result: result
+          ? JSON.parse(removeBrokenUnicode(result))
+          : { action: 'error', message: 'No result' },
+      };
+    } catch (e) {
+      scriptCallbacks.delete(refId);
+
+      console.log(
+        `engine.run err ${compilerParams.funcName}`,
+        e,
+        outputData,
+        compilerParams
+      );
+      return {
+        diagnosticsOutput: `scripting engine error ${e}`,
+        ...outputData,
+        result: { action: 'error', message: e?.toString() || 'Unknown error' },
+      };
+    }
+  };
+
+  const getParticleScriptOrAction = ():
+    | ['error' | 'pass' | 'script', string] => {
+    if (!entrypoints.particle) {
+      return ['error', ''];
+    }
+
+    const { script, enabled } = entrypoints.particle;
+
+    if (!enabled) {
+      return ['pass', ''];
+    }
+
+    return ['script', script];
+  };
+
+  const personalProcessor = async (
+    params: ScriptParticleParams
+  ): Promise<ScriptParticleResult> => {
+    const [resultType, script] = getParticleScriptOrAction();
+
+    if (resultType === 'error') {
+      return { action: 'error', message: 'No particle entrypoint' };
+    }
+
+    if (resultType !== 'script') {
+      return { action: 'pass' };
+    }
+
+    const { cid, contentType, content } = params;
+    const output = await run(script, {
+      funcName: 'personal_processor',
+      funcParams: [cid, contentType, content], //params as EntrypointParams,
+    });
+    const { action, content: outputContent } = output.result;
+
+    if (action === 'error') {
+      console.error(
+        `RUNE: personalProcessor error: ${params.cid}`,
+        params,
+        output
+      );
+    }
+
+    if (outputContent) {
+      return { ...output.result, content: outputContent };
+    }
+
+    return output.result;
+  };
+
+  const executeFunction = async (
+    script: string,
+    funcName: string,
+    funcParams: EntrypointParams
+  ): Promise<ScriptParticleResult> => {
+    console.log('-----executeFunction rune', funcName, funcParams);
+    const output = await run(script, {
+      funcName,
+      funcParams,
+      readOnly: true, // block to sign tx and add to ipfs
+    });
+
+    return output.result;
+  };
+
+  // const particleInference = async (
+  //   userScript: string,
+  //   funcParams: EntrypointParams
+  // ): Promise<ScriptMyParticleResult> => {
+  //   const output = await run(userScript, {
+  //     funcName: 'particle_inference',
+  //     funcParams,
+  //   });
+
+  //   return output.result;
+  // };
+
+  const askCompanion = async (
+    cid: string,
+    contentType: string,
+    content: string,
+    callback?: ScriptCallback
+  ): Promise<ScriptMyCampanion> => {
+    const [resultType, script] = getParticleScriptOrAction();
+    if (resultType === 'error') {
+      return {
+        action: 'error',
+        metaItems: [{ type: 'text', text: 'No particle entrypoint' }],
+      };
+    }
+
+    if (resultType === 'pass') {
+      return { action: 'pass', metaItems: [] };
+    }
+
+    const output = await run(
+      script,
+      {
+        funcName: 'ask_companion',
+        funcParams: [cid, contentType, content],
+      },
+      callback
+    );
+
+    if (output.result.action === 'error') {
+      console.error('---askCompanion error', output);
+      return {
+        action: 'error',
+        metaItems: [{ type: 'text', text: output.error }],
+      };
+    }
+
+    return { action: 'answer', metaItems: output.result.content };
+  };
+
+  const executeCallback = async (refId: string, data: any) => {
+    const callback = scriptCallbacks.get(refId);
+
+    if (callback) {
+      await callback(data);
+    }
+  };
+
+  return {
+    init,
+    isSoulInitialized$,
+    run,
+    // particleInference,
+    askCompanion,
+    personalProcessor,
+    setEntrypoints,
+    pushContext,
+    popContext,
+    executeFunction,
+    executeCallback,
+    getDebug: () => ({
+      context,
+      entrypoints,
+    }),
+  };
+}
+
+const scriptEngine = enigine();
+
+export type RuneEngine = typeof scriptEngine;
+
+export default scriptEngine;
diff --git a/src/services/scripting/helpers.ts b/src/services/scripting/helpers.ts
new file mode 100644
index 000000000..cceed14c1
--- /dev/null
+++ b/src/services/scripting/helpers.ts
@@ -0,0 +1,52 @@
+import { Nullable } from 'src/types';
+
+export async function getScriptFromParticle(cid?: Nullable<string>) {
+  throw new Error('Not implemented');
+  // if (!cid || !isCID(cid)) {
+  //   // throw new Error('cid is not valid');
+  //   return undefined;
+  // }
+
+  // const queueResult = await queueManager.enqueueAndWait(cid, {
+  //   postProcessing: false,
+  // });
+  // const result = queueResult?.result;
+  // if (!result?.result || result?.contentType !== 'text') {
+  //   // throw new Error('content is not valid');
+  //   return undefined;
+  // }
+
+  // return getTextFromIpfsContent(result.result);
+}
+
+export function extractRuneContent(markdown: string) {
+  // Regular expression to match the content between ```rune``` tags
+  const runeRegex = /```rune\s*([\s\S]*?)```/g;
+
+  let match;
+  let runeScript = '';
+  let modifiedMarkdown = markdown;
+  let hasRune = false;
+  // Iterate through all matches of the regular expression
+  while ((match = runeRegex.exec(markdown)) !== null) {
+    hasRune = true;
+    // Append the matched content between ```rune``` tags to runeContent variable
+    runeScript += match[1] + '\n';
+
+    // Replace the entire matched block, including the tags, with an empty string
+    modifiedMarkdown = modifiedMarkdown.replace(match[0], '');
+  }
+
+  // Returning both the extracted content and the modified markdown without the tags
+  return {
+    script: runeScript.trim(),
+    markdown: modifiedMarkdown,
+    hasRune,
+  };
+}
+
+export function extractRuneScript(markdown: string) {
+  const { script, markdown: md, hasRune } = extractRuneContent(markdown);
+  // if no rune tag, consider this like pure script
+  return hasRune ? script : md;
+}
diff --git a/src/services/scripting/rune/default/myParticle.rn b/src/services/scripting/rune/default/myParticle.rn
new file mode 100644
index 000000000..0bfacc57f
--- /dev/null
+++ b/src/services/scripting/rune/default/myParticle.rn
@@ -0,0 +1,9 @@
+// params:
+//  - inupt: user search input
+pub async fn particle_inference(params) {
+    let nickname =  cyb::context.user.nickname;
+
+    //return cid_result("QmYWfDTQKzQ52aJhbFedj4izvZKkvVRtFsJ9hyCup4EPKi");
+
+    return content_result(`Hello, ${nickname}!`);
+}
diff --git a/src/services/scripting/rune/default/particle.rn b/src/services/scripting/rune/default/particle.rn
new file mode 100644
index 000000000..1742d805f
--- /dev/null
+++ b/src/services/scripting/rune/default/particle.rn
@@ -0,0 +1,111 @@
+/*
+    Any information here, will be shown in the description of your soul.
+    [template]
+*/
+
+// CODE EXAMPLES
+
+// your content for <citizen_name>.moon domain
+pub async fn moon_domain_resolver() {
+    // get nickname of domain resolver at the momemnt
+    let nickname =  cyb::context.user.nickname;
+
+    let rng = rand::WyRand::new();
+    let rand_int = rng.int_range(0, 999999);
+
+    return content_result(`Hello, ${nickname}, your lucky number is ${rand_int} 🎉`);
+
+    // substitute with some CID (ipfs hosted app in this case)
+    // return cid_result("QmcqikiVZJLmum6QRDH7kmLSUuvoPvNiDnCKY4A5nuRw17")
+}
+
+// Extend particle page with custom UI elements
+pub async fn ask_companion(cid, content_type, content) {
+    // plain text item
+    let links = [meta_text("similar: ")];
+
+    // search closest 5 particles using local data from the brain
+    let similar_results = cyb::search_by_embedding(content, 5).await;
+
+
+    for v in similar_results {
+        // link item
+        links.push(meta_link(`/oracle/ask/${v.cid}`, v.text));
+    }
+
+    if links.len() == 1 {
+        links = [meta_text("no similar particles found")];
+    }
+
+    return content_result(links)
+}
+
+// Transform content of the particle
+pub async fn personal_processor(cid, content_type, content) {
+
+    // skip any non-text content
+    if content_type != "text" {
+        return pass()
+    }
+
+    // <citizen_name>.moon domain resolver
+    if content.ends_with(".moon") {
+        let items = content.split(".").collect::<Vec>();
+
+        let username = items[0];
+        let ext = items[1];
+
+        if username.len() <= 14 && ext == "moon" {
+
+            // get passport data by username
+            let passport = cyb::get_passport_by_nickname(username).await;
+
+            // particle - CID of soul script
+            let particle_cid = passport["extension"]["particle"];
+
+            cyb::log(`Resolve ${username} domain from passport particle '${particle_cid}'`);
+
+            // resolve content(script) by cid
+            // evaluate 'moon_domain_resolver' from that
+            let result = cyb::eval_script_from_ipfs(particle_cid, "moon_domain_resolver", []).await;
+
+            return result
+        }
+    }
+
+    // example of content exclusion from the search results
+    let buzz_word = "пиздопроебанное хуеплетство";
+
+    if content.contains(buzz_word) {
+        cyb::log(`Hide ${cid} item because of '${buzz_word}' in the content`);
+        return hide()
+    }
+
+
+    // example of content modification
+    // replaces cyber with cyber❤
+    let highlight_text = "cyber ";
+    let highlight_with = "❤ ";
+
+    if content.contains(highlight_text) {
+        cyb::log(`Update ${cid} content, highlight ${highlight_text}${highlight_with}`);
+        return content_result(content.replace(highlight_text, `${highlight_text}${highlight_with}`))
+    }
+
+    // replace <token_name>@NOW (ex. bitcoin@NOW) with actual price in usdt
+    // using external api call
+    if content.contains("@NOW") {
+        let left_part = content.split("@NOW").next().unwrap();
+        let token_name = left_part.split(" ").rev().next().unwrap();
+        let vs_currency = "usd";
+
+        // external url call
+        let json =  http::get(`https://api.coingecko.com/api/v3/simple/price?ids=${token_name}&vs_currencies=${vs_currency}`).await?.json().await?;
+        return content_result(content.replace(`${token_name}@NOW`, `Current ${token_name} price is ${json[token_name][vs_currency]} ${vs_currency}`))
+    }
+
+    // anything else
+	content = content.replace("хуй", "🌽").replace("хуя", "🌽").replace("хуе", "🌽");
+
+    content_result(content)
+}
\ No newline at end of file
diff --git a/src/services/scripting/rune/runtime.rn b/src/services/scripting/rune/runtime.rn
new file mode 100644
index 000000000..f0a1ca5fc
--- /dev/null
+++ b/src/services/scripting/rune/runtime.rn
@@ -0,0 +1,34 @@
+pub fn pass() {
+    #{ "action": "pass" }
+}
+
+pub fn hide() {
+    #{ "action": "hide" }
+}
+
+pub fn cid_result(cid) {
+    #{ "cid": cid, "action": "cid_result" }
+}
+
+pub fn content_result(content) {
+    // #{ "content": json::to_string(content)?, "action": "content_result" }
+    #{ "content": content, "action": "content_result" }
+}
+
+pub fn error(message) {
+    #{ "message": message, "action": "error" }
+}
+
+pub fn meta_text(text) {
+    #{ "text": text, "type": "text" }
+}
+
+pub fn meta_link(url, title) {
+    #{ "url": url, "title": title, "type": "link" }
+}
+
+pub async fn async_callback(data) {
+    cyb::log("asyc callback from rune");
+
+    //    cyb::callback(cyb::ref_id, data).await
+}
diff --git a/src/services/scripting/runeDeps.ts b/src/services/scripting/runeDeps.ts
new file mode 100644
index 000000000..073cdc50d
--- /dev/null
+++ b/src/services/scripting/runeDeps.ts
@@ -0,0 +1,182 @@
+import { ProxyMarked, Remote } from 'comlink';
+
+import { BehaviorSubject, Subject, first, tap } from 'rxjs';
+import { CyberClient, SigningCyberClient } from '@cybercongress/cyber-js';
+import { RPC_URL } from 'src/constants/config';
+import { SenseApi } from 'src/contexts/backend/services/senseApi';
+import { Option } from 'src/types';
+import { getSearchQuery, searchByHash } from 'src/utils/search/utils';
+import { NeuronAddress, ParticleCid } from 'src/types/base';
+import { getPassportByNickname } from 'src/containers/portal/utils';
+import { sendCyberlink } from '../neuron/neuronApi';
+
+import { extractRuneScript } from './helpers';
+import { RuneEngine } from './engine';
+import DbApiWrapper from '../backend/services/DbApi/DbApi';
+import { IpfsApi } from '../backend/workers/background/api/ipfsApi';
+import { EmbeddingApi } from '../backend/workers/background/api/mlApi';
+import { Observable } from '@apollo/client';
+
+export type RuneInnerDeps = {
+  ipfsApi: Option<IpfsApi>;
+  rune: Option<RuneEngine>;
+  queryClient: Option<CyberClient>;
+  embeddingApi: Option<EmbeddingApi>;
+  dbApi: Option<DbApiWrapper>;
+  signingClient: Option<SigningCyberClient & ProxyMarked>;
+  // signer?: Option<OfflineSigner>;
+  senseApi: Option<SenseApi & ProxyMarked>;
+  address: Option<NeuronAddress>;
+};
+
+type SubjectDeps<T> = {
+  [K in keyof T]: BehaviorSubject<T[K]> | Subject<T[K]>;
+};
+
+const createRuneDeps = () => {
+  const subjectDeps: SubjectDeps<RuneInnerDeps> = {
+    // Initialize subjects for each dependency
+    ipfsApi: new BehaviorSubject<RuneInnerDeps['ipfsApi']>(undefined),
+    rune: new BehaviorSubject<RuneInnerDeps['rune']>(undefined),
+    queryClient: new BehaviorSubject<RuneInnerDeps['queryClient']>(undefined),
+    embeddingApi: new BehaviorSubject<Option<EmbeddingApi>>(undefined),
+    signingClient: new BehaviorSubject<RuneInnerDeps['signingClient']>(
+      undefined
+    ),
+    senseApi: new BehaviorSubject<RuneInnerDeps['senseApi']>(undefined),
+    address: new BehaviorSubject<RuneInnerDeps['address']>(undefined),
+    dbApi: new BehaviorSubject<RuneInnerDeps['dbApi']>(undefined),
+  };
+
+  const defferedDependency = (
+    name: keyof RuneInnerDeps
+  ): Promise<RuneInnerDeps[typeof name]> => {
+    return new Promise((resolve) => {
+      const item$ = subjectDeps[name] as BehaviorSubject<
+        RuneInnerDeps[typeof name]
+      >;
+      if (item$.getValue()) {
+        resolve(item$.getValue());
+      }
+
+      item$
+        .pipe(
+          first((value) => !!value) // Automatically unsubscribes after the first valid value
+          // tap((v) => console.log('------defferedDependency', name, v))
+        )
+        .subscribe((value) => {
+          resolve(value);
+        });
+    });
+  };
+
+  CyberClient.connect(RPC_URL).then((client) => {
+    subjectDeps.queryClient?.next(client);
+  });
+
+  const setInnerDeps = (externalDeps: Partial<RuneInnerDeps>) => {
+    Object.keys(externalDeps)
+      .filter((name) => externalDeps[name as keyof RuneInnerDeps] !== undefined)
+      .forEach((name) => {
+        const item = externalDeps[name as keyof RuneInnerDeps];
+        subjectDeps[name as keyof RuneInnerDeps].next(item);
+      });
+  };
+
+  const graphSearch = async (query: string, page = 0) => {
+    const queryClient = (await defferedDependency(
+      'queryClient'
+    )) as CyberClient;
+
+    const keywordHash = await getSearchQuery(query);
+
+    return searchByHash(queryClient, keywordHash, page);
+  };
+
+  const getIpfsTextConent = async (cid: string) => {
+    const ipfsApi = (await defferedDependency('ipfsApi')) as IpfsApi;
+    return ipfsApi.fetchWithDetails(cid, 'text');
+  };
+
+  const evalScriptFromIpfs = async (
+    cid: ParticleCid,
+    funcName: string,
+    params = {}
+  ) => {
+    try {
+      const result = await getIpfsTextConent(cid);
+      if (result?.content === undefined) {
+        return { action: 'error', message: 'Particle not found' };
+      }
+      // in case of soul script is mixed with markdown
+      // need to extract pure script
+      const pureScript = extractRuneScript(result.content);
+
+      const rune = (await defferedDependency('rune')) as RuneEngine;
+
+      return rune.executeFunction(pureScript, funcName, params);
+    } catch (e) {
+      return { action: 'error', message: e.toString() };
+    }
+  };
+
+  const executeScriptCallback = async (refId: string, data = {}) => {
+    try {
+      const rune = (await defferedDependency('rune')) as RuneEngine;
+      return rune.executeCallback(refId, data);
+    } catch (e) {
+      return { action: 'error', message: e.toString() };
+    }
+  };
+
+  const cybApi = {
+    graphSearch,
+    cyberlink: async (from: string, to: string) => {
+      const address = subjectDeps.address.getValue();
+      if (!address) {
+        throw new Error('Connect your wallet first');
+      }
+      const senseApi = (await defferedDependency('senseApi')) as SenseApi;
+      const signingClient = (await defferedDependency(
+        'signingClient'
+      )) as SigningCyberClient;
+
+      return sendCyberlink(address, from, to, {
+        senseApi,
+        signingClient,
+      });
+    },
+    getPassportByNickname: async (nickname: string) => {
+      const queryClient = await defferedDependency('queryClient');
+      const passport = await getPassportByNickname(queryClient, nickname);
+
+      return passport;
+    },
+    searcByEmbedding: async (text: string, count = 10) => {
+      const embeddingApi = (await defferedDependency(
+        'embeddingApi'
+      )) as EmbeddingApi;
+      await defferedDependency('dbApi');
+      // console.log('----searcByEmbedding', text);
+      return embeddingApi.searchByEmbedding(text, count);
+    },
+    evalScriptFromIpfs,
+    getIpfsTextConent,
+    addContenToIpfs: async (content: string) => {
+      const ipfsApi = (await defferedDependency('ipfsApi')) as IpfsApi;
+
+      return ipfsApi.addContent(content);
+    },
+    executeScriptCallback,
+  };
+
+  return { setInnerDeps, cybApi };
+};
+
+const runeDeps = createRuneDeps();
+
+export type RuneDeps = typeof runeDeps;
+
+// export type EngineDeps = ReturnType<typeof createRuneDeps>;
+
+export default runeDeps;
diff --git a/src/services/scripting/services/llmRequests/openai.ts b/src/services/scripting/services/llmRequests/openai.ts
new file mode 100644
index 000000000..252275721
--- /dev/null
+++ b/src/services/scripting/services/llmRequests/openai.ts
@@ -0,0 +1,35 @@
+/* eslint-disable import/prefer-default-export */
+/* eslint-disable import/no-unused-modules */
+import axios from 'axios';
+
+// https://platform.openai.com/docs/models/overview
+// gpt-3.5-turbo
+
+// https://platform.openai.com/docs/api-reference/chat/create
+export const promptToOpenAI = async (
+  prompt: string,
+  apiKey: string,
+  params: any = {
+    model: 'text-davinci-003', // 'gpt-3.5-turbo',
+    maxTokens: 500,
+    stop: '.',
+    n: 1,
+  }
+) => {
+  //prompt: `Complete this sentence: "${input}"`,
+  const response = await axios.post(
+    'https://api.openai.com/v1/completions',
+    {
+      prompt,
+      ...params,
+    },
+    {
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+      },
+    }
+  );
+  console.log('response', response);
+  return response.data.choices[0].text;
+};
diff --git a/src/services/scripting/services/postProcessing.ts b/src/services/scripting/services/postProcessing.ts
new file mode 100644
index 000000000..6164f7f6b
--- /dev/null
+++ b/src/services/scripting/services/postProcessing.ts
@@ -0,0 +1,85 @@
+import {
+  IPFSContentDetails,
+  IPFSContentDetailsMutated,
+} from 'src/services/ipfs/types';
+
+import { QueuePriority } from 'src/services/QueueManager/types';
+import { parseArrayLikeToDetails } from 'src/services/ipfs/utils/content';
+import { ParticleCid } from 'src/types/base';
+import { IpfsApi } from 'src/services/backend/workers/background/api/ipfsApi';
+import { RuneEngine } from '../engine';
+
+/**
+ * Execute 'particle' script to post process item: modify cid or content, or hide from view
+ * @param item
+ * @param details
+ * @param ipfsQueue
+ * @returns
+ */
+// eslint-disable-next-line import/prefer-default-export, import/no-unused-modules
+export async function postProcessIpfContent(
+  cid: ParticleCid,
+  details: IPFSContentDetails,
+  rune: RuneEngine,
+  ipfsApi: IpfsApi
+): Promise<IPFSContentDetailsMutated> {
+  try {
+    const { type: contentType, content } = details!;
+
+    const mutation = await rune.personalProcessor({
+      cid,
+      contentType,
+      content,
+    });
+
+    if (mutation.action === 'cid_result' && mutation.cid) {
+      // refectch content from new cid
+      const result = await ipfsApi.enqueueAndWait(mutation.cid, {
+        priority: QueuePriority.URGENT,
+      });
+      const mutatedDetails = await parseArrayLikeToDetails(
+        result.result,
+        mutation.cid
+      );
+      // console.log('----cid_result', cid, details, mutation, result);
+
+      if (result) {
+        return {
+          ...mutatedDetails,
+          cidBefore: cid,
+          mutation: 'modified',
+        };
+      }
+    }
+
+    if (mutation.action === 'content_result') {
+      // update meta to reflect new content
+      // const meta = {
+      //   type: 'file',
+      //   size: mutation.content?.length,
+      //   sizeLocal: mutation.content?.length,
+      //   mime: 'text/plain',
+      //   contentType: 'text',
+      // } as IPFSContentMeta;
+      return {
+        ...details,
+        content: mutation.content,
+        text: mutation.content,
+        mutation: 'modified',
+      };
+    }
+
+    if (mutation.action === 'hide') {
+      return { ...details, mutation: 'hidden' };
+    }
+
+    if (mutation.action === 'error') {
+      return { ...details, mutation: 'error' };
+    }
+
+    return details as IPFSContentDetailsMutated;
+  } catch (e) {
+    console.log('----exc', e);
+    return { ...details, mutation: 'error' };
+  }
+}
diff --git a/src/services/scripting/types.ts b/src/services/scripting/types.ts
new file mode 100644
index 000000000..fe5f04411
--- /dev/null
+++ b/src/services/scripting/types.ts
@@ -0,0 +1,118 @@
+import { Citizenship } from 'src/types/citizenship';
+import { KeyValueString, TabularKeyValues } from 'src/types/data';
+
+type ParamsContext = {
+  path?: string[];
+  query?: string;
+  search?: { [k: string]: string };
+};
+
+export type UserContext = {
+  address?: string;
+  nickname?: string;
+  passport?: Citizenship;
+  particle?: string | null;
+};
+
+type ScriptContext = {
+  params: ParamsContext;
+  user: UserContext;
+  secrets: TabularKeyValues;
+};
+
+type EngineContext = Omit<ScriptContext, 'secrets'> & {
+  secrets: KeyValueString;
+};
+
+type ScriptEntrypoint = {
+  title: string;
+  script: string;
+  enabled: boolean;
+};
+
+type ScriptEntrypoints = {
+  particle: ScriptEntrypoint;
+  // myParticle: ScriptEntrypoint;
+};
+
+type ScriptEntrypointNames = keyof ScriptEntrypoints;
+
+type ScriptCallback = (data: any) => Promise<void>;
+
+type ScriptParticleParams = {
+  cid?: string;
+  contentType?: string;
+  content?: string;
+};
+
+// type ScriptMyParticleParams = {
+//   nickname?: string;
+//   input?: string;
+// };
+
+type ScriptParticleResult = {
+  action: 'pass' | 'cid_result' | 'content_result' | 'hide' | 'error';
+  cid?: string;
+  content?: string;
+  message?: string;
+};
+
+type ScriptMyParticleResult = {
+  action: 'pass' | 'answer' | 'error';
+  answer?: string;
+};
+
+type MetaLinkComponent = {
+  type: 'link';
+  url: string;
+  title: string;
+};
+
+type MetaTextComponent = {
+  type: 'text';
+  text: string;
+};
+
+type ScriptMyCampanion = {
+  action: 'pass' | 'answer' | 'error';
+  metaItems: (MetaLinkComponent | MetaTextComponent)[];
+};
+
+// type ScriptScopeParams = {
+//   particle?: ScriptParticleParams;
+//   myParticle?: ScriptMyParticleParams;
+//   refId?: string;
+// };
+
+type EntrypointParams = {
+  [key: string]: any;
+};
+
+type ScriptExecutionResult = {
+  error?: string;
+  result: ScriptParticleResult;
+  diagnosticsOutput?: string;
+  output?: string;
+  diagnostics?: object[];
+  instructions?: string;
+};
+
+export type {
+  ScriptContext,
+  UserContext,
+  ParamsContext,
+  ScriptEntrypointNames,
+  ScriptEntrypoint,
+  ScriptCallbackStatus,
+  ScriptCallback,
+  EntrypointParams,
+  ScriptParticleParams,
+  // ScriptMyParticleParams,
+  // ScriptScopeParams,
+  ScriptExecutionResult,
+  ScriptEntrypoints,
+  ScriptMyParticleResult,
+  ScriptParticleResult,
+  EngineContext,
+  ScriptMyCampanion,
+};
diff --git a/src/services/scripting/wasmBindings.js b/src/services/scripting/wasmBindings.js
new file mode 100644
index 000000000..0ece63fc5
--- /dev/null
+++ b/src/services/scripting/wasmBindings.js
@@ -0,0 +1,59 @@
+/* eslint-disable import/no-unused-modules */
+import { getFromLink, getToLink } from 'src/utils/search/utils';
+import runeDeps from './runeDeps';
+import { promptToOpenAI } from './services/llmRequests/openai';
+
+// let runeDeps;
+
+// export const initRuneDeps = (deps) => {
+//   console.log('---initRuneDeps', deps);
+
+//   runeDeps = deps;
+// };
+export async function jsCyberSearch(query) {
+  return runeDeps.cybApi.graphSearch(query);
+}
+
+export async function jsCyberLink(fromCid, toCid) {
+  return runeDeps.cybApi.cyberlink(fromCid, toCid);
+}
+
+export async function jsGetPassportByNickname(nickname) {
+  return runeDeps.cybApi.getPassportByNickname(nickname);
+}
+
+export async function jsEvalScriptFromIpfs(cid, funcName, params = {}) {
+  return runeDeps.cybApi.evalScriptFromIpfs(cid, funcName, params);
+}
+
+export async function jsGetIpfsTextContent(cid) {
+  return runeDeps.getIpfsTextConent(cid);
+}
+
+export async function jsAddContenToIpfs(content) {
+  return runeDeps.addContenToIpfs(content);
+}
+
+export async function jsPromptToOpenAI(prompt, apiKey, params) {
+  const result = await promptToOpenAI(prompt, apiKey, params);
+  return result;
+}
+
+export async function jsSearchByEmbedding(text, count) {
+  return runeDeps.cybApi.searcByEmbedding(text, count);
+}
+
+export async function jsCyberLinksFrom(cid) {
+  const result = await getFromLink(cid);
+  return result;
+}
+
+export async function jsCyberLinksTo(cid) {
+  const result = await getToLink(cid);
+  return result;
+}
+
+export async function jsExecuteScriptCallback(refId, data) {
+  console.log('exec deps callback', refId);
+  return runeDeps.cybApi.executeScriptCallback(refId, data);
+}
diff --git a/src/types/data.d.ts b/src/types/data.d.ts
index a3d78ab5e..287f34dc1 100644
--- a/src/types/data.d.ts
+++ b/src/types/data.d.ts
@@ -1,7 +1,13 @@
-export type ObjKeyValue = {
-  [key: string]: number;
+type KeyValue<T> = {
+  [key: string]: T;
 };
 
+export type ObjKeyValue = KeyValue<number>;
+
+export type KeyValueString = KeyValue<string>;
+
+export type TabularKeyValues = { [key: string]: KeyValueString };
+
 type ObjectKey<T> = {
   [key: string | number]: T;
 };
diff --git a/src/types/index.d.ts b/src/types/index.d.ts
index 5b20e1658..b81574e7c 100644
--- a/src/types/index.d.ts
+++ b/src/types/index.d.ts
@@ -2,3 +2,5 @@ export type Option<T> = T | undefined;
 export type Nullable<T> = T | null | undefined;
 export type ArrayElement<ArrayType extends readonly unknown[]> =
   ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
+
+export type ExtractPromiseType<T> = T extends Promise<infer U> ? U : never;
diff --git a/src/utils/dto.ts b/src/utils/dto.ts
index 46f3788f0..33a55e34c 100644
--- a/src/utils/dto.ts
+++ b/src/utils/dto.ts
@@ -1,4 +1,5 @@
 import { EntityToDto, DtoToEntity } from 'src/types/dto';
+import { deserializeString } from './string';
 
 export const snakeToCamel = (str: string) =>
   str.replace(/([-_][a-z])/g, (group) =>
@@ -25,6 +26,8 @@ export function entityToDto<T extends Record<string, any>>(
         value = dbEntity[key].map((item) => entityToDto(item));
       } else if (typeof dbEntity[key] === 'object') {
         value = entityToDto(dbEntity[key]);
+      } else if (typeof dbEntity[key] === 'string') {
+        value = deserializeString(value);
       }
       dto[camelCaseKey] = value;
     }
@@ -46,11 +49,14 @@ export function dtoToEntity<T extends Record<string, any>>(
     if (Object.prototype.hasOwnProperty.call(dto, key)) {
       const snakeCaseKey = camelToSnake(key);
       let value = dto[key];
-      if (Array.isArray(dto[key])) {
-        value = dto[key].map((item) => dtoToEntity(item));
-      } else if (typeof dto[key] === 'object') {
-        value = dtoToEntity(dto[key]);
+      if (Array.isArray(value)) {
+        value = value.map((item) => dtoToEntity(item));
+      } else if (typeof value === 'object') {
+        value = dtoToEntity(value);
       }
+      //  else if (typeof value === 'string') {
+      //   value = replaceQuotes(value);
+      // }
       dbEntity[snakeCaseKey] = value;
     }
   });
diff --git a/src/utils/ipfs/helpers.ts b/src/utils/ipfs/helpers.ts
index 4fcef209f..e3e1d6fd0 100644
--- a/src/utils/ipfs/helpers.ts
+++ b/src/utils/ipfs/helpers.ts
@@ -1,9 +1,15 @@
 import Unixfs from 'ipfs-unixfs';
 import { DAGNode, util as DAGUtil } from 'ipld-dag-pb';
 import { isString } from 'lodash';
-import { IpfsApi } from 'src/services/backend/workers/background/worker';
+import { RemoteIpfsApi } from 'src/services/backend/workers/background/worker';
 import { ParticleCid } from 'src/types/base';
 import { PATTERN_IPFS_HASH } from 'src/constants/patterns';
+import { Remote } from 'comlink';
+import { IpfsApi } from 'src/services/backend/workers/background/api/ipfsApi';
+
+export const isCID = (cid: string): boolean => {
+  return cid.match(PATTERN_IPFS_HASH) !== null;
+};
 
 // eslint-disable-next-line import/prefer-default-export
 export const getIpfsHash = (string: string): Promise<ParticleCid> =>
@@ -23,7 +29,7 @@ export const getIpfsHash = (string: string): Promise<ParticleCid> =>
   });
 export const addIfpsMessageOrCid = async (
   message: string | ParticleCid | File,
-  { ipfsApi }: { ipfsApi: IpfsApi | null }
+  { ipfsApi }: { ipfsApi: Remote<IpfsApi> | null }
 ) => {
   if (!ipfsApi) {
     throw Error('IpfsApi is not initialized');
diff --git a/src/utils/localStorage.ts b/src/utils/localStorage.ts
new file mode 100644
index 000000000..50d63faa4
--- /dev/null
+++ b/src/utils/localStorage.ts
@@ -0,0 +1,66 @@
+import { ScriptEntrypointNames } from 'src/services/scripting/types';
+import { KeyValueString } from 'src/types/data';
+
+type JsonTypeKeys = 'secrets';
+
+type StringTypeKeys =
+  | ScriptEntrypointNames
+  | `${ScriptEntrypointNames[0]}_enabled`
+  | `${ScriptEntrypointNames[1]}_enabled`;
+
+const jsonKeyMap: Record<JsonTypeKeys, string> = {
+  secrets: 'secrets',
+};
+
+const stringKeyMap: Record<StringTypeKeys, string> = {
+  particle: 'script_particle',
+  // myParticle: 'script_particle_inference',
+};
+
+const keyValuesToObject = (data: KeyValueString[]) => {
+  return Object.fromEntries(
+    Object.values(data)
+      .filter((row) => !!row?.key)
+      .map((row) => [row.key, row.value])
+  );
+};
+
+const saveJsonToLocalStorage = (storageKey: JsonTypeKeys, data: Object) => {
+  localStorage.setItem(jsonKeyMap[storageKey], JSON.stringify(data));
+};
+
+const loadJsonFromLocalStorage = (
+  storageKey: JsonTypeKeys,
+  defaultData: Object
+) => {
+  const raw = localStorage.getItem(jsonKeyMap[storageKey]);
+  return raw ? JSON.parse(raw) : defaultData;
+};
+
+const loadStringFromLocalStorage = (
+  name: StringTypeKeys,
+  defaultValue?: string
+) => {
+  const keyName = stringKeyMap[name] || name;
+  const result = localStorage.getItem(keyName) || defaultValue;
+  return result;
+};
+
+const saveStringToLocalStorage = (name: StringTypeKeys, value: string) => {
+  const keyName = stringKeyMap[name] || name;
+  localStorage.setItem(keyName, value);
+};
+
+const getEntrypointKeyName = (
+  name: ScriptEntrypointNames,
+  prefix: 'enabled'
+): StringTypeKeys => `${name}_${prefix}`;
+
+export {
+  saveJsonToLocalStorage,
+  loadJsonFromLocalStorage,
+  loadStringFromLocalStorage,
+  saveStringToLocalStorage,
+  getEntrypointKeyName,
+  keyValuesToObject,
+};
diff --git a/src/utils/search/utils.ts b/src/utils/search/utils.ts
index 00db3144a..c0c2e6eaf 100644
--- a/src/utils/search/utils.ts
+++ b/src/utils/search/utils.ts
@@ -5,6 +5,10 @@ import { DelegationResponse } from 'cosmjs-types/cosmos/staking/v1beta1/staking'
 import { CID_TWEET } from 'src/constants/app';
 import { LCD_URL } from 'src/constants/config';
 import { LinksType, LinksTypeFilter } from 'src/containers/Search/types';
+import { ParticleCid } from 'src/types/base';
+import { PATTERN_IPFS_HASH } from 'src/constants/patterns';
+import { getIpfsHash } from '../ipfs/helpers';
+import { encodeSlash } from '../utils';
 
 export const formatNumber = (number, toFixed) => {
   let formatted = +number;
@@ -707,6 +711,9 @@ export const getCredit = async (address) => {
   }
 };
 
+export const getSearchQuery = async (query: ParticleCid | string) =>
+  query.match(PATTERN_IPFS_HASH) ? query : getIpfsHash(encodeSlash(query));
+
 export const searchByHash = async (
   client: CyberClient,
   hash: string,
diff --git a/src/utils/string.ts b/src/utils/string.ts
new file mode 100644
index 000000000..ab6d1cb60
--- /dev/null
+++ b/src/utils/string.ts
@@ -0,0 +1,71 @@
+export function shortenString(string: string, length = 300) {
+  return string.length > length ? `${string.slice(0, length)}...` : string;
+}
+
+export function replaceQuotes(string: string) {
+  return string.replace(/"/g, "'");
+}
+
+export function serializeString(input: string): string {
+  return input
+    .replace(/\\/g, '\\\\') // Escape backslashes
+    .replace(/"/g, "\\''") // Escape double quotes
+    .replace(/'/g, "\\'") // Escape single quotes
+    .replace(/\n/g, '\\n') // Escape newlines
+    .replace(/\r/g, '\\r') // Escape carriage returns
+    .replace(/#/g, '\\!!'); // Escape  - that's comment in cozo
+}
+
+export function deserializeString(serialized: string): string {
+  return serialized
+    .replace(/\\r/g, '\r') // Unescape carriage returns
+    .replace(/\\n/g, '\n') // Unescape newlines
+    .replace(/\\'/g, "'") // Unescape single quotes
+    .replace(/\\''/g, '"') // Unescape double quotes
+    .replace(/\\\\/g, '\\') // Unescape backslashes
+    .replace(/\\!!/g, '#'); // Unescape # cozo comment
+}
+
+const specialCharsRegexe = /\\u\{[a-fA-F0-9]+\}/g;
+
+export function removeBrokenUnicode(string: string): string {
+  return string.replace(specialCharsRegexe, '');
+}
+
+export function removeMarkdownFormatting(markdown: string): string {
+  // Remove headers
+  let text = markdown.replace(/^#{1,6}\s+/gm, '');
+
+  // Remove emphasis (bold, italic, strikethrough)
+  text = text.replace(/(\*\*|__)(.*?)\1/g, '$2');
+  text = text.replace(/(\*|_)(.*?)\1/g, '$2');
+  text = text.replace(/(~~)(.*?)\1/g, '$2');
+
+  // Remove inline code and code blocks
+  text = text.replace(/`{1,3}[^`](.*?)`{1,3}/g, '$1');
+  text = text.replace(/```[\s\S]*?```/g, '');
+
+  // Remove blockquotes
+  text = text.replace(/^\s{0,3}>\s?/gm, '');
+
+  // Remove links
+  text = text.replace(/\[(.*?)\]\(.*?\)/g, '$1');
+
+  // Remove images
+  text = text.replace(/!\[(.*?)\]\(.*?\)/g, '$1');
+
+  // Remove horizontal rules
+  text = text.replace(/^-{3,}$/gm, '');
+
+  // Remove unordered lists
+  text = text.replace(/^\s*[-+*]\s+/gm, '');
+
+  // Remove ordered lists
+  text = text.replace(/^\s*\d+\.\s+/gm, '');
+
+  // Remove extra spaces and new lines
+  text = text.replace(/\n{2,}/g, '\n\n');
+  text = text.replace(/^\s+|\s+$/g, '');
+
+  return text;
+}
diff --git a/webpack.config.common.js b/webpack.config.common.js
index 7087f4071..689441412 100644
--- a/webpack.config.common.js
+++ b/webpack.config.common.js
@@ -18,8 +18,6 @@ const config = {
   devtool: 'cheap-module-source-map',
   entry: {
     main: [path.join(__dirname, 'src', 'index.tsx')],
-    // helia: 'helia',
-    // cozodb: 'cyb-cozo-lib-wasm',
   },
   output: {
     filename: '[name].js',
@@ -201,6 +199,10 @@ const config = {
         exclude: /node_modules/,
         use: 'graphql-tag/loader',
       },
+      {
+        test: /\.rn$/,
+        type: 'asset/source',
+      },
     ],
   },
 };
diff --git a/webpack.config.prod.js b/webpack.config.prod.js
index f9e7ec277..fc67c879f 100644
--- a/webpack.config.prod.js
+++ b/webpack.config.prod.js
@@ -32,17 +32,17 @@ module.exports = merge(commonConfig, {
         cache: true,
         sourceMap: true,
       }),
-      ...(!process.env.IPFS_DEPLOY
-        ? [
-          new CompressionWebpackPlugin({
-            filename: '[path][base].gz',
-            algorithm: 'gzip',
-            test: /\.js$|\.css$|\.html$|\.eot?.+$|\.ttf?.+$|\.woff?.+$|\.svg+$|\.wasm?.+$/,
-            threshold: 10240,
-            minRatio: 0.8,
-          }),
-        ]
-        : []),
+      // ...(!process.env.IPFS_DEPLOY
+      //   ? [
+      //       new CompressionWebpackPlugin({
+      //         filename: '[path][base].gz',
+      //         algorithm: 'gzip',
+      //         test: /\.js$|\.css$|\.html$|\.eot?.+$|\.ttf?.+$|\.woff?.+$|\.svg+$|\.wasm?.+$/,
+      //         threshold: 10240,
+      //         minRatio: 0.8,
+      //       }),
+      //     ]
+      //   : []),
     ],
   },
   plugins: [
diff --git a/yarn.lock b/yarn.lock
index 5aca212b6..cd691e9ed 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,6 +221,14 @@
     "@babel/highlight" "^7.24.2"
     picocolors "^1.0.0"
 
+"@babel/code-frame@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.24.6.tgz#ab88da19344445c3d8889af2216606d3329f3ef2"
+  integrity sha512-ZJhac6FkEd1yhG2AHOmfcXG4ceoLltoCVJjN5XsWN9BifBQr+cHJbWi0h68HZuSORq+3WtJ2z0hwF2NG1b5kcA==
+  dependencies:
+    "@babel/highlight" "^7.24.6"
+    picocolors "^1.0.0"
+
 "@babel/compat-data@^7.17.7", "@babel/compat-data@^7.20.1", "@babel/compat-data@^7.20.5":
   version "7.21.0"
   resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.21.0.tgz#c241dc454e5b5917e40d37e525e2f4530c399298"
@@ -241,10 +249,10 @@
   resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.24.1.tgz#31c1f66435f2a9c329bb5716a6d6186c516c3742"
   integrity sha512-Pc65opHDliVpRHuKfzI+gSA4zcgr65O4cl64fFJIWEEh8JoHIHh0Oez1Eo8Arz8zq/JhgKodQaxEwUPRtZylVA==
 
-"@babel/compat-data@^7.24.4":
-  version "7.24.4"
-  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.24.4.tgz#6f102372e9094f25d908ca0d34fc74c74606059a"
-  integrity sha512-vg8Gih2MLK+kOkHJp4gBEIkyaIi00jgWot2D9QOmmfLC8jINSOzmCLta6Bvz/JSBCqnegV0L80jhxkol5GWNfQ==
+"@babel/compat-data@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.24.6.tgz#b3600217688cabb26e25f8e467019e66d71b7ae2"
+  integrity sha512-aC2DGhBq5eEdyXWqrDInSqQjO0k8xtPRf5YylULqx8MCd6jBtzqfta/3ETMRpuKIc5hyswfO80ObyA1MvkCcUQ==
 
 "@babel/core@^7.0.0-0", "@babel/core@^7.1.0", "@babel/core@^7.1.6", "@babel/core@^7.11.6", "@babel/core@^7.12.17", "@babel/core@^7.12.3", "@babel/core@^7.13.16", "@babel/core@^7.7.5":
   version "7.21.5"
@@ -310,20 +318,20 @@
     semver "^6.3.1"
 
 "@babel/core@^7.24.4":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.24.5.tgz#15ab5b98e101972d171aeef92ac70d8d6718f06a"
-  integrity sha512-tVQRucExLQ02Boi4vdPp49svNGcfL2GhdTCT9aldhXgCJVAI21EtRfBettiuLUwce/7r6bFdgs6JFkcdTiFttA==
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.24.6.tgz#8650e0e4b03589ebe886c4e4a60398db0a7ec787"
+  integrity sha512-qAHSfAdVyFmIvl0VHELib8xar7ONuSHrE2hLnsaWkYNTI68dmi1x8GYDhJjMI/e7XWal9QBlZkwbOnkcw7Z8gQ==
   dependencies:
     "@ampproject/remapping" "^2.2.0"
-    "@babel/code-frame" "^7.24.2"
-    "@babel/generator" "^7.24.5"
-    "@babel/helper-compilation-targets" "^7.23.6"
-    "@babel/helper-module-transforms" "^7.24.5"
-    "@babel/helpers" "^7.24.5"
-    "@babel/parser" "^7.24.5"
-    "@babel/template" "^7.24.0"
-    "@babel/traverse" "^7.24.5"
-    "@babel/types" "^7.24.5"
+    "@babel/code-frame" "^7.24.6"
+    "@babel/generator" "^7.24.6"
+    "@babel/helper-compilation-targets" "^7.24.6"
+    "@babel/helper-module-transforms" "^7.24.6"
+    "@babel/helpers" "^7.24.6"
+    "@babel/parser" "^7.24.6"
+    "@babel/template" "^7.24.6"
+    "@babel/traverse" "^7.24.6"
+    "@babel/types" "^7.24.6"
     convert-source-map "^2.0.0"
     debug "^4.1.0"
     gensync "^1.0.0-beta.2"
@@ -379,12 +387,12 @@
     "@jridgewell/trace-mapping" "^0.3.17"
     jsesc "^2.5.1"
 
-"@babel/generator@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.24.5.tgz#e5afc068f932f05616b66713e28d0f04e99daeb3"
-  integrity sha512-x32i4hEXvr+iI0NEoEfDKzlemF8AmtOP8CcrRaEcpzysWuoEb1KknpcvMsHKPONoKZiDuItklgWhB18xEhr9PA==
+"@babel/generator@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.24.6.tgz#dfac82a228582a9d30c959fe50ad28951d4737a7"
+  integrity sha512-S7m4eNa6YAPJRHmKsLHIDJhNAGNKoWNiWefz1MBbpnt8g9lvMDl1hir4P9bo/57bQEmuwEhnRU/AMWsD0G/Fbg==
   dependencies:
-    "@babel/types" "^7.24.5"
+    "@babel/types" "^7.24.6"
     "@jridgewell/gen-mapping" "^0.3.5"
     "@jridgewell/trace-mapping" "^0.3.25"
     jsesc "^2.5.1"
@@ -403,6 +411,13 @@
   dependencies:
     "@babel/types" "^7.22.5"
 
+"@babel/helper-annotate-as-pure@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.24.6.tgz#517af93abc77924f9b2514c407bbef527fb8938d"
+  integrity sha512-DitEzDfOMnd13kZnDqns1ccmftwJTS9DMkyn9pYTxulS7bZxUxpMly3Nf23QQ6NwA4UB8lAqjbqWtyvElEMAkg==
+  dependencies:
+    "@babel/types" "^7.24.6"
+
 "@babel/helper-builder-binary-assignment-operator-visitor@^7.18.6":
   version "7.18.9"
   resolved "https://registry.yarnpkg.com/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.18.9.tgz#acd4edfd7a566d1d51ea975dff38fd52906981bb"
@@ -411,13 +426,6 @@
     "@babel/helper-explode-assignable-expression" "^7.18.6"
     "@babel/types" "^7.18.9"
 
-"@babel/helper-builder-binary-assignment-operator-visitor@^7.22.15":
-  version "7.22.15"
-  resolved "https://registry.yarnpkg.com/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.22.15.tgz#5426b109cf3ad47b91120f8328d8ab1be8b0b956"
-  integrity sha512-QkBXwGgaoC2GtGZRoma6kv7Szfv06khvhFav67ZExau2RaXzy8MpHSMO2PNoP2XtmQphJQRHFfg77Bq731Yizw==
-  dependencies:
-    "@babel/types" "^7.22.15"
-
 "@babel/helper-builder-binary-assignment-operator-visitor@^7.22.5":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.22.5.tgz#a3f4758efdd0190d8927fcffd261755937c71878"
@@ -425,6 +433,13 @@
   dependencies:
     "@babel/types" "^7.22.5"
 
+"@babel/helper-builder-binary-assignment-operator-visitor@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.24.6.tgz#19e9089ee87b0d0928012c83961a8deef4b0223f"
+  integrity sha512-+wnfqc5uHiMYtvRX7qu80Toef8BXeh4HHR1SPeonGb1SKPniNEd4a/nlaJJMv/OIEYvIVavvo0yR7u10Gqz0Iw==
+  dependencies:
+    "@babel/types" "^7.24.6"
+
 "@babel/helper-compilation-targets@^7.17.7", "@babel/helper-compilation-targets@^7.18.9", "@babel/helper-compilation-targets@^7.20.0", "@babel/helper-compilation-targets@^7.20.7":
   version "7.20.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.20.7.tgz#a6cd33e93629f5eb473b021aac05df62c4cd09bb"
@@ -469,6 +484,17 @@
     lru-cache "^5.1.1"
     semver "^6.3.1"
 
+"@babel/helper-compilation-targets@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.24.6.tgz#4a51d681f7680043d38e212715e2a7b1ad29cb51"
+  integrity sha512-VZQ57UsDGlX/5fFA7GkVPplZhHsVc+vuErWgdOiysI9Ksnw0Pbbd6pnPiR/mmJyKHgyIW0c7KT32gmhiF+cirg==
+  dependencies:
+    "@babel/compat-data" "^7.24.6"
+    "@babel/helper-validator-option" "^7.24.6"
+    browserslist "^4.22.2"
+    lru-cache "^5.1.1"
+    semver "^6.3.1"
+
 "@babel/helper-create-class-features-plugin@^7.18.6", "@babel/helper-create-class-features-plugin@^7.21.0":
   version "7.21.0"
   resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.21.0.tgz#64f49ecb0020532f19b1d014b03bccaa1ab85fb9"
@@ -498,19 +524,19 @@
     "@babel/helper-split-export-declaration" "^7.22.6"
     semver "^6.3.1"
 
-"@babel/helper-create-class-features-plugin@^7.24.1", "@babel/helper-create-class-features-plugin@^7.24.4", "@babel/helper-create-class-features-plugin@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.24.5.tgz#7d19da92c7e0cd8d11c09af2ce1b8e7512a6e723"
-  integrity sha512-uRc4Cv8UQWnE4NXlYTIIdM7wfFkOqlFztcC/gVXDKohKoVB3OyonfelUBaJzSwpBntZ2KYGF/9S7asCHsXwW6g==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.22.5"
-    "@babel/helper-environment-visitor" "^7.22.20"
-    "@babel/helper-function-name" "^7.23.0"
-    "@babel/helper-member-expression-to-functions" "^7.24.5"
-    "@babel/helper-optimise-call-expression" "^7.22.5"
-    "@babel/helper-replace-supers" "^7.24.1"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.22.5"
-    "@babel/helper-split-export-declaration" "^7.24.5"
+"@babel/helper-create-class-features-plugin@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.24.6.tgz#c50b86fa1c4ca9b7a890dc21884f097b6c4b5286"
+  integrity sha512-djsosdPJVZE6Vsw3kk7IPRWethP94WHGOhQTc67SNXE0ZzMhHgALw8iGmYS0TD1bbMM0VDROy43od7/hN6WYcA==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.24.6"
+    "@babel/helper-environment-visitor" "^7.24.6"
+    "@babel/helper-function-name" "^7.24.6"
+    "@babel/helper-member-expression-to-functions" "^7.24.6"
+    "@babel/helper-optimise-call-expression" "^7.24.6"
+    "@babel/helper-replace-supers" "^7.24.6"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.24.6"
+    "@babel/helper-split-export-declaration" "^7.24.6"
     semver "^6.3.1"
 
 "@babel/helper-create-regexp-features-plugin@^7.18.6", "@babel/helper-create-regexp-features-plugin@^7.20.5":
@@ -521,15 +547,6 @@
     "@babel/helper-annotate-as-pure" "^7.18.6"
     regexpu-core "^5.3.1"
 
-"@babel/helper-create-regexp-features-plugin@^7.22.15":
-  version "7.22.15"
-  resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.22.15.tgz#5ee90093914ea09639b01c711db0d6775e558be1"
-  integrity sha512-29FkPLFjn4TPEa3RE7GpW+qbE8tlsu3jntNYNfcGsc49LphF1PQIiD+vMZ1z1xVOKt+93khA9tc2JBs3kBjA7w==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.22.5"
-    regexpu-core "^5.3.1"
-    semver "^6.3.1"
-
 "@babel/helper-create-regexp-features-plugin@^7.22.5":
   version "7.22.9"
   resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.22.9.tgz#9d8e61a8d9366fe66198f57c40565663de0825f6"
@@ -539,6 +556,15 @@
     regexpu-core "^5.3.1"
     semver "^6.3.1"
 
+"@babel/helper-create-regexp-features-plugin@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.24.6.tgz#47d382dec0d49e74ca1b6f7f3b81f5968022a3c8"
+  integrity sha512-C875lFBIWWwyv6MHZUG9HmRrlTDgOsLWZfYR0nW69gaKJNe0/Mpxx5r0EID2ZdHQkdUmQo2t0uNckTL08/1BgA==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.24.6"
+    regexpu-core "^5.3.1"
+    semver "^6.3.1"
+
 "@babel/helper-define-polyfill-provider@^0.3.3":
   version "0.3.3"
   resolved "https://registry.yarnpkg.com/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.3.3.tgz#8612e55be5d51f0cd1f36b4a5a83924e89884b7a"
@@ -593,6 +619,11 @@
   resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.5.tgz#f06dd41b7c1f44e1f8da6c4055b41ab3a09a7e98"
   integrity sha512-XGmhECfVA/5sAt+H+xpSg0mfrHq6FzNr9Oxh7PSEBBRUb/mL7Kz3NICXb194rCqAEdxkhPT1a88teizAFyvk8Q==
 
+"@babel/helper-environment-visitor@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.24.6.tgz#ac7ad5517821641550f6698dd5468f8cef78620d"
+  integrity sha512-Y50Cg3k0LKLMjxdPjIl40SdJgMB85iXn27Vk/qbHZCFx/o5XO3PSnpi675h1KEmmDb6OFArfd5SCQEQ5Q4H88g==
+
 "@babel/helper-explode-assignable-expression@^7.18.6":
   version "7.18.6"
   resolved "https://registry.yarnpkg.com/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.18.6.tgz#41f8228ef0a6f1a036b8dfdfec7ce94f9a6bc096"
@@ -624,6 +655,14 @@
     "@babel/template" "^7.22.15"
     "@babel/types" "^7.23.0"
 
+"@babel/helper-function-name@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.24.6.tgz#cebdd063386fdb95d511d84b117e51fc68fec0c8"
+  integrity sha512-xpeLqeeRkbxhnYimfr2PC+iA0Q7ljX/d1eZ9/inYbmfG2jpl8Lu3DyXvpOAnrS5kxkfOWJjioIMQsaMBXFI05w==
+  dependencies:
+    "@babel/template" "^7.24.6"
+    "@babel/types" "^7.24.6"
+
 "@babel/helper-hoist-variables@^7.18.6":
   version "7.18.6"
   resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz#d4d2c8fb4baeaa5c68b99cc8245c56554f926678"
@@ -638,6 +677,13 @@
   dependencies:
     "@babel/types" "^7.22.5"
 
+"@babel/helper-hoist-variables@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.24.6.tgz#8a7ece8c26756826b6ffcdd0e3cf65de275af7f9"
+  integrity sha512-SF/EMrC3OD7dSta1bLJIlrsVxwtd0UpjRJqLno6125epQMJ/kyFmpTT4pbvPbdQHzCHg+biQ7Syo8lnDtbR+uA==
+  dependencies:
+    "@babel/types" "^7.24.6"
+
 "@babel/helper-member-expression-to-functions@^7.20.7", "@babel/helper-member-expression-to-functions@^7.21.0":
   version "7.21.0"
   resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.21.0.tgz#319c6a940431a133897148515877d2f3269c3ba5"
@@ -659,19 +705,19 @@
   dependencies:
     "@babel/types" "^7.23.0"
 
-"@babel/helper-member-expression-to-functions@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.24.5.tgz#5981e131d5c7003c7d1fa1ad49e86c9b097ec475"
-  integrity sha512-4owRteeihKWKamtqg4JmWSsEZU445xpFRXPEwp44HbgbxdWlUV1b4Agg4lkA806Lil5XM/e+FJyS0vj5T6vmcA==
+"@babel/helper-member-expression-to-functions@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.24.6.tgz#86084f3e0e4e2169a134754df3870bc7784db71e"
+  integrity sha512-OTsCufZTxDUsv2/eDXanw/mUZHWOxSbEmC3pP8cgjcy5rgeVPWWMStnv274DV60JtHxTk0adT0QrCzC4M9NWGg==
   dependencies:
-    "@babel/types" "^7.24.5"
+    "@babel/types" "^7.24.6"
 
-"@babel/helper-module-imports@^7.10.4", "@babel/helper-module-imports@^7.22.15", "@babel/helper-module-imports@^7.24.1", "@babel/helper-module-imports@^7.24.3":
-  version "7.24.3"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.24.3.tgz#6ac476e6d168c7c23ff3ba3cf4f7841d46ac8128"
-  integrity sha512-viKb0F9f2s0BCS22QSF308z/+1YWKV/76mwt61NBzS5izMzDPwdq1pTrzf+Li3npBWX9KdQbkeCt1jSAM7lZqg==
+"@babel/helper-module-imports@^7.10.4", "@babel/helper-module-imports@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.24.6.tgz#65e54ffceed6a268dc4ce11f0433b82cfff57852"
+  integrity sha512-a26dmxFJBF62rRO9mmpgrfTLsAuyHk4e1hKTUkD/fcMfynt8gvEKwQPQDVxWhca8dHoDck+55DFt42zV0QMw5g==
   dependencies:
-    "@babel/types" "^7.24.0"
+    "@babel/types" "^7.24.6"
 
 "@babel/helper-module-imports@^7.18.6":
   version "7.18.6"
@@ -687,6 +733,13 @@
   dependencies:
     "@babel/types" "^7.21.4"
 
+"@babel/helper-module-imports@^7.22.15":
+  version "7.24.3"
+  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.24.3.tgz#6ac476e6d168c7c23ff3ba3cf4f7841d46ac8128"
+  integrity sha512-viKb0F9f2s0BCS22QSF308z/+1YWKV/76mwt61NBzS5izMzDPwdq1pTrzf+Li3npBWX9KdQbkeCt1jSAM7lZqg==
+  dependencies:
+    "@babel/types" "^7.24.0"
+
 "@babel/helper-module-imports@^7.22.5":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.22.5.tgz#1a8f4c9f4027d23f520bd76b364d44434a72660c"
@@ -744,16 +797,16 @@
     "@babel/helper-split-export-declaration" "^7.22.6"
     "@babel/helper-validator-identifier" "^7.22.20"
 
-"@babel/helper-module-transforms@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.24.5.tgz#ea6c5e33f7b262a0ae762fd5986355c45f54a545"
-  integrity sha512-9GxeY8c2d2mdQUP1Dye0ks3VDyIMS98kt/llQ2nUId8IsWqTF0l1LkSX0/uP7l7MCDrzXS009Hyhe2gzTiGW8A==
+"@babel/helper-module-transforms@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.24.6.tgz#22346ed9df44ce84dee850d7433c5b73fab1fe4e"
+  integrity sha512-Y/YMPm83mV2HJTbX1Qh2sjgjqcacvOlhbzdCCsSlblOKjSYmQqEbO6rUniWQyRo9ncyfjT8hnUjlG06RXDEmcA==
   dependencies:
-    "@babel/helper-environment-visitor" "^7.22.20"
-    "@babel/helper-module-imports" "^7.24.3"
-    "@babel/helper-simple-access" "^7.24.5"
-    "@babel/helper-split-export-declaration" "^7.24.5"
-    "@babel/helper-validator-identifier" "^7.24.5"
+    "@babel/helper-environment-visitor" "^7.24.6"
+    "@babel/helper-module-imports" "^7.24.6"
+    "@babel/helper-simple-access" "^7.24.6"
+    "@babel/helper-split-export-declaration" "^7.24.6"
+    "@babel/helper-validator-identifier" "^7.24.6"
 
 "@babel/helper-optimise-call-expression@^7.18.6":
   version "7.18.6"
@@ -769,6 +822,13 @@
   dependencies:
     "@babel/types" "^7.22.5"
 
+"@babel/helper-optimise-call-expression@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.24.6.tgz#f7836e3ccca3dfa02f15d2bc8b794efe75a5256e"
+  integrity sha512-3SFDJRbx7KuPRl8XDUr8O7GAEB8iGyWPjLKJh/ywP/Iy9WOmEfMrsWbaZpvBu2HSYn4KQygIsz0O7m8y10ncMA==
+  dependencies:
+    "@babel/types" "^7.24.6"
+
 "@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.14.5", "@babel/helper-plugin-utils@^7.16.7", "@babel/helper-plugin-utils@^7.18.6", "@babel/helper-plugin-utils@^7.18.9", "@babel/helper-plugin-utils@^7.19.0", "@babel/helper-plugin-utils@^7.20.2", "@babel/helper-plugin-utils@^7.8.0", "@babel/helper-plugin-utils@^7.8.3":
   version "7.20.2"
   resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.20.2.tgz#d1b9000752b18d0877cff85a5c376ce5c3121629"
@@ -789,10 +849,10 @@
   resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.24.0.tgz#945681931a52f15ce879fd5b86ce2dae6d3d7f2a"
   integrity sha512-9cUznXMG0+FxRuJfvL82QlTqIzhVW9sL0KjMPHhAOOvpQGL8QtdxnBKILjBqxlHyliz0yCa1G903ZXI/FuHy2w==
 
-"@babel/helper-plugin-utils@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.24.5.tgz#a924607dd254a65695e5bd209b98b902b3b2f11a"
-  integrity sha512-xjNLDopRzW2o6ba0gKbkZq5YWEBaK3PCyTOY1K2P/O07LGMhMqlMXPxwN4S5/RhWuCobT8z0jrlKGlYmeR1OhQ==
+"@babel/helper-plugin-utils@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.24.6.tgz#fa02a32410a15a6e8f8185bcbf608f10528d2a24"
+  integrity sha512-MZG/JcWfxybKwsA9N9PmtF2lOSFSEMVCpIRrbxccZFLJPrJciJdG/UhSh5W96GEteJI2ARqm5UAHxISwRDLSNg==
 
 "@babel/helper-remap-async-to-generator@^7.18.9":
   version "7.18.9"
@@ -804,15 +864,6 @@
     "@babel/helper-wrap-function" "^7.18.9"
     "@babel/types" "^7.18.9"
 
-"@babel/helper-remap-async-to-generator@^7.22.20":
-  version "7.22.20"
-  resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.22.20.tgz#7b68e1cb4fa964d2996fd063723fb48eca8498e0"
-  integrity sha512-pBGyV4uBqOns+0UvhsTO8qgl8hO89PmiDYv+/COyp1aeMcmfrfruz+/nCMFiYyFF/Knn0yfrC85ZzNFjembFTw==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.22.5"
-    "@babel/helper-environment-visitor" "^7.22.20"
-    "@babel/helper-wrap-function" "^7.22.20"
-
 "@babel/helper-remap-async-to-generator@^7.22.5":
   version "7.22.9"
   resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.22.9.tgz#53a25b7484e722d7efb9c350c75c032d4628de82"
@@ -822,6 +873,15 @@
     "@babel/helper-environment-visitor" "^7.22.5"
     "@babel/helper-wrap-function" "^7.22.9"
 
+"@babel/helper-remap-async-to-generator@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.24.6.tgz#c96ceb9846e877d806ce82a1521230ea7e0fc354"
+  integrity sha512-1Qursq9ArRZPAMOZf/nuzVW8HgJLkTB9y9LfP4lW2MVp4e9WkLJDovfKBxoDcCk6VuzIxyqWHyBoaCtSRP10yg==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.24.6"
+    "@babel/helper-environment-visitor" "^7.24.6"
+    "@babel/helper-wrap-function" "^7.24.6"
+
 "@babel/helper-replace-supers@^7.18.6", "@babel/helper-replace-supers@^7.20.7":
   version "7.20.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.20.7.tgz#243ecd2724d2071532b2c8ad2f0f9f083bcae331"
@@ -852,6 +912,15 @@
     "@babel/helper-member-expression-to-functions" "^7.23.0"
     "@babel/helper-optimise-call-expression" "^7.22.5"
 
+"@babel/helper-replace-supers@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.24.6.tgz#3ea87405a2986a49ab052d10e540fe036d747c71"
+  integrity sha512-mRhfPwDqDpba8o1F8ESxsEkJMQkUF8ZIWrAc0FtWhxnjfextxMWxr22RtFizxxSYLjVHDeMgVsRq8BBZR2ikJQ==
+  dependencies:
+    "@babel/helper-environment-visitor" "^7.24.6"
+    "@babel/helper-member-expression-to-functions" "^7.24.6"
+    "@babel/helper-optimise-call-expression" "^7.24.6"
+
 "@babel/helper-simple-access@^7.20.2":
   version "7.20.2"
   resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.20.2.tgz#0ab452687fe0c2cfb1e2b9e0015de07fc2d62dd9"
@@ -873,12 +942,12 @@
   dependencies:
     "@babel/types" "^7.22.5"
 
-"@babel/helper-simple-access@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.24.5.tgz#50da5b72f58c16b07fbd992810be6049478e85ba"
-  integrity sha512-uH3Hmf5q5n7n8mz7arjUlDOCbttY/DW4DYhE6FUsjKJ/oYC1kQQUvwEQWxRwUpX9qQKRXeqLwWxrqilMrf32sQ==
+"@babel/helper-simple-access@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.24.6.tgz#1d6e04d468bba4fc963b4906f6dac6286cfedff1"
+  integrity sha512-nZzcMMD4ZhmB35MOOzQuiGO5RzL6tJbsT37Zx8M5L/i9KSrukGXWTjLe1knIbb/RmxoJE9GON9soq0c0VEMM5g==
   dependencies:
-    "@babel/types" "^7.24.5"
+    "@babel/types" "^7.24.6"
 
 "@babel/helper-skip-transparent-expression-wrappers@^7.20.0":
   version "7.20.0"
@@ -894,6 +963,13 @@
   dependencies:
     "@babel/types" "^7.22.5"
 
+"@babel/helper-skip-transparent-expression-wrappers@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.24.6.tgz#c47e9b33b7ea50d1073e125ebc26661717cb7040"
+  integrity sha512-jhbbkK3IUKc4T43WadP96a27oYti9gEf1LdyGSP2rHGH77kwLwfhO7TgwnWvxxQVmke0ImmCSS47vcuxEMGD3Q==
+  dependencies:
+    "@babel/types" "^7.24.6"
+
 "@babel/helper-split-export-declaration@^7.18.6":
   version "7.18.6"
   resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz#7367949bc75b20c6d5a5d4a97bba2824ae8ef075"
@@ -908,12 +984,12 @@
   dependencies:
     "@babel/types" "^7.22.5"
 
-"@babel/helper-split-export-declaration@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.24.5.tgz#b9a67f06a46b0b339323617c8c6213b9055a78b6"
-  integrity sha512-5CHncttXohrHk8GWOFCcCl4oRD9fKosWlIRgWm4ql9VYioKm52Mk2xsmoohvm7f3JoiLSM5ZgJuRaf5QZZYd3Q==
+"@babel/helper-split-export-declaration@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.24.6.tgz#e830068f7ba8861c53b7421c284da30ae656d7a3"
+  integrity sha512-CvLSkwXGWnYlF9+J3iZUvwgAxKiYzK3BWuo+mLzD/MDGOZDj7Gq8+hqaOkMxmJwmlv0iu86uH5fdADd9Hxkymw==
   dependencies:
-    "@babel/types" "^7.24.5"
+    "@babel/types" "^7.24.6"
 
 "@babel/helper-string-parser@^7.19.4":
   version "7.19.4"
@@ -930,11 +1006,16 @@
   resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz#533f36457a25814cf1df6488523ad547d784a99f"
   integrity sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==
 
-"@babel/helper-string-parser@^7.23.4", "@babel/helper-string-parser@^7.24.1":
+"@babel/helper-string-parser@^7.23.4":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.24.1.tgz#f99c36d3593db9540705d0739a1f10b5e20c696e"
   integrity sha512-2ofRCjnnA9y+wk8b9IAREroeUP02KHp431N2mhKniy2yKIDKpbrHv9eXwm8cBeWQYcJmzv5qKCu65P47eCF7CQ==
 
+"@babel/helper-string-parser@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.24.6.tgz#28583c28b15f2a3339cfafafeaad42f9a0e828df"
+  integrity sha512-WdJjwMEkmBicq5T9fm/cHND3+UlFa2Yj8ALLgmoSQAJZysYbBjw+azChSGPN4DSPLXOcooGRvDwZWMcF/mLO2Q==
+
 "@babel/helper-validator-identifier@^7.18.6", "@babel/helper-validator-identifier@^7.19.1":
   version "7.19.1"
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz#7eea834cf32901ffdc1a7ee555e2f9c27e249ca2"
@@ -950,10 +1031,10 @@
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.5.tgz#9544ef6a33999343c8740fa51350f30eeaaaf193"
   integrity sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==
 
-"@babel/helper-validator-identifier@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.24.5.tgz#918b1a7fa23056603506370089bd990d8720db62"
-  integrity sha512-3q93SSKX2TWCG30M2G2kwaKeTYgEUp5Snjuj8qm729SObL6nbtUldAi37qbxkD5gg3xnBio+f9nqpSepGZMvxA==
+"@babel/helper-validator-identifier@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.24.6.tgz#08bb6612b11bdec78f3feed3db196da682454a5e"
+  integrity sha512-4yA7s865JHaqUdRbnaxarZREuPTHrjpDT+pXoAZ1yhyo6uFnIEpS8VMu16siFOHDpZNKYv5BObhsB//ycbICyw==
 
 "@babel/helper-validator-option@^7.18.6", "@babel/helper-validator-option@^7.21.0":
   version "7.21.0"
@@ -970,6 +1051,11 @@
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.23.5.tgz#907a3fbd4523426285365d1206c423c4c5520307"
   integrity sha512-85ttAOMLsr53VgXkTbkx8oA6YTfT4q7/HzXSLEYmjcSTJPMPQtvq1BD79Byep5xMUYbGRzEpDsjUf3dyp54IKw==
 
+"@babel/helper-validator-option@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.24.6.tgz#59d8e81c40b7d9109ab7e74457393442177f460a"
+  integrity sha512-Jktc8KkF3zIkePb48QO+IapbXlSapOW9S+ogZZkcO6bABgYAxtZcjZ/O005111YLf+j4M84uEgwYoidDkXbCkQ==
+
 "@babel/helper-wrap-function@^7.18.9":
   version "7.20.5"
   resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.20.5.tgz#75e2d84d499a0ab3b31c33bcfe59d6b8a45f62e3"
@@ -980,15 +1066,6 @@
     "@babel/traverse" "^7.20.5"
     "@babel/types" "^7.20.5"
 
-"@babel/helper-wrap-function@^7.22.20":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.24.5.tgz#335f934c0962e2c1ed1fb9d79e06a56115067c09"
-  integrity sha512-/xxzuNvgRl4/HLNKvnFwdhdgN3cpLxgLROeLDl83Yx0AJ1SGvq1ak0OszTOjDfiB8Vx03eJbeDWh9r+jCCWttw==
-  dependencies:
-    "@babel/helper-function-name" "^7.23.0"
-    "@babel/template" "^7.24.0"
-    "@babel/types" "^7.24.5"
-
 "@babel/helper-wrap-function@^7.22.9":
   version "7.22.9"
   resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.22.9.tgz#189937248c45b0182c1dcf32f3444ca153944cb9"
@@ -998,6 +1075,15 @@
     "@babel/template" "^7.22.5"
     "@babel/types" "^7.22.5"
 
+"@babel/helper-wrap-function@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.24.6.tgz#c27af1006e310683fdc76b668a0a1f6003e36217"
+  integrity sha512-f1JLrlw/jbiNfxvdrfBgio/gRBk3yTAEJWirpAkiJG2Hb22E7cEYKHWo0dFPTv/niPovzIdPdEDetrv6tC6gPQ==
+  dependencies:
+    "@babel/helper-function-name" "^7.24.6"
+    "@babel/template" "^7.24.6"
+    "@babel/types" "^7.24.6"
+
 "@babel/helpers@^7.21.5":
   version "7.21.5"
   resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.21.5.tgz#5bac66e084d7a4d2d9696bdf0175a93f7fb63c08"
@@ -1025,14 +1111,13 @@
     "@babel/traverse" "^7.24.1"
     "@babel/types" "^7.24.0"
 
-"@babel/helpers@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.24.5.tgz#fedeb87eeafa62b621160402181ad8585a22a40a"
-  integrity sha512-CiQmBMMpMQHwM5m01YnrM6imUG1ebgYJ+fAIW4FZe6m4qHTPaRHti+R8cggAwkdz4oXhtO4/K9JWlh+8hIfR2Q==
+"@babel/helpers@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.24.6.tgz#cd124245299e494bd4e00edda0e4ea3545c2c176"
+  integrity sha512-V2PI+NqnyFu1i0GyTd/O/cTpxzQCYioSkUIRmgo7gFEHKKCg5w46+r/A6WeUR1+P3TeQ49dspGPNd/E3n9AnnA==
   dependencies:
-    "@babel/template" "^7.24.0"
-    "@babel/traverse" "^7.24.5"
-    "@babel/types" "^7.24.5"
+    "@babel/template" "^7.24.6"
+    "@babel/types" "^7.24.6"
 
 "@babel/highlight@^7.10.4", "@babel/highlight@^7.18.6":
   version "7.18.6"
@@ -1071,6 +1156,16 @@
     js-tokens "^4.0.0"
     picocolors "^1.0.0"
 
+"@babel/highlight@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.24.6.tgz#6d610c1ebd2c6e061cade0153bf69b0590b7b3df"
+  integrity sha512-2YnuOp4HAk2BsBrJJvYCbItHx0zWscI1C3zgWkz+wDyD9I7GIVrfnLyrR4Y1VR+7p+chAEcrgRQYZAGIKMV7vQ==
+  dependencies:
+    "@babel/helper-validator-identifier" "^7.24.6"
+    chalk "^2.4.2"
+    js-tokens "^4.0.0"
+    picocolors "^1.0.0"
+
 "@babel/parser@^7.1.0", "@babel/parser@^7.1.6", "@babel/parser@^7.13.16", "@babel/parser@^7.14.7", "@babel/parser@^7.21.5":
   version "7.21.5"
   resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.21.5.tgz#821bb520118fd25b982eaf8d37421cf5c64a312b"
@@ -1096,18 +1191,18 @@
   resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.22.7.tgz#df8cf085ce92ddbdbf668a7f186ce848c9036cae"
   integrity sha512-7NF8pOkHP5o2vpmGgNGcfAeCvOYhGLyA3Z4eBQkT1RJlWu47n63bCs93QfJ2hIAFCil7L5P2IWhs1oToVgrL0Q==
 
-"@babel/parser@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.24.5.tgz#4a4d5ab4315579e5398a82dcf636ca80c3392790"
-  integrity sha512-EOv5IK8arwh3LI47dz1b0tKUb/1uhHAnHJOrjgtQMIpu1uXd9mlFrJg9IUgGUgZ41Ch0K8REPTYpO7B76b4vJg==
+"@babel/parser@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.24.6.tgz#5e030f440c3c6c78d195528c3b688b101a365328"
+  integrity sha512-eNZXdfU35nJC2h24RznROuOpO94h6x8sg9ju0tT9biNtLZ2vuP8SduLqqV+/8+cebSLV9SJEAN5Z3zQbJG/M+Q==
 
-"@babel/plugin-bugfix-firefox-class-in-computed-class-key@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.24.5.tgz#4c3685eb9cd790bcad2843900fe0250c91ccf895"
-  integrity sha512-LdXRi1wEMTrHVR4Zc9F8OewC3vdm5h4QB6L71zy6StmYeqGi1b3ttIO8UC+BfZKcH9jdr4aI249rBkm+3+YvHw==
+"@babel/plugin-bugfix-firefox-class-in-computed-class-key@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.24.6.tgz#283a74ef365b1e954cda6b2724c678a978215e88"
+  integrity sha512-bYndrJ6Ph6Ar+GaB5VAc0JPoP80bQCm4qon6JEzXfRl5QZyQ8Ur1K6k7htxWmPA5z+k7JQvaMUrtXlqclWYzKw==
   dependencies:
-    "@babel/helper-environment-visitor" "^7.22.20"
-    "@babel/helper-plugin-utils" "^7.24.5"
+    "@babel/helper-environment-visitor" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@^7.18.6":
   version "7.18.6"
@@ -1123,12 +1218,12 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.24.1.tgz#b645d9ba8c2bc5b7af50f0fe949f9edbeb07c8cf"
-  integrity sha512-y4HqEnkelJIOQGd+3g1bTeKsA5c6qM7eOn7VggGVbBc0y8MLSKHacwcIE2PplNlQSj0PqS9rrXL/nkPVK+kUNg==
+"@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.24.6.tgz#f9f5ae4d6fb72f5950262cb6f0b2482c3bc684ef"
+  integrity sha512-iVuhb6poq5ikqRq2XWU6OQ+R5o9wF+r/or9CeUyovgptz0UlnK4/seOQ1Istu/XybYjAhQv1FRSSfHHufIku5Q==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.18.9", "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.20.7":
   version "7.20.7"
@@ -1148,22 +1243,22 @@
     "@babel/helper-skip-transparent-expression-wrappers" "^7.22.5"
     "@babel/plugin-transform-optional-chaining" "^7.22.5"
 
-"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.24.1.tgz#da8261f2697f0f41b0855b91d3a20a1fbfd271d3"
-  integrity sha512-Hj791Ii4ci8HqnaKHAlLNs+zaLXb0EzSDhiAWp5VNlyvCNymYfacs64pxTxbH1znW/NcArSmwpmG9IKE/TUVVQ==
+"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.24.6.tgz#ab9be6edfffa127bd5ec4317c76c5af0f8fc7e6c"
+  integrity sha512-c8TER5xMDYzzFcGqOEp9l4hvB7dcbhcGjcLVwxWfe4P5DOafdwjsBJZKsmv+o3aXh7NhopvayQIovHrh2zSRUQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.22.5"
-    "@babel/plugin-transform-optional-chaining" "^7.24.1"
+    "@babel/helper-plugin-utils" "^7.24.6"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.24.6"
+    "@babel/plugin-transform-optional-chaining" "^7.24.6"
 
-"@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.24.1.tgz#1181d9685984c91d657b8ddf14f0487a6bab2988"
-  integrity sha512-m9m/fXsXLiHfwdgydIFnpk+7jlVbnvlK5B2EKiPdLUb6WX654ZaaEWJUjk8TftRbZpK0XibovlLWX4KIZhV6jw==
+"@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.24.6.tgz#0faf879249ec622d7f1c42eaebf7d11197401b2c"
+  integrity sha512-z8zEjYmwBUHN/pCF3NuWBhHQjJCrd33qAi8MgANfMrAvn72k2cImT8VjK9LJFu4ysOLJqhfkYYb3MvwANRUNZQ==
   dependencies:
-    "@babel/helper-environment-visitor" "^7.22.20"
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-environment-visitor" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-proposal-async-generator-functions@^7.20.1", "@babel/plugin-proposal-async-generator-functions@^7.20.7":
   version "7.20.7"
@@ -1376,12 +1471,12 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-syntax-import-assertions@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.24.1.tgz#db3aad724153a00eaac115a3fb898de544e34971"
-  integrity sha512-IuwnI5XnuF189t91XbxmXeCDz3qs6iDRO7GJ++wcfgeXNs/8FmIlKcpDSXNVyuLQxlwvskmI3Ct73wUODkJBlQ==
+"@babel/plugin-syntax-import-assertions@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.24.6.tgz#52521c1c1698fc2dd9cf88f7a4dd86d4d041b9e1"
+  integrity sha512-BE6o2BogJKJImTmGpkmOic4V0hlRRxVtzqxiSPa8TIFxyhi4EFjHm08nq1M4STK4RytuLMgnSz0/wfflvGFNOg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-syntax-import-attributes@^7.22.5":
   version "7.22.5"
@@ -1390,12 +1485,12 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-syntax-import-attributes@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.24.1.tgz#c66b966c63b714c4eec508fcf5763b1f2d381093"
-  integrity sha512-zhQTMH0X2nVLnb04tz+s7AMuasX8U0FnpE+nHTOhSOINjWMnopoZTxtIKsd45n4GQ/HIZLyfIpoul8e2m0DnRA==
+"@babel/plugin-syntax-import-attributes@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.24.6.tgz#12aba325534129584672920274fefa4dc2d5f68e"
+  integrity sha512-D+CfsVZousPXIdudSII7RGy52+dYRtbyKAZcvtQKq/NpsivyMVduepzcLqG5pMBugtMdedxdC8Ramdpcne9ZWQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-syntax-import-meta@^7.10.4", "@babel/plugin-syntax-import-meta@^7.8.3":
   version "7.10.4"
@@ -1510,7 +1605,7 @@
     "@babel/helper-create-regexp-features-plugin" "^7.18.6"
     "@babel/helper-plugin-utils" "^7.18.6"
 
-"@babel/plugin-transform-arrow-functions@^7.0.0", "@babel/plugin-transform-arrow-functions@^7.24.1":
+"@babel/plugin-transform-arrow-functions@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.24.1.tgz#2bf263617060c9cc45bcdbf492b8cc805082bf27"
   integrity sha512-ngT/3NkRhsaep9ck9uj2Xhv9+xB1zShY3tM3g6om4xxCELwCDN4g4Aq5dRn48+0hasAql7s2hdBOysCfNpr4fw==
@@ -1538,6 +1633,13 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
+"@babel/plugin-transform-arrow-functions@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.24.6.tgz#93607d1ef5b81c70af174aff3532d57216367492"
+  integrity sha512-jSSSDt4ZidNMggcLx8SaKsbGNEfIl0PHx/4mFEulorE7bpYLbN0d3pDW3eJ7Y5Z3yPhy3L3NaPCYyTUY7TuugQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.24.6"
+
 "@babel/plugin-transform-async-generator-functions@^7.22.7":
   version "7.22.7"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.22.7.tgz#053e76c0a903b72b573cb1ab7d6882174d460a1b"
@@ -1548,14 +1650,14 @@
     "@babel/helper-remap-async-to-generator" "^7.22.5"
     "@babel/plugin-syntax-async-generators" "^7.8.4"
 
-"@babel/plugin-transform-async-generator-functions@^7.24.3":
-  version "7.24.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.24.3.tgz#8fa7ae481b100768cc9842c8617808c5352b8b89"
-  integrity sha512-Qe26CMYVjpQxJ8zxM1340JFNjZaF+ISWpr1Kt/jGo+ZTUzKkfw/pphEWbRCb+lmSM6k/TOgfYLvmbHkUQ0asIg==
+"@babel/plugin-transform-async-generator-functions@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.24.6.tgz#fa4a9e5c3a7f60f697ba36587b6c41b04f507d84"
+  integrity sha512-VEP2o4iR2DqQU6KPgizTW2mnMx6BG5b5O9iQdrW9HesLkv8GIA8x2daXBQxw1MrsIkFQGA/iJ204CKoQ8UcnAA==
   dependencies:
-    "@babel/helper-environment-visitor" "^7.22.20"
-    "@babel/helper-plugin-utils" "^7.24.0"
-    "@babel/helper-remap-async-to-generator" "^7.22.20"
+    "@babel/helper-environment-visitor" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
+    "@babel/helper-remap-async-to-generator" "^7.24.6"
     "@babel/plugin-syntax-async-generators" "^7.8.4"
 
 "@babel/plugin-transform-async-to-generator@^7.18.6", "@babel/plugin-transform-async-to-generator@^7.20.7":
@@ -1576,16 +1678,16 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/helper-remap-async-to-generator" "^7.22.5"
 
-"@babel/plugin-transform-async-to-generator@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.24.1.tgz#0e220703b89f2216800ce7b1c53cb0cf521c37f4"
-  integrity sha512-AawPptitRXp1y0n4ilKcGbRYWfbbzFWz2NqNu7dacYDtFtz0CMjG64b3LQsb3KIgnf4/obcUL78hfaOS7iCUfw==
+"@babel/plugin-transform-async-to-generator@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.24.6.tgz#eb11434b11d73d8c0cf9f71a6f4f1e6ba441df35"
+  integrity sha512-NTBA2SioI3OsHeIn6sQmhvXleSl9T70YY/hostQLveWs0ic+qvbA3fa0kwAwQ0OA/XGaAerNZRQGJyRfhbJK4g==
   dependencies:
-    "@babel/helper-module-imports" "^7.24.1"
-    "@babel/helper-plugin-utils" "^7.24.0"
-    "@babel/helper-remap-async-to-generator" "^7.22.20"
+    "@babel/helper-module-imports" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
+    "@babel/helper-remap-async-to-generator" "^7.24.6"
 
-"@babel/plugin-transform-block-scoped-functions@^7.0.0", "@babel/plugin-transform-block-scoped-functions@^7.24.1":
+"@babel/plugin-transform-block-scoped-functions@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.24.1.tgz#1c94799e20fcd5c4d4589523bbc57b7692979380"
   integrity sha512-TWWC18OShZutrv9C6mye1xwtam+uNi2bnTOCBUd5sZxyHOiWbU6ztSROofIMrK84uweEZC219POICK/sTYwfgg==
@@ -1606,6 +1708,13 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
+"@babel/plugin-transform-block-scoped-functions@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.24.6.tgz#975555b5bfa9870b1218da536d1528735f1f8c56"
+  integrity sha512-XNW7jolYHW9CwORrZgA/97tL/k05qe/HL0z/qqJq1mdWhwwCM6D4BJBV7wAz9HgFziN5dTOG31znkVIzwxv+vw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.24.6"
+
 "@babel/plugin-transform-block-scoping@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.24.1.tgz#27af183d7f6dad890531256c7a45019df768ac1f"
@@ -1627,12 +1736,12 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-block-scoping@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.24.5.tgz#89574191397f85661d6f748d4b89ee4d9ee69a2a"
-  integrity sha512-sMfBc3OxghjC95BkYrYocHL3NaOplrcaunblzwXhGmlPwpmfsxr4vK+mBBt49r+S240vahmv+kUxkeKgs+haCw==
+"@babel/plugin-transform-block-scoping@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.24.6.tgz#a03ec8a4591c2b43cf7798bc633e698293fda179"
+  integrity sha512-S/t1Xh4ehW7sGA7c1j/hiOBLnEYCp/c2sEG4ZkL8kI1xX9tW2pqJTCHKtdhe/jHKt8nG0pFCrDHUXd4DvjHS9w==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.5"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-class-properties@^7.22.5":
   version "7.22.5"
@@ -1642,13 +1751,13 @@
     "@babel/helper-create-class-features-plugin" "^7.22.5"
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-class-properties@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.24.1.tgz#bcbf1aef6ba6085cfddec9fc8d58871cf011fc29"
-  integrity sha512-OMLCXi0NqvJfORTaPQBwqLXHhb93wkBKZ4aNwMl6WtehO7ar+cmp+89iPEQPqxAnxsOKTaMcs3POz3rKayJ72g==
+"@babel/plugin-transform-class-properties@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.24.6.tgz#d9f394e97e88ef905d5a1e5e7a16238621b7982e"
+  integrity sha512-j6dZ0Z2Z2slWLR3kt9aOmSIrBvnntWjMDN/TVcMPxhXMLmJVqX605CBRlcGI4b32GMbfifTEsdEjGjiE+j/c3A==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.24.1"
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-create-class-features-plugin" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-class-static-block@^7.22.5":
   version "7.22.5"
@@ -1659,13 +1768,13 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/plugin-syntax-class-static-block" "^7.14.5"
 
-"@babel/plugin-transform-class-static-block@^7.24.4":
-  version "7.24.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.24.4.tgz#1a4653c0cf8ac46441ec406dece6e9bc590356a4"
-  integrity sha512-B8q7Pz870Hz/q9UgP8InNpY01CSLDSCyqX7zcRuv3FcPl87A2G17lASroHWaCtbdIcbYzOZ7kWmXFKbijMSmFg==
+"@babel/plugin-transform-class-static-block@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.24.6.tgz#f43f29286f6f0dca33d18fd5033b817d6c3fa816"
+  integrity sha512-1QSRfoPI9RoLRa8Mnakc6v3e0gJxiZQTYrMfLn+mD0sz5+ndSzwymp2hDcYJTyT0MOn0yuWzj8phlIvO72gTHA==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.24.4"
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-create-class-features-plugin" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
     "@babel/plugin-syntax-class-static-block" "^7.14.5"
 
 "@babel/plugin-transform-classes@^7.0.0":
@@ -1712,21 +1821,21 @@
     "@babel/helper-split-export-declaration" "^7.22.6"
     globals "^11.1.0"
 
-"@babel/plugin-transform-classes@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.24.5.tgz#05e04a09df49a46348299a0e24bfd7e901129339"
-  integrity sha512-gWkLP25DFj2dwe9Ck8uwMOpko4YsqyfZJrOmqqcegeDYEbp7rmn4U6UQZNj08UF6MaX39XenSpKRCvpDRBtZ7Q==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.22.5"
-    "@babel/helper-compilation-targets" "^7.23.6"
-    "@babel/helper-environment-visitor" "^7.22.20"
-    "@babel/helper-function-name" "^7.23.0"
-    "@babel/helper-plugin-utils" "^7.24.5"
-    "@babel/helper-replace-supers" "^7.24.1"
-    "@babel/helper-split-export-declaration" "^7.24.5"
+"@babel/plugin-transform-classes@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.24.6.tgz#0cc198c02720d4eeb091004843477659c6b37977"
+  integrity sha512-+fN+NO2gh8JtRmDSOB6gaCVo36ha8kfCW1nMq2Gc0DABln0VcHN4PrALDvF5/diLzIRKptC7z/d7Lp64zk92Fg==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.24.6"
+    "@babel/helper-compilation-targets" "^7.24.6"
+    "@babel/helper-environment-visitor" "^7.24.6"
+    "@babel/helper-function-name" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
+    "@babel/helper-replace-supers" "^7.24.6"
+    "@babel/helper-split-export-declaration" "^7.24.6"
     globals "^11.1.0"
 
-"@babel/plugin-transform-computed-properties@^7.0.0", "@babel/plugin-transform-computed-properties@^7.24.1":
+"@babel/plugin-transform-computed-properties@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.24.1.tgz#bc7e787f8e021eccfb677af5f13c29a9934ed8a7"
   integrity sha512-5pJGVIUfJpOS+pAqBQd+QMaTD2vCL/HcePooON6pDpHgRp4gNRmzyHTPIkXntwKsq3ayUFVfJaIKPw2pOkOcTw==
@@ -1758,6 +1867,14 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/template" "^7.22.5"
 
+"@babel/plugin-transform-computed-properties@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.24.6.tgz#7a1765c01cdfe59c320d2d0f37a4dc4aecd14df1"
+  integrity sha512-cRzPobcfRP0ZtuIEkA8QzghoUpSB3X3qSH5W2+FzG+VjWbJXExtx0nbRqwumdBN1x/ot2SlTNQLfBCnPdzp6kg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.24.6"
+    "@babel/template" "^7.24.6"
+
 "@babel/plugin-transform-destructuring@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.24.1.tgz#b1e8243af4a0206841973786292b8c8dd8447345"
@@ -1779,12 +1896,12 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-destructuring@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.24.5.tgz#80843ee6a520f7362686d1a97a7b53544ede453c"
-  integrity sha512-SZuuLyfxvsm+Ah57I/i1HVjveBENYK9ue8MJ7qkc7ndoNjqquJiElzA7f5yaAXjyW2hKojosOTAQQRX50bPSVg==
+"@babel/plugin-transform-destructuring@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.24.6.tgz#bdd1a6c90ffb2bfd13b6007b13316eeafc97cb53"
+  integrity sha512-YLW6AE5LQpk5npNXL7i/O+U9CE4XsBCuRPgyjl1EICZYKmcitV+ayuuUGMJm2lC1WWjXYszeTnIxF/dq/GhIZQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.5"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-dotall-regex@^7.18.6", "@babel/plugin-transform-dotall-regex@^7.4.4":
   version "7.18.6"
@@ -1802,13 +1919,13 @@
     "@babel/helper-create-regexp-features-plugin" "^7.22.5"
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-dotall-regex@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.24.1.tgz#d56913d2f12795cc9930801b84c6f8c47513ac13"
-  integrity sha512-p7uUxgSoZwZ2lPNMzUkqCts3xlp8n+o05ikjy7gbtFJSt9gdU88jAmtfmOxHM14noQXBxfgzf2yRWECiNVhTCw==
+"@babel/plugin-transform-dotall-regex@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.24.6.tgz#5a6b3148ec5f4f274ff48cebea90565087cad126"
+  integrity sha512-rCXPnSEKvkm/EjzOtLoGvKseK+dS4kZwx1HexO3BtRtgL0fQ34awHn34aeSHuXtZY2F8a1X8xqBBPRtOxDVmcA==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.22.15"
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-create-regexp-features-plugin" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-duplicate-keys@^7.18.9":
   version "7.18.9"
@@ -1824,12 +1941,12 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-duplicate-keys@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.24.1.tgz#5347a797fe82b8d09749d10e9f5b83665adbca88"
-  integrity sha512-msyzuUnvsjsaSaocV6L7ErfNsa5nDWL1XKNnDePLgmz+WdU4w/J8+AxBMrWfi9m4IxfL5sZQKUPQKDQeeAT6lA==
+"@babel/plugin-transform-duplicate-keys@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.24.6.tgz#2716301227cf7cd4fdadcbe4353ce191f8b3dc8a"
+  integrity sha512-/8Odwp/aVkZwPFJMllSbawhDAO3UJi65foB00HYnK/uXvvCPm0TAXSByjz1mpRmp0q6oX2SIxpkUOpPFHk7FLA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-dynamic-import@^7.22.5":
   version "7.22.5"
@@ -1839,12 +1956,12 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/plugin-syntax-dynamic-import" "^7.8.3"
 
-"@babel/plugin-transform-dynamic-import@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.24.1.tgz#2a5a49959201970dd09a5fca856cb651e44439dd"
-  integrity sha512-av2gdSTyXcJVdI+8aFZsCAtR29xJt0S5tas+Ef8NvBNmD1a+N/3ecMLeMBgfcK+xzsjdLDT6oHt+DFPyeqUbDA==
+"@babel/plugin-transform-dynamic-import@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.24.6.tgz#b477177761d56b15a4ba42a83be31cf72d757acf"
+  integrity sha512-vpq8SSLRTBLOHUZHSnBqVo0AKX3PBaoPs2vVzYVWslXDTDIpwAcCDtfhUcHSQQoYoUvcFPTdC8TZYXu9ZnLT/w==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
     "@babel/plugin-syntax-dynamic-import" "^7.8.3"
 
 "@babel/plugin-transform-exponentiation-operator@^7.18.6":
@@ -1863,13 +1980,13 @@
     "@babel/helper-builder-binary-assignment-operator-visitor" "^7.22.5"
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-exponentiation-operator@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.24.1.tgz#6650ebeb5bd5c012d5f5f90a26613a08162e8ba4"
-  integrity sha512-U1yX13dVBSwS23DEAqU+Z/PkwE9/m7QQy8Y9/+Tdb8UWYaGNDYwTLi19wqIAiROr8sXVum9A/rtiH5H0boUcTw==
+"@babel/plugin-transform-exponentiation-operator@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.24.6.tgz#011e9e1a429f91b024af572530873ca571f9ef06"
+  integrity sha512-EemYpHtmz0lHE7hxxxYEuTYOOBZ43WkDgZ4arQ4r+VX9QHuNZC+WH3wUWmRNvR8ECpTRne29aZV6XO22qpOtdA==
   dependencies:
-    "@babel/helper-builder-binary-assignment-operator-visitor" "^7.22.15"
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-builder-binary-assignment-operator-visitor" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-export-namespace-from@^7.22.5":
   version "7.22.5"
@@ -1879,12 +1996,12 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
 
-"@babel/plugin-transform-export-namespace-from@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.24.1.tgz#f033541fc036e3efb2dcb58eedafd4f6b8078acd"
-  integrity sha512-Ft38m/KFOyzKw2UaJFkWG9QnHPG/Q/2SkOrRk4pNBPg5IPZ+dOxcmkK5IyuBcxiNPyyYowPGUReyBvrvZs7IlQ==
+"@babel/plugin-transform-export-namespace-from@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.24.6.tgz#b64ded74d9afb3db5d47d93996c4df69f15ac97c"
+  integrity sha512-inXaTM1SVrIxCkIJ5gqWiozHfFMStuGbGJAxZFBoHcRRdDP0ySLb3jH6JOwmfiinPwyMZqMBX+7NBDCO4z0NSA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
     "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
 
 "@babel/plugin-transform-flow-strip-types@^7.0.0":
@@ -1911,7 +2028,7 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/plugin-syntax-flow" "^7.22.5"
 
-"@babel/plugin-transform-for-of@^7.0.0", "@babel/plugin-transform-for-of@^7.24.1":
+"@babel/plugin-transform-for-of@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.24.1.tgz#67448446b67ab6c091360ce3717e7d3a59e202fd"
   integrity sha512-OxBdcnF04bpdQdR3i4giHZNZQn7cm8RQKcSwA17wAAqEELo1ZOwp5FFgeptWUQXFyT9kwHo10aqqauYkRZPCAg==
@@ -1940,7 +2057,15 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-function-name@^7.0.0", "@babel/plugin-transform-function-name@^7.24.1":
+"@babel/plugin-transform-for-of@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.24.6.tgz#7f31780bd0c582b546372c0c0da9d9d56731e0a2"
+  integrity sha512-n3Sf72TnqK4nw/jziSqEl1qaWPbCRw2CziHH+jdRYvw4J6yeCzsj4jdw8hIntOEeDGTmHVe2w4MVL44PN0GMzg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.24.6"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.24.6"
+
+"@babel/plugin-transform-function-name@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.24.1.tgz#8cba6f7730626cc4dfe4ca2fa516215a0592b361"
   integrity sha512-BXmDZpPlh7jwicKArQASrj8n22/w6iymRnvHYYd2zO30DbE277JO20/7yXJT3QxDPtiQiOxQBbZH4TpivNXIxA==
@@ -1967,6 +2092,15 @@
     "@babel/helper-function-name" "^7.22.5"
     "@babel/helper-plugin-utils" "^7.22.5"
 
+"@babel/plugin-transform-function-name@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.24.6.tgz#60d1de3f6fd816a3e3bf9538578a64527e1b9c97"
+  integrity sha512-sOajCu6V0P1KPljWHKiDq6ymgqB+vfo3isUS4McqW1DZtvSVU2v/wuMhmRmkg3sFoq6GMaUUf8W4WtoSLkOV/Q==
+  dependencies:
+    "@babel/helper-compilation-targets" "^7.24.6"
+    "@babel/helper-function-name" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
+
 "@babel/plugin-transform-json-strings@^7.22.5":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.22.5.tgz#14b64352fdf7e1f737eed68de1a1468bd2a77ec0"
@@ -1975,15 +2109,15 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/plugin-syntax-json-strings" "^7.8.3"
 
-"@babel/plugin-transform-json-strings@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.24.1.tgz#08e6369b62ab3e8a7b61089151b161180c8299f7"
-  integrity sha512-U7RMFmRvoasscrIFy5xA4gIp8iWnWubnKkKuUGJjsuOH7GfbMkB+XZzeslx2kLdEGdOJDamEmCqOks6e8nv8DQ==
+"@babel/plugin-transform-json-strings@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.24.6.tgz#a84639180ea1f9001bb5e6dc01921235ab05ad8b"
+  integrity sha512-Uvgd9p2gUnzYJxVdBLcU0KurF8aVhkmVyMKW4MIY1/BByvs3EBpv45q01o7pRTVmTvtQq5zDlytP3dcUgm7v9w==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
     "@babel/plugin-syntax-json-strings" "^7.8.3"
 
-"@babel/plugin-transform-literals@^7.0.0", "@babel/plugin-transform-literals@^7.24.1":
+"@babel/plugin-transform-literals@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.24.1.tgz#0a1982297af83e6b3c94972686067df588c5c096"
   integrity sha512-zn9pwz8U7nCqOYIiBaOxoQOtYmMODXTJnkxG4AtX8fPmnCRYWBOHD0qcpwS9e2VDSp1zNJYpdnFMIKb8jmwu6g==
@@ -2004,6 +2138,13 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
+"@babel/plugin-transform-literals@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.24.6.tgz#7f44f2871d7a4456030b0540858046f0b7bc6b18"
+  integrity sha512-f2wHfR2HF6yMj+y+/y07+SLqnOSwRp8KYLpQKOzS58XLVlULhXbiYcygfXQxJlMbhII9+yXDwOUFLf60/TL5tw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.24.6"
+
 "@babel/plugin-transform-logical-assignment-operators@^7.22.5":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.22.5.tgz#66ae5f068fd5a9a5dc570df16f56c2a8462a9d6c"
@@ -2012,15 +2153,15 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4"
 
-"@babel/plugin-transform-logical-assignment-operators@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.24.1.tgz#719d8aded1aa94b8fb34e3a785ae8518e24cfa40"
-  integrity sha512-OhN6J4Bpz+hIBqItTeWJujDOfNP+unqv/NJgyhlpSqgBTPm37KkMmZV6SYcOj+pnDbdcl1qRGV/ZiIjX9Iy34w==
+"@babel/plugin-transform-logical-assignment-operators@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.24.6.tgz#9cc7baa5629866566562c159dc1eae7569810f33"
+  integrity sha512-EKaWvnezBCMkRIHxMJSIIylzhqK09YpiJtDbr2wsXTwnO0TxyjMUkaw4RlFIZMIS0iDj0KyIg7H7XCguHu/YDA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
     "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4"
 
-"@babel/plugin-transform-member-expression-literals@^7.0.0", "@babel/plugin-transform-member-expression-literals@^7.24.1":
+"@babel/plugin-transform-member-expression-literals@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.24.1.tgz#896d23601c92f437af8b01371ad34beb75df4489"
   integrity sha512-4ojai0KysTWXzHseJKa1XPNXKRbuUrhkOPY4rEGeR+7ChlJVKxFa3H3Bz+7tWaGKgJAXUWKOGmltN+u9B3+CVg==
@@ -2041,6 +2182,13 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
+"@babel/plugin-transform-member-expression-literals@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.24.6.tgz#5d3681ca201ac6909419cc51ac082a6ba4c5c756"
+  integrity sha512-9g8iV146szUo5GWgXpRbq/GALTnY+WnNuRTuRHWWFfWGbP9ukRL0aO/jpu9dmOPikclkxnNsjY8/gsWl6bmZJQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.24.6"
+
 "@babel/plugin-transform-modules-amd@^7.19.6", "@babel/plugin-transform-modules-amd@^7.20.11":
   version "7.20.11"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.20.11.tgz#3daccca8e4cc309f03c3a0c4b41dc4b26f55214a"
@@ -2057,15 +2205,15 @@
     "@babel/helper-module-transforms" "^7.22.5"
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-modules-amd@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.24.1.tgz#b6d829ed15258536977e9c7cc6437814871ffa39"
-  integrity sha512-lAxNHi4HVtjnHd5Rxg3D5t99Xm6H7b04hUS7EHIXcUl2EV4yl1gWdqZrNzXnSrHveL9qMdbODlLF55mvgjAfaQ==
+"@babel/plugin-transform-modules-amd@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.24.6.tgz#09aeac7acb7913496aaaafdc64f40683e0db7e41"
+  integrity sha512-eAGogjZgcwqAxhyFgqghvoHRr+EYRQPFjUXrTYKBRb5qPnAVxOOglaxc4/byHqjvq/bqO2F3/CGwTHsgKJYHhQ==
   dependencies:
-    "@babel/helper-module-transforms" "^7.23.3"
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-module-transforms" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
-"@babel/plugin-transform-modules-commonjs@^7.0.0", "@babel/plugin-transform-modules-commonjs@^7.24.1":
+"@babel/plugin-transform-modules-commonjs@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.24.1.tgz#e71ba1d0d69e049a22bf90b3867e263823d3f1b9"
   integrity sha512-szog8fFTUxBfw0b98gEWPaEqF42ZUD/T3bkynW/wtgx2p/XCP55WEsb+VosKceRSd6njipdZvNogqdtI4Q0chw==
@@ -2101,6 +2249,15 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/helper-simple-access" "^7.22.5"
 
+"@babel/plugin-transform-modules-commonjs@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.24.6.tgz#1b8269902f25bd91ca6427230d4735ddd1e1283e"
+  integrity sha512-JEV8l3MHdmmdb7S7Cmx6rbNEjRCgTQMZxllveHO0mx6uiclB0NflCawlQQ6+o5ZrwjUBYPzHm2XoK4wqGVUFuw==
+  dependencies:
+    "@babel/helper-module-transforms" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
+    "@babel/helper-simple-access" "^7.24.6"
+
 "@babel/plugin-transform-modules-systemjs@^7.19.6", "@babel/plugin-transform-modules-systemjs@^7.20.11":
   version "7.20.11"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.20.11.tgz#467ec6bba6b6a50634eea61c9c232654d8a4696e"
@@ -2121,15 +2278,15 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/helper-validator-identifier" "^7.22.5"
 
-"@babel/plugin-transform-modules-systemjs@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.24.1.tgz#2b9625a3d4e445babac9788daec39094e6b11e3e"
-  integrity sha512-mqQ3Zh9vFO1Tpmlt8QPnbwGHzNz3lpNEMxQb1kAemn/erstyqw1r9KeOlOfo3y6xAnFEcOv2tSyrXfmMk+/YZA==
+"@babel/plugin-transform-modules-systemjs@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.24.6.tgz#c54eb53fe16f9b82d320abd76762d0320e3f9393"
+  integrity sha512-xg1Z0J5JVYxtpX954XqaaAT6NpAY6LtZXvYFCJmGFJWwtlz2EmJoR8LycFRGNE8dBKizGWkGQZGegtkV8y8s+w==
   dependencies:
-    "@babel/helper-hoist-variables" "^7.22.5"
-    "@babel/helper-module-transforms" "^7.23.3"
-    "@babel/helper-plugin-utils" "^7.24.0"
-    "@babel/helper-validator-identifier" "^7.22.20"
+    "@babel/helper-hoist-variables" "^7.24.6"
+    "@babel/helper-module-transforms" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
+    "@babel/helper-validator-identifier" "^7.24.6"
 
 "@babel/plugin-transform-modules-umd@^7.18.6":
   version "7.18.6"
@@ -2147,13 +2304,13 @@
     "@babel/helper-module-transforms" "^7.22.5"
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-modules-umd@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.24.1.tgz#69220c66653a19cf2c0872b9c762b9a48b8bebef"
-  integrity sha512-tuA3lpPj+5ITfcCluy6nWonSL7RvaG0AOTeAuvXqEKS34lnLzXpDb0dcP6K8jD0zWZFNDVly90AGFJPnm4fOYg==
+"@babel/plugin-transform-modules-umd@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.24.6.tgz#c4ef8b6d4da230b8dc87e81cd66986728952f89b"
+  integrity sha512-esRCC/KsSEUvrSjv5rFYnjZI6qv4R1e/iHQrqwbZIoRJqk7xCvEUiN7L1XrmW5QSmQe3n1XD88wbgDTWLbVSyg==
   dependencies:
-    "@babel/helper-module-transforms" "^7.23.3"
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-module-transforms" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-named-capturing-groups-regex@^7.19.1", "@babel/plugin-transform-named-capturing-groups-regex@^7.20.5":
   version "7.20.5"
@@ -2171,6 +2328,14 @@
     "@babel/helper-create-regexp-features-plugin" "^7.22.5"
     "@babel/helper-plugin-utils" "^7.22.5"
 
+"@babel/plugin-transform-named-capturing-groups-regex@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.24.6.tgz#352ee2861ab8705320029f80238cf26a92ba65d5"
+  integrity sha512-6DneiCiu91wm3YiNIGDWZsl6GfTTbspuj/toTEqLh9d4cx50UIzSdg+T96p8DuT7aJOBRhFyaE9ZvTHkXrXr6Q==
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
+
 "@babel/plugin-transform-new-target@^7.18.6":
   version "7.18.6"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.18.6.tgz#d128f376ae200477f37c4ddfcc722a8a1b3246a8"
@@ -2185,12 +2350,12 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-new-target@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.24.1.tgz#29c59988fa3d0157de1c871a28cd83096363cc34"
-  integrity sha512-/rurytBM34hYy0HKZQyA0nHbQgQNFm4Q/BOc9Hflxi2X3twRof7NaE5W46j4kQitm7SvACVRXsa6N/tSZxvPug==
+"@babel/plugin-transform-new-target@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.24.6.tgz#fc024294714705113720d5e3dc0f9ad7abdbc289"
+  integrity sha512-f8liz9JG2Va8A4J5ZBuaSdwfPqN6axfWRK+y66fjKYbwf9VBLuq4WxtinhJhvp1w6lamKUwLG0slK2RxqFgvHA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-nullish-coalescing-operator@^7.22.5":
   version "7.22.5"
@@ -2200,12 +2365,12 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3"
 
-"@babel/plugin-transform-nullish-coalescing-operator@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.24.1.tgz#0cd494bb97cb07d428bd651632cb9d4140513988"
-  integrity sha512-iQ+caew8wRrhCikO5DrUYx0mrmdhkaELgFa+7baMcVuhxIkN7oxt06CZ51D65ugIb1UWRQ8oQe+HXAVM6qHFjw==
+"@babel/plugin-transform-nullish-coalescing-operator@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.24.6.tgz#12b83b3cdfd1cd2066350e36e4fb912ab194545e"
+  integrity sha512-+QlAiZBMsBK5NqrBWFXCYeXyiU1y7BQ/OYaiPAcQJMomn5Tyg+r5WuVtyEuvTbpV7L25ZSLfE+2E9ywj4FD48A==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
     "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3"
 
 "@babel/plugin-transform-numeric-separator@^7.22.5":
@@ -2216,12 +2381,12 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/plugin-syntax-numeric-separator" "^7.10.4"
 
-"@babel/plugin-transform-numeric-separator@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.24.1.tgz#5bc019ce5b3435c1cadf37215e55e433d674d4e8"
-  integrity sha512-7GAsGlK4cNL2OExJH1DzmDeKnRv/LXq0eLUSvudrehVA5Rgg4bIrqEUW29FbKMBRT0ztSqisv7kjP+XIC4ZMNw==
+"@babel/plugin-transform-numeric-separator@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.24.6.tgz#d9115669cc85aa91fbfb15f88f2226332cf4946a"
+  integrity sha512-6voawq8T25Jvvnc4/rXcWZQKKxUNZcKMS8ZNrjxQqoRFernJJKjE3s18Qo6VFaatG5aiX5JV1oPD7DbJhn0a4Q==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
     "@babel/plugin-syntax-numeric-separator" "^7.10.4"
 
 "@babel/plugin-transform-object-rest-spread@^7.22.5":
@@ -2235,17 +2400,17 @@
     "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
     "@babel/plugin-transform-parameters" "^7.22.5"
 
-"@babel/plugin-transform-object-rest-spread@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.24.5.tgz#f91bbcb092ff957c54b4091c86bda8372f0b10ef"
-  integrity sha512-7EauQHszLGM3ay7a161tTQH7fj+3vVM/gThlz5HpFtnygTxjrlvoeq7MPVA1Vy9Q555OB8SnAOsMkLShNkkrHA==
+"@babel/plugin-transform-object-rest-spread@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.24.6.tgz#68d763f69955f9e599c405c6c876f5be46b47d8a"
+  integrity sha512-OKmi5wiMoRW5Smttne7BwHM8s/fb5JFs+bVGNSeHWzwZkWXWValR1M30jyXo1s/RaqgwwhEC62u4rFH/FBcBPg==
   dependencies:
-    "@babel/helper-compilation-targets" "^7.23.6"
-    "@babel/helper-plugin-utils" "^7.24.5"
+    "@babel/helper-compilation-targets" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
     "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
-    "@babel/plugin-transform-parameters" "^7.24.5"
+    "@babel/plugin-transform-parameters" "^7.24.6"
 
-"@babel/plugin-transform-object-super@^7.0.0", "@babel/plugin-transform-object-super@^7.24.1":
+"@babel/plugin-transform-object-super@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.24.1.tgz#e71d6ab13483cca89ed95a474f542bbfc20a0520"
   integrity sha512-oKJqR3TeI5hSLRxudMjFQ9re9fBVUU0GICqM3J1mi8MqlhVr6hC/ZN4ttAyMuQR6EZZIY6h/exe5swqGNNIkWQ==
@@ -2269,6 +2434,14 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/helper-replace-supers" "^7.22.5"
 
+"@babel/plugin-transform-object-super@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.24.6.tgz#9cbe6f995bed343a7ab8daf0416dac057a9c3e27"
+  integrity sha512-N/C76ihFKlZgKfdkEYKtaRUtXZAgK7sOY4h2qrbVbVTXPrKGIi8aww5WGe/+Wmg8onn8sr2ut6FXlsbu/j6JHg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.24.6"
+    "@babel/helper-replace-supers" "^7.24.6"
+
 "@babel/plugin-transform-optional-catch-binding@^7.22.5":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.22.5.tgz#842080be3076703be0eaf32ead6ac8174edee333"
@@ -2277,12 +2450,12 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/plugin-syntax-optional-catch-binding" "^7.8.3"
 
-"@babel/plugin-transform-optional-catch-binding@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.24.1.tgz#92a3d0efe847ba722f1a4508669b23134669e2da"
-  integrity sha512-oBTH7oURV4Y+3EUrf6cWn1OHio3qG/PVwO5J03iSJmBg6m2EhKjkAu/xuaXaYwWW9miYtvbWv4LNf0AmR43LUA==
+"@babel/plugin-transform-optional-catch-binding@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.24.6.tgz#c81e90a971aad898e56f2b75a358e6c4855aeba3"
+  integrity sha512-L5pZ+b3O1mSzJ71HmxSCmTVd03VOT2GXOigug6vDYJzE5awLI7P1g0wFcdmGuwSDSrQ0L2rDOe/hHws8J1rv3w==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
     "@babel/plugin-syntax-optional-catch-binding" "^7.8.3"
 
 "@babel/plugin-transform-optional-chaining@^7.22.5", "@babel/plugin-transform-optional-chaining@^7.22.6":
@@ -2294,13 +2467,13 @@
     "@babel/helper-skip-transparent-expression-wrappers" "^7.22.5"
     "@babel/plugin-syntax-optional-chaining" "^7.8.3"
 
-"@babel/plugin-transform-optional-chaining@^7.24.1", "@babel/plugin-transform-optional-chaining@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.24.5.tgz#a6334bebd7f9dd3df37447880d0bd64b778e600f"
-  integrity sha512-xWCkmwKT+ihmA6l7SSTpk8e4qQl/274iNbSKRRS8mpqFR32ksy36+a+LWY8OXCCEefF8WFlnOHVsaDI2231wBg==
+"@babel/plugin-transform-optional-chaining@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.24.6.tgz#3d636b3ed8b5a506f93e4d4675fc95754d7594f5"
+  integrity sha512-cHbqF6l1QP11OkYTYQ+hhVx1E017O5ZcSPXk9oODpqhcAD1htsWG2NpHrrhthEO2qZomLK0FXS+u7NfrkF5aOQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.5"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.22.5"
+    "@babel/helper-plugin-utils" "^7.24.6"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.24.6"
     "@babel/plugin-syntax-optional-chaining" "^7.8.3"
 
 "@babel/plugin-transform-parameters@^7.0.0":
@@ -2324,12 +2497,12 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-parameters@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.24.5.tgz#5c3b23f3a6b8fed090f9b98f2926896d3153cc62"
-  integrity sha512-9Co00MqZ2aoky+4j2jhofErthm6QVLKbpQrvz20c3CH9KQCLHyNB+t2ya4/UrRpQGR+Wrwjg9foopoeSdnHOkA==
+"@babel/plugin-transform-parameters@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.24.6.tgz#7aee86dfedd2fc0136fecbe6f7649fc02d86ab22"
+  integrity sha512-ST7guE8vLV+vI70wmAxuZpIKzVjvFX9Qs8bl5w6tN/6gOypPWUmMQL2p7LJz5E63vEGrDhAiYetniJFyBH1RkA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.5"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-private-methods@^7.22.5":
   version "7.22.5"
@@ -2339,13 +2512,13 @@
     "@babel/helper-create-class-features-plugin" "^7.22.5"
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-private-methods@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.24.1.tgz#a0faa1ae87eff077e1e47a5ec81c3aef383dc15a"
-  integrity sha512-tGvisebwBO5em4PaYNqt4fkw56K2VALsAbAakY0FjTYqJp7gfdrgr7YX76Or8/cpik0W6+tj3rZ0uHU9Oil4tw==
+"@babel/plugin-transform-private-methods@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.24.6.tgz#258e1f859a52ff7b30ad556598224c192defcda7"
+  integrity sha512-T9LtDI0BgwXOzyXrvgLTT8DFjCC/XgWLjflczTLXyvxbnSR/gpv0hbmzlHE/kmh9nOvlygbamLKRo6Op4yB6aw==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.24.1"
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-create-class-features-plugin" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-private-property-in-object@^7.22.5":
   version "7.22.5"
@@ -2357,17 +2530,17 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/plugin-syntax-private-property-in-object" "^7.14.5"
 
-"@babel/plugin-transform-private-property-in-object@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.24.5.tgz#f5d1fcad36e30c960134cb479f1ca98a5b06eda5"
-  integrity sha512-JM4MHZqnWR04jPMujQDTBVRnqxpLLpx2tkn7iPn+Hmsc0Gnb79yvRWOkvqFOx3Z7P7VxiRIR22c4eGSNj87OBQ==
+"@babel/plugin-transform-private-property-in-object@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.24.6.tgz#59ff09a099f62213112cf348e96b6b11957d1f28"
+  integrity sha512-Qu/ypFxCY5NkAnEhCF86Mvg3NSabKsh/TPpBVswEdkGl7+FbsYHy1ziRqJpwGH4thBdQHh8zx+z7vMYmcJ7iaQ==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.22.5"
-    "@babel/helper-create-class-features-plugin" "^7.24.5"
-    "@babel/helper-plugin-utils" "^7.24.5"
+    "@babel/helper-annotate-as-pure" "^7.24.6"
+    "@babel/helper-create-class-features-plugin" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
     "@babel/plugin-syntax-private-property-in-object" "^7.14.5"
 
-"@babel/plugin-transform-property-literals@^7.0.0", "@babel/plugin-transform-property-literals@^7.24.1":
+"@babel/plugin-transform-property-literals@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.24.1.tgz#d6a9aeab96f03749f4eebeb0b6ea8e90ec958825"
   integrity sha512-LetvD7CrHmEx0G442gOomRr66d7q8HzzGGr4PMHGr+5YIm6++Yke+jxj246rpvsbyhJwCLxcTn6zW1P1BSenqA==
@@ -2388,6 +2561,13 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
+"@babel/plugin-transform-property-literals@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.24.6.tgz#243c4faabe811c405e9443059a58e834bf95dfd1"
+  integrity sha512-oARaglxhRsN18OYsnPTpb8TcKQWDYNsPNmTnx5++WOAsUJ0cSC/FZVlIJCKvPbU4yn/UXsS0551CFKJhN0CaMw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.24.6"
+
 "@babel/plugin-transform-react-display-name@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.24.1.tgz#554e3e1a25d181f040cf698b93fd289a03bfdcdb"
@@ -2496,12 +2676,12 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     regenerator-transform "^0.15.1"
 
-"@babel/plugin-transform-regenerator@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.24.1.tgz#625b7545bae52363bdc1fbbdc7252b5046409c8c"
-  integrity sha512-sJwZBCzIBE4t+5Q4IGLaaun5ExVMRY0lYwos/jNecjMrVCygCdph3IKv0tkP5Fc87e/1+bebAmEAGBfnRD+cnw==
+"@babel/plugin-transform-regenerator@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.24.6.tgz#ed10cf0c13619365e15459f88d1b915ac57ffc24"
+  integrity sha512-SMDxO95I8WXRtXhTAc8t/NFQUT7VYbIWwJCJgEli9ml4MhqUMh4S6hxgH6SmAC3eAQNWCDJFxcFeEt9w2sDdXg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
     regenerator-transform "^0.15.2"
 
 "@babel/plugin-transform-reserved-words@^7.18.6":
@@ -2518,14 +2698,14 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-reserved-words@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.24.1.tgz#8de729f5ecbaaf5cf83b67de13bad38a21be57c1"
-  integrity sha512-JAclqStUfIwKN15HrsQADFgeZt+wexNQ0uLhuqvqAUFoqPMjEcFCYZBhq0LUdz6dZK/mD+rErhW71fbx8RYElg==
+"@babel/plugin-transform-reserved-words@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.24.6.tgz#9eb16cbf339fcea0a46677716c775afb5ef14245"
+  integrity sha512-DcrgFXRRlK64dGE0ZFBPD5egM2uM8mgfrvTMOSB2yKzOtjpGegVYkzh3s1zZg1bBck3nkXiaOamJUqK3Syk+4A==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
-"@babel/plugin-transform-shorthand-properties@^7.0.0", "@babel/plugin-transform-shorthand-properties@^7.24.1":
+"@babel/plugin-transform-shorthand-properties@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.24.1.tgz#ba9a09144cf55d35ec6b93a32253becad8ee5b55"
   integrity sha512-LyjVB1nsJ6gTTUKRjRWx9C1s9hE7dLfP/knKdrfeH9UPtAGjYGgxIbFfx7xyLIEWs7Xe1Gnf8EWiUqfjLhInZA==
@@ -2546,7 +2726,14 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-spread@^7.0.0", "@babel/plugin-transform-spread@^7.24.1":
+"@babel/plugin-transform-shorthand-properties@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.24.6.tgz#ef734ebccc428d2174c7bb36015d0800faf5381e"
+  integrity sha512-xnEUvHSMr9eOWS5Al2YPfc32ten7CXdH7Zwyyk7IqITg4nX61oHj+GxpNvl+y5JHjfN3KXE2IV55wAWowBYMVw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.24.6"
+
+"@babel/plugin-transform-spread@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.24.1.tgz#a1acf9152cbf690e4da0ba10790b3ac7d2b2b391"
   integrity sha512-KjmcIM+fxgY+KxPVbjelJC6hrH1CgtPmTvdXAfn3/a9CnWGSTY7nH4zm5+cjmWJybdcPSsD0++QssDsjcpe47g==
@@ -2570,6 +2757,14 @@
     "@babel/helper-plugin-utils" "^7.22.5"
     "@babel/helper-skip-transparent-expression-wrappers" "^7.22.5"
 
+"@babel/plugin-transform-spread@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.24.6.tgz#a56cecbd8617675531d1b79f5b755b7613aa0822"
+  integrity sha512-h/2j7oIUDjS+ULsIrNZ6/TKG97FgmEk1PXryk/HQq6op4XUUUwif2f69fJrzK0wza2zjCS1xhXmouACaWV5uPA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.24.6"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.24.6"
+
 "@babel/plugin-transform-sticky-regex@^7.18.6":
   version "7.18.6"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.18.6.tgz#c6706eb2b1524028e317720339583ad0f444adcc"
@@ -2584,14 +2779,14 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-sticky-regex@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.24.1.tgz#f03e672912c6e203ed8d6e0271d9c2113dc031b9"
-  integrity sha512-9v0f1bRXgPVcPrngOQvLXeGNNVLc8UjMVfebo9ka0WF3/7+aVUHmaJVT3sa0XCzEFioPfPHZiOcYG9qOsH63cw==
+"@babel/plugin-transform-sticky-regex@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.24.6.tgz#1a78127731fea87d954bed193840986a38f04327"
+  integrity sha512-fN8OcTLfGmYv7FnDrsjodYBo1DhPL3Pze/9mIIE2MGCT1KgADYIOD7rEglpLHZj8PZlC/JFX5WcD+85FLAQusw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
-"@babel/plugin-transform-template-literals@^7.0.0", "@babel/plugin-transform-template-literals@^7.24.1":
+"@babel/plugin-transform-template-literals@^7.0.0":
   version "7.24.1"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.24.1.tgz#15e2166873a30d8617e3e2ccadb86643d327aab7"
   integrity sha512-WRkhROsNzriarqECASCNu/nojeXCDTE/F2HmRgOzi7NGvyfYGq1NEjKBK3ckLfRgGc6/lPAqP0vDOSw3YtG34g==
@@ -2612,6 +2807,13 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
+"@babel/plugin-transform-template-literals@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.24.6.tgz#aaf2ae157acd0e5c9265dba8ac0a439f8d2a6303"
+  integrity sha512-BJbEqJIcKwrqUP+KfUIkxz3q8VzXe2R8Wv8TaNgO1cx+nNavxn/2+H8kp9tgFSOL6wYPPEgFvU6IKS4qoGqhmg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.24.6"
+
 "@babel/plugin-transform-typeof-symbol@^7.18.9":
   version "7.18.9"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.18.9.tgz#c8cea68263e45addcd6afc9091429f80925762c0"
@@ -2626,12 +2828,12 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-typeof-symbol@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.24.5.tgz#703cace5ef74155fb5eecab63cbfc39bdd25fe12"
-  integrity sha512-UTGnhYVZtTAjdwOTzT+sCyXmTn8AhaxOS/MjG9REclZ6ULHWF9KoCZur0HSGU7hk8PdBFKKbYe6+gqdXWz84Jg==
+"@babel/plugin-transform-typeof-symbol@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.24.6.tgz#3d02da23ebcc8f1982ddcd1f2581cf3ee4e58762"
+  integrity sha512-IshCXQ+G9JIFJI7bUpxTE/oA2lgVLAIK8q1KdJNoPXOpvRaNjMySGuvLfBw/Xi2/1lLo953uE8hyYSDW3TSYig==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.5"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-typescript@^7.21.3":
   version "7.21.3"
@@ -2664,12 +2866,12 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-unicode-escapes@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.24.1.tgz#fb3fa16676549ac7c7449db9b342614985c2a3a4"
-  integrity sha512-RlkVIcWT4TLI96zM660S877E7beKlQw7Ig+wqkKBiWfj0zH5Q4h50q6er4wzZKRNSYpfo6ILJ+hrJAGSX2qcNw==
+"@babel/plugin-transform-unicode-escapes@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.24.6.tgz#c8ddca8fd5bacece837a4e27bd3b7ed64580d1a8"
+  integrity sha512-bKl3xxcPbkQQo5eX9LjjDpU2xYHeEeNQbOhj0iPvetSzA+Tu9q/o5lujF4Sek60CM6MgYvOS/DJuwGbiEYAnLw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-unicode-property-regex@^7.22.5":
   version "7.22.5"
@@ -2679,13 +2881,13 @@
     "@babel/helper-create-regexp-features-plugin" "^7.22.5"
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-unicode-property-regex@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.24.1.tgz#56704fd4d99da81e5e9f0c0c93cabd91dbc4889e"
-  integrity sha512-Ss4VvlfYV5huWApFsF8/Sq0oXnGO+jB+rijFEFugTd3cwSObUSnUi88djgR5528Csl0uKlrI331kRqe56Ov2Ng==
+"@babel/plugin-transform-unicode-property-regex@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.24.6.tgz#e66297d5d452db0b0be56515e3d0e10b7d33fb32"
+  integrity sha512-8EIgImzVUxy15cZiPii9GvLZwsy7Vxc+8meSlR3cXFmBIl5W5Tn9LGBf7CDKkHj4uVfNXCJB8RsVfnmY61iedA==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.22.15"
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-create-regexp-features-plugin" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-unicode-regex@^7.18.6":
   version "7.18.6"
@@ -2703,13 +2905,13 @@
     "@babel/helper-create-regexp-features-plugin" "^7.22.5"
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-unicode-regex@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.24.1.tgz#57c3c191d68f998ac46b708380c1ce4d13536385"
-  integrity sha512-2A/94wgZgxfTsiLaQ2E36XAOdcZmGAaEEgVmxQWwZXWkGhvoHbaqXcKnU8zny4ycpu3vNqg0L/PcCiYtHtA13g==
+"@babel/plugin-transform-unicode-regex@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.24.6.tgz#2001e7d87ed709eea145e0b65fb5f93c3c0e225b"
+  integrity sha512-pssN6ExsvxaKU638qcWb81RrvvgZom3jDgU/r5xFZ7TONkZGFf4MhI2ltMb8OcQWhHyxgIavEU+hgqtbKOmsPA==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.22.15"
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-create-regexp-features-plugin" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/plugin-transform-unicode-sets-regex@^7.22.5":
   version "7.22.5"
@@ -2719,13 +2921,13 @@
     "@babel/helper-create-regexp-features-plugin" "^7.22.5"
     "@babel/helper-plugin-utils" "^7.22.5"
 
-"@babel/plugin-transform-unicode-sets-regex@^7.24.1":
-  version "7.24.1"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.24.1.tgz#c1ea175b02afcffc9cf57a9c4658326625165b7f"
-  integrity sha512-fqj4WuzzS+ukpgerpAoOnMfQXwUHFxXUZUE84oL2Kao2N8uSlvcpnAidKASgsNgzZHBsHWvcm8s9FPWUhAb8fA==
+"@babel/plugin-transform-unicode-sets-regex@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.24.6.tgz#f18b7292222aee85c155258ceb345a146a070a46"
+  integrity sha512-quiMsb28oXWIDK0gXLALOJRXLgICLiulqdZGOaPPd0vRT7fQp74NtdADAVu+D8s00C+0Xs0MxVP0VKF/sZEUgw==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.22.15"
-    "@babel/helper-plugin-utils" "^7.24.0"
+    "@babel/helper-create-regexp-features-plugin" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
 
 "@babel/preset-env@7.20.2":
   version "7.20.2"
@@ -2891,26 +3093,26 @@
     semver "^6.3.0"
 
 "@babel/preset-env@^7.11.0":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.24.5.tgz#6a9ac90bd5a5a9dae502af60dfc58c190551bbcd"
-  integrity sha512-UGK2ifKtcC8i5AI4cH+sbLLuLc2ktYSFJgBAXorKAsHUZmrQ1q6aQ6i3BvU24wWs2AAKqQB6kq3N9V9Gw1HiMQ==
-  dependencies:
-    "@babel/compat-data" "^7.24.4"
-    "@babel/helper-compilation-targets" "^7.23.6"
-    "@babel/helper-plugin-utils" "^7.24.5"
-    "@babel/helper-validator-option" "^7.23.5"
-    "@babel/plugin-bugfix-firefox-class-in-computed-class-key" "^7.24.5"
-    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression" "^7.24.1"
-    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining" "^7.24.1"
-    "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly" "^7.24.1"
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.24.6.tgz#a5a55bc70e5ff1ed7f872067e2a9d65ff917ad6f"
+  integrity sha512-CrxEAvN7VxfjOG8JNF2Y/eMqMJbZPZ185amwGUBp8D9USK90xQmv7dLdFSa+VbD7fdIqcy/Mfv7WtzG8+/qxKg==
+  dependencies:
+    "@babel/compat-data" "^7.24.6"
+    "@babel/helper-compilation-targets" "^7.24.6"
+    "@babel/helper-plugin-utils" "^7.24.6"
+    "@babel/helper-validator-option" "^7.24.6"
+    "@babel/plugin-bugfix-firefox-class-in-computed-class-key" "^7.24.6"
+    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression" "^7.24.6"
+    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining" "^7.24.6"
+    "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly" "^7.24.6"
     "@babel/plugin-proposal-private-property-in-object" "7.21.0-placeholder-for-preset-env.2"
     "@babel/plugin-syntax-async-generators" "^7.8.4"
     "@babel/plugin-syntax-class-properties" "^7.12.13"
     "@babel/plugin-syntax-class-static-block" "^7.14.5"
     "@babel/plugin-syntax-dynamic-import" "^7.8.3"
     "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
-    "@babel/plugin-syntax-import-assertions" "^7.24.1"
-    "@babel/plugin-syntax-import-attributes" "^7.24.1"
+    "@babel/plugin-syntax-import-assertions" "^7.24.6"
+    "@babel/plugin-syntax-import-attributes" "^7.24.6"
     "@babel/plugin-syntax-import-meta" "^7.10.4"
     "@babel/plugin-syntax-json-strings" "^7.8.3"
     "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4"
@@ -2922,54 +3124,54 @@
     "@babel/plugin-syntax-private-property-in-object" "^7.14.5"
     "@babel/plugin-syntax-top-level-await" "^7.14.5"
     "@babel/plugin-syntax-unicode-sets-regex" "^7.18.6"
-    "@babel/plugin-transform-arrow-functions" "^7.24.1"
-    "@babel/plugin-transform-async-generator-functions" "^7.24.3"
-    "@babel/plugin-transform-async-to-generator" "^7.24.1"
-    "@babel/plugin-transform-block-scoped-functions" "^7.24.1"
-    "@babel/plugin-transform-block-scoping" "^7.24.5"
-    "@babel/plugin-transform-class-properties" "^7.24.1"
-    "@babel/plugin-transform-class-static-block" "^7.24.4"
-    "@babel/plugin-transform-classes" "^7.24.5"
-    "@babel/plugin-transform-computed-properties" "^7.24.1"
-    "@babel/plugin-transform-destructuring" "^7.24.5"
-    "@babel/plugin-transform-dotall-regex" "^7.24.1"
-    "@babel/plugin-transform-duplicate-keys" "^7.24.1"
-    "@babel/plugin-transform-dynamic-import" "^7.24.1"
-    "@babel/plugin-transform-exponentiation-operator" "^7.24.1"
-    "@babel/plugin-transform-export-namespace-from" "^7.24.1"
-    "@babel/plugin-transform-for-of" "^7.24.1"
-    "@babel/plugin-transform-function-name" "^7.24.1"
-    "@babel/plugin-transform-json-strings" "^7.24.1"
-    "@babel/plugin-transform-literals" "^7.24.1"
-    "@babel/plugin-transform-logical-assignment-operators" "^7.24.1"
-    "@babel/plugin-transform-member-expression-literals" "^7.24.1"
-    "@babel/plugin-transform-modules-amd" "^7.24.1"
-    "@babel/plugin-transform-modules-commonjs" "^7.24.1"
-    "@babel/plugin-transform-modules-systemjs" "^7.24.1"
-    "@babel/plugin-transform-modules-umd" "^7.24.1"
-    "@babel/plugin-transform-named-capturing-groups-regex" "^7.22.5"
-    "@babel/plugin-transform-new-target" "^7.24.1"
-    "@babel/plugin-transform-nullish-coalescing-operator" "^7.24.1"
-    "@babel/plugin-transform-numeric-separator" "^7.24.1"
-    "@babel/plugin-transform-object-rest-spread" "^7.24.5"
-    "@babel/plugin-transform-object-super" "^7.24.1"
-    "@babel/plugin-transform-optional-catch-binding" "^7.24.1"
-    "@babel/plugin-transform-optional-chaining" "^7.24.5"
-    "@babel/plugin-transform-parameters" "^7.24.5"
-    "@babel/plugin-transform-private-methods" "^7.24.1"
-    "@babel/plugin-transform-private-property-in-object" "^7.24.5"
-    "@babel/plugin-transform-property-literals" "^7.24.1"
-    "@babel/plugin-transform-regenerator" "^7.24.1"
-    "@babel/plugin-transform-reserved-words" "^7.24.1"
-    "@babel/plugin-transform-shorthand-properties" "^7.24.1"
-    "@babel/plugin-transform-spread" "^7.24.1"
-    "@babel/plugin-transform-sticky-regex" "^7.24.1"
-    "@babel/plugin-transform-template-literals" "^7.24.1"
-    "@babel/plugin-transform-typeof-symbol" "^7.24.5"
-    "@babel/plugin-transform-unicode-escapes" "^7.24.1"
-    "@babel/plugin-transform-unicode-property-regex" "^7.24.1"
-    "@babel/plugin-transform-unicode-regex" "^7.24.1"
-    "@babel/plugin-transform-unicode-sets-regex" "^7.24.1"
+    "@babel/plugin-transform-arrow-functions" "^7.24.6"
+    "@babel/plugin-transform-async-generator-functions" "^7.24.6"
+    "@babel/plugin-transform-async-to-generator" "^7.24.6"
+    "@babel/plugin-transform-block-scoped-functions" "^7.24.6"
+    "@babel/plugin-transform-block-scoping" "^7.24.6"
+    "@babel/plugin-transform-class-properties" "^7.24.6"
+    "@babel/plugin-transform-class-static-block" "^7.24.6"
+    "@babel/plugin-transform-classes" "^7.24.6"
+    "@babel/plugin-transform-computed-properties" "^7.24.6"
+    "@babel/plugin-transform-destructuring" "^7.24.6"
+    "@babel/plugin-transform-dotall-regex" "^7.24.6"
+    "@babel/plugin-transform-duplicate-keys" "^7.24.6"
+    "@babel/plugin-transform-dynamic-import" "^7.24.6"
+    "@babel/plugin-transform-exponentiation-operator" "^7.24.6"
+    "@babel/plugin-transform-export-namespace-from" "^7.24.6"
+    "@babel/plugin-transform-for-of" "^7.24.6"
+    "@babel/plugin-transform-function-name" "^7.24.6"
+    "@babel/plugin-transform-json-strings" "^7.24.6"
+    "@babel/plugin-transform-literals" "^7.24.6"
+    "@babel/plugin-transform-logical-assignment-operators" "^7.24.6"
+    "@babel/plugin-transform-member-expression-literals" "^7.24.6"
+    "@babel/plugin-transform-modules-amd" "^7.24.6"
+    "@babel/plugin-transform-modules-commonjs" "^7.24.6"
+    "@babel/plugin-transform-modules-systemjs" "^7.24.6"
+    "@babel/plugin-transform-modules-umd" "^7.24.6"
+    "@babel/plugin-transform-named-capturing-groups-regex" "^7.24.6"
+    "@babel/plugin-transform-new-target" "^7.24.6"
+    "@babel/plugin-transform-nullish-coalescing-operator" "^7.24.6"
+    "@babel/plugin-transform-numeric-separator" "^7.24.6"
+    "@babel/plugin-transform-object-rest-spread" "^7.24.6"
+    "@babel/plugin-transform-object-super" "^7.24.6"
+    "@babel/plugin-transform-optional-catch-binding" "^7.24.6"
+    "@babel/plugin-transform-optional-chaining" "^7.24.6"
+    "@babel/plugin-transform-parameters" "^7.24.6"
+    "@babel/plugin-transform-private-methods" "^7.24.6"
+    "@babel/plugin-transform-private-property-in-object" "^7.24.6"
+    "@babel/plugin-transform-property-literals" "^7.24.6"
+    "@babel/plugin-transform-regenerator" "^7.24.6"
+    "@babel/plugin-transform-reserved-words" "^7.24.6"
+    "@babel/plugin-transform-shorthand-properties" "^7.24.6"
+    "@babel/plugin-transform-spread" "^7.24.6"
+    "@babel/plugin-transform-sticky-regex" "^7.24.6"
+    "@babel/plugin-transform-template-literals" "^7.24.6"
+    "@babel/plugin-transform-typeof-symbol" "^7.24.6"
+    "@babel/plugin-transform-unicode-escapes" "^7.24.6"
+    "@babel/plugin-transform-unicode-property-regex" "^7.24.6"
+    "@babel/plugin-transform-unicode-regex" "^7.24.6"
+    "@babel/plugin-transform-unicode-sets-regex" "^7.24.6"
     "@babel/preset-modules" "0.1.6-no-external-plugins"
     babel-plugin-polyfill-corejs2 "^0.4.10"
     babel-plugin-polyfill-corejs3 "^0.10.4"
@@ -3224,6 +3426,15 @@
     "@babel/parser" "^7.24.0"
     "@babel/types" "^7.24.0"
 
+"@babel/template@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.24.6.tgz#048c347b2787a6072b24c723664c8d02b67a44f9"
+  integrity sha512-3vgazJlLwNXi9jhrR1ef8qiB65L1RK90+lEQwv4OxveHnqC3BfmnHdgySwRLzf6akhlOYenT+b7AfWq+a//AHw==
+  dependencies:
+    "@babel/code-frame" "^7.24.6"
+    "@babel/parser" "^7.24.6"
+    "@babel/types" "^7.24.6"
+
 "@babel/traverse@^7.1.6", "@babel/traverse@^7.20.5", "@babel/traverse@^7.20.7", "@babel/traverse@^7.21.2", "@babel/traverse@^7.21.5", "@babel/traverse@^7.22.6", "@babel/traverse@^7.22.8", "@babel/traverse@^7.7.0":
   version "7.23.2"
   resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.23.2.tgz#329c7a06735e144a506bdb2cad0268b7f46f4ad8"
@@ -3256,19 +3467,19 @@
     debug "^4.3.1"
     globals "^11.1.0"
 
-"@babel/traverse@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.24.5.tgz#972aa0bc45f16983bf64aa1f877b2dd0eea7e6f8"
-  integrity sha512-7aaBLeDQ4zYcUFDUD41lJc1fG8+5IU9DaNSJAgal866FGvmD5EbWQgnEC6kO1gGLsX0esNkfnJSndbTXA3r7UA==
-  dependencies:
-    "@babel/code-frame" "^7.24.2"
-    "@babel/generator" "^7.24.5"
-    "@babel/helper-environment-visitor" "^7.22.20"
-    "@babel/helper-function-name" "^7.23.0"
-    "@babel/helper-hoist-variables" "^7.22.5"
-    "@babel/helper-split-export-declaration" "^7.24.5"
-    "@babel/parser" "^7.24.5"
-    "@babel/types" "^7.24.5"
+"@babel/traverse@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.24.6.tgz#0941ec50cdeaeacad0911eb67ae227a4f8424edc"
+  integrity sha512-OsNjaJwT9Zn8ozxcfoBc+RaHdj3gFmCmYoQLUII1o6ZrUwku0BMg80FoOTPx+Gi6XhcQxAYE4xyjPTo4SxEQqw==
+  dependencies:
+    "@babel/code-frame" "^7.24.6"
+    "@babel/generator" "^7.24.6"
+    "@babel/helper-environment-visitor" "^7.24.6"
+    "@babel/helper-function-name" "^7.24.6"
+    "@babel/helper-hoist-variables" "^7.24.6"
+    "@babel/helper-split-export-declaration" "^7.24.6"
+    "@babel/parser" "^7.24.6"
+    "@babel/types" "^7.24.6"
     debug "^4.3.1"
     globals "^11.1.0"
 
@@ -3317,13 +3528,13 @@
     "@babel/helper-validator-identifier" "^7.22.5"
     to-fast-properties "^2.0.0"
 
-"@babel/types@^7.24.5":
-  version "7.24.5"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.24.5.tgz#7661930afc638a5383eb0c4aee59b74f38db84d7"
-  integrity sha512-6mQNsaLeXTw0nxYUYu+NSa4Hx4BlF1x1x8/PMFbiR+GBSr+2DkECc69b8hgy2frEodNcvPffeH8YfWd3LI6jhQ==
+"@babel/types@^7.24.6":
+  version "7.24.6"
+  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.24.6.tgz#ba4e1f59870c10dc2fa95a274ac4feec23b21912"
+  integrity sha512-WaMsgi6Q8zMgMth93GvWPXkhAIEobfsIkLTacoVZoK1J0CevIPGYY2Vo5YvJGqyHqXM6P4ppOYGsIRU8MM9pFQ==
   dependencies:
-    "@babel/helper-string-parser" "^7.24.1"
-    "@babel/helper-validator-identifier" "^7.24.5"
+    "@babel/helper-string-parser" "^7.24.6"
+    "@babel/helper-validator-identifier" "^7.24.6"
     to-fast-properties "^2.0.0"
 
 "@base2/pretty-print-object@1.0.1":
@@ -5693,6 +5904,11 @@
     progress-events "^1.0.0"
     sparse-array "^1.3.2"
 
+"@huggingface/jinja@^0.2.2":
+  version "0.2.2"
+  resolved "https://registry.yarnpkg.com/@huggingface/jinja/-/jinja-0.2.2.tgz#faeb205a9d6995089bef52655ddd8245d3190627"
+  integrity sha512-/KPde26khDUIPkTGU82jdtTW9UAuvUTumCAbFs/7giR0SxsvZC4hru51PBvpijH6BVkHcROcvZM/lpy5h1jRRA==
+
 "@humanwhocodes/config-array@^0.11.8":
   version "0.11.8"
   resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.11.8.tgz#03595ac2075a4dc0f191cc2131de14fbd7d410b9"
@@ -10631,6 +10847,17 @@
   dependencies:
     tslib "^2.3.0"
 
+"@xenova/transformers@^2.17.0":
+  version "2.17.1"
+  resolved "https://registry.yarnpkg.com/@xenova/transformers/-/transformers-2.17.1.tgz#712f7a72c76c8aa2075749382f83dc7dd4e5a9a5"
+  integrity sha512-zo702tQAFZXhzeD2GCYUNUqeqkoueOdiSbQWa4s0q7ZE4z8WBIwIsMMPGobpgdqjQ2u0Qulo08wuqVEUrBXjkQ==
+  dependencies:
+    "@huggingface/jinja" "^0.2.2"
+    onnxruntime-web "1.14.0"
+    sharp "^0.32.0"
+  optionalDependencies:
+    onnxruntime-node "1.14.0"
+
 "@xtuc/ieee754@^1.2.0":
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/@xtuc/ieee754/-/ieee754-1.2.0.tgz#eef014a3145ae477a1cbc00cd1e552336dceb790"
@@ -10956,9 +11183,9 @@ ajv@^8.0.0, ajv@^8.0.1, ajv@^8.8.0:
     uri-js "^4.2.2"
 
 ajv@^8.6.0:
-  version "8.13.0"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.13.0.tgz#a3939eaec9fb80d217ddf0c3376948c023f28c91"
-  integrity sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA==
+  version "8.14.0"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.14.0.tgz#f514ddfd4756abb200e1704414963620a625ebbb"
+  integrity sha512-oYs1UUtO97ZO2lJ4bwnWeQW8/zvOIQLGKcvPTsWmvc2SYgBb+upuNS5NxoLaMU4h8Ju3Nbj6Cq8mD2LQoqVKFA==
   dependencies:
     fast-deep-equal "^3.1.3"
     json-schema-traverse "^1.0.0"
@@ -11629,6 +11856,11 @@ axobject-query@^3.1.1:
   dependencies:
     deep-equal "^2.0.5"
 
+b4a@^1.6.4:
+  version "1.6.6"
+  resolved "https://registry.yarnpkg.com/b4a/-/b4a-1.6.6.tgz#a4cc349a3851987c3c4ac2d7785c18744f6da9ba"
+  integrity sha512-5Tk1HLk6b6ctmjIkAcU/Ujv/1WqiDl0F0JdRCR80VsOcUlHcu7pWeWRlOqQLHfDEsVx9YH/aif5AG4ehoCtTmg==
+
 babel-core@^7.0.0-bridge.0:
   version "7.0.0-bridge.0"
   resolved "https://registry.yarnpkg.com/babel-core/-/babel-core-7.0.0-bridge.0.tgz#95a492ddd90f9b4e9a4a1da14eb335b87b634ece"
@@ -11905,6 +12137,39 @@ balanced-match@^2.0.0:
   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-2.0.0.tgz#dc70f920d78db8b858535795867bf48f820633d9"
   integrity sha512-1ugUSr8BHXRnK23KfuYS+gVMC3LB8QGH9W1iGtDPsNWoQbgtXSExkBu2aDR4epiGWZOjZsj6lDl/N/AqqTC3UA==
 
+bare-events@^2.0.0, bare-events@^2.2.0:
+  version "2.2.2"
+  resolved "https://registry.yarnpkg.com/bare-events/-/bare-events-2.2.2.tgz#a98a41841f98b2efe7ecc5c5468814469b018078"
+  integrity sha512-h7z00dWdG0PYOQEvChhOSWvOfkIKsdZGkWr083FgN/HyoQuebSew/cgirYqh9SCuy/hRvxc5Vy6Fw8xAmYHLkQ==
+
+bare-fs@^2.1.1:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/bare-fs/-/bare-fs-2.3.0.tgz#0872f8e33cf291c9fd527d827154f156a298d402"
+  integrity sha512-TNFqa1B4N99pds2a5NYHR15o0ZpdNKbAeKTE/+G6ED/UeOavv8RY3dr/Fu99HW3zU3pXpo2kDNO8Sjsm2esfOw==
+  dependencies:
+    bare-events "^2.0.0"
+    bare-path "^2.0.0"
+    bare-stream "^1.0.0"
+
+bare-os@^2.1.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/bare-os/-/bare-os-2.3.0.tgz#718e680b139effff0624a7421c098e7a2c2d63da"
+  integrity sha512-oPb8oMM1xZbhRQBngTgpcQ5gXw6kjOaRsSWsIeNyRxGed2w/ARyP7ScBYpWR1qfX2E5rS3gBw6OWcSQo+s+kUg==
+
+bare-path@^2.0.0, bare-path@^2.1.0:
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/bare-path/-/bare-path-2.1.2.tgz#7a0940d34ebe65f7e179fa61ed8d49d9dc151d67"
+  integrity sha512-o7KSt4prEphWUHa3QUwCxUI00R86VdjiuxmJK0iNVDHYPGo+HsDaVCnqCmPbf/MiW1ok8F4p3m8RTHlWk8K2ig==
+  dependencies:
+    bare-os "^2.1.0"
+
+bare-stream@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/bare-stream/-/bare-stream-1.0.0.tgz#25c3e56198d922187320c3f8c52d75c4051178b4"
+  integrity sha512-KhNUoDL40iP4gFaLSsoGE479t0jHijfYdIcxRn/XtezA2BaUD0NRf/JGRpsMq6dMNM+SrCrB0YSSo/5wBY4rOQ==
+  dependencies:
+    streamx "^2.16.1"
+
 barycentric@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/barycentric/-/barycentric-1.0.1.tgz#f1562bb891b26f4fec463a82eeda3657800ec688"
@@ -13258,6 +13523,11 @@ co@^4.6.0:
   resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184"
   integrity sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==
 
+codemirror@5.57.0:
+  version "5.57.0"
+  resolved "https://registry.yarnpkg.com/codemirror/-/codemirror-5.57.0.tgz#d26365b72f909f5d2dbb6b1209349ca1daeb2d50"
+  integrity sha512-WGc6UL7Hqt+8a6ZAsj/f1ApQl3NPvHY/UQSzG6fB6l4BjExgVdhFaxd7mRTw1UCiYe/6q86zHP+kfvBQcZGvUg==
+
 collect-v8-coverage@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/collect-v8-coverage/-/collect-v8-coverage-1.0.1.tgz#cc2c8e94fc18bbdffe64d6534570c8a673b27f59"
@@ -13379,7 +13649,7 @@ color-space@^2.0.0:
   resolved "https://registry.yarnpkg.com/color-space/-/color-space-2.0.0.tgz#ae7813abcbe3dabda9e3e2266b0675f688b24977"
   integrity sha512-Bu8P/usGNuVWushjxcuaGSkhT+L2KX0cvgMGMTF0KJ7lFeqonhsntT68d6Yu3uwZzCmbF7KTB9EV67AGcUXhJw==
 
-color-string@^1.6.0:
+color-string@^1.6.0, color-string@^1.9.0:
   version "1.9.1"
   resolved "https://registry.yarnpkg.com/color-string/-/color-string-1.9.1.tgz#4467f9146f036f855b764dfb5bf8582bf342c7a4"
   integrity sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==
@@ -13395,6 +13665,14 @@ color@^3.1.3:
     color-convert "^1.9.3"
     color-string "^1.6.0"
 
+color@^4.2.3:
+  version "4.2.3"
+  resolved "https://registry.yarnpkg.com/color/-/color-4.2.3.tgz#d781ecb5e57224ee43ea9627560107c0e0c6463a"
+  integrity sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==
+  dependencies:
+    color-convert "^2.0.1"
+    color-string "^1.9.0"
+
 colord@^2.9.1, colord@^2.9.3:
   version "2.9.3"
   resolved "https://registry.yarnpkg.com/colord/-/colord-2.9.3.tgz#4f8ce919de456f1d5c1c368c307fe20f3e59fb43"
@@ -13783,9 +14061,9 @@ core-js-compat@^3.31.0:
     browserslist "^4.21.9"
 
 core-js-compat@^3.36.1:
-  version "3.37.0"
-  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.37.0.tgz#d9570e544163779bb4dff1031c7972f44918dc73"
-  integrity sha512-vYq4L+T8aS5UuFg4UwDhc7YNRWVeVZwltad9C/jV3R2LgVOpS9BDr7l/WL6BN0dbV3k1XejPTHqqEzJgsa0frA==
+  version "3.37.1"
+  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.37.1.tgz#c844310c7852f4bdf49b8d339730b97e17ff09ee"
+  integrity sha512-9TNiImhKvQqSUkOvk/mMRZzOANTiEVC7WaBNhHcKM7x+/5E1l5NvsysR19zuDQScE8k+kfQXWRN3AtS/eOSHpg==
   dependencies:
     browserslist "^4.23.0"
 
@@ -14314,6 +14592,11 @@ cyb-cozo-lib-wasm@^0.7.145:
   resolved "https://registry.yarnpkg.com/cyb-cozo-lib-wasm/-/cyb-cozo-lib-wasm-0.7.145.tgz#df82255d478415134d0a2cf82de1467c2009db92"
   integrity sha512-vCbiFuBPFOaMyS9kPutatBDekAqEafmsQ9jX34J3eMzQiBmoyujsm+z6jZiLwVWz2yDNtF/H17ofgexalHKjnw==
 
+cyb-rune-wasm@^0.0.82:
+  version "0.0.82"
+  resolved "https://registry.yarnpkg.com/cyb-rune-wasm/-/cyb-rune-wasm-0.0.82.tgz#f5ecb2c3f0d9e55b6a44b542191d0e0de57a8b65"
+  integrity sha512-u+SIcFd09gEWwVlStGAimI465xkt7tBF5YtZ58nsQIs8OdWX3IXeHsnkmcJPGeP7ZVQDFY3SCwSwHM77F1p7Gw==
+
 d3-array@1, d3-array@^1.1.1, d3-array@^1.2.0, d3-array@^1.2.1:
   version "1.2.4"
   resolved "https://registry.yarnpkg.com/d3-array/-/d3-array-1.2.4.tgz#635ce4d5eea759f6f605863dbcfc30edc737f71f"
@@ -15290,6 +15573,11 @@ detect-libc@^2.0.0:
   resolved "https://registry.yarnpkg.com/detect-libc/-/detect-libc-2.0.2.tgz#8ccf2ba9315350e1241b88d0ac3b0e1fbd99605d"
   integrity sha512-UX6sGumvvqSaXgdKGUsgZWqcUyIXZ/vZTrlRT/iobiKhGL0zL4d3osHj3uqllWJK+i+sixDS/3COVEOFbupFyw==
 
+detect-libc@^2.0.2:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/detect-libc/-/detect-libc-2.0.3.tgz#f0cd503b40f9939b894697d19ad50895e30cf700"
+  integrity sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==
+
 detect-newline@^3.0.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-3.1.0.tgz#576f5dfc63ae1a192ff192d8ad3af6308991b651"
@@ -15610,13 +15898,20 @@ ee-first@1.1.1:
   resolved "https://registry.yarnpkg.com/ee-first/-/ee-first-1.1.1.tgz#590c61156b0ae2f4f0255732a158b266bc56b21d"
   integrity sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==
 
-ejs@^3.1.6, ejs@^3.1.8:
+ejs@^3.1.6:
   version "3.1.10"
   resolved "https://registry.yarnpkg.com/ejs/-/ejs-3.1.10.tgz#69ab8358b14e896f80cc39e62087b88500c3ac3b"
   integrity sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==
   dependencies:
     jake "^10.8.5"
 
+ejs@^3.1.8:
+  version "3.1.9"
+  resolved "https://registry.yarnpkg.com/ejs/-/ejs-3.1.9.tgz#03c9e8777fe12686a9effcef22303ca3d8eeb361"
+  integrity sha512-rC+QVNMJWv+MtPgkt0y+0rVEIdbtxVADApW9JXrUVlzHetgcyczP/E7DJmWJ4fJCZF2cPcBk0laWO9ZHMG3DmQ==
+  dependencies:
+    jake "^10.8.5"
+
 electron-fetch@^1.7.2:
   version "1.9.1"
   resolved "https://registry.yarnpkg.com/electron-fetch/-/electron-fetch-1.9.1.tgz#e28bfe78d467de3f2dec884b1d72b8b05322f30f"
@@ -17131,6 +17426,11 @@ fast-fifo@^1.0.0:
   resolved "https://registry.yarnpkg.com/fast-fifo/-/fast-fifo-1.1.0.tgz#17d1a3646880b9891dfa0c54e69c5fef33cad779"
   integrity sha512-Kl29QoNbNvn4nhDsLYjyIAaIqaJB6rBx5p3sL9VjaefJ+eMFBWVZiaoguaoZfzEKr5RhAti0UgM8703akGPJ6g==
 
+fast-fifo@^1.1.0, fast-fifo@^1.2.0:
+  version "1.3.2"
+  resolved "https://registry.yarnpkg.com/fast-fifo/-/fast-fifo-1.3.2.tgz#286e31de96eb96d38a97899815740ba2a4f3640c"
+  integrity sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==
+
 fast-glob@^3.2.11, fast-glob@^3.2.12, fast-glob@^3.2.9, fast-glob@^3.3.0:
   version "3.3.0"
   resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.3.0.tgz#7c40cb491e1e2ed5664749e87bfb516dbe8727c0"
@@ -17479,6 +17779,11 @@ flat-cache@^3.0.4:
     flatted "^3.1.0"
     rimraf "^3.0.2"
 
+flatbuffers@^1.12.0:
+  version "1.12.0"
+  resolved "https://registry.yarnpkg.com/flatbuffers/-/flatbuffers-1.12.0.tgz#72e87d1726cb1b216e839ef02658aa87dcef68aa"
+  integrity sha512-c7CZADjRcl6j0PlvFy0ZqXQ67qSEZfrVPynmnL+2zPc+NtMvrF8Y0QceMo7QqnSPc7+uWjUIAbvCQ5WIKlMVdQ==
+
 flatted@^2.0.0:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/flatted/-/flatted-2.0.2.tgz#4575b21e2bcee7434aa9be662f4b7b5f9c2b5138"
@@ -18786,6 +19091,11 @@ grid-index@^1.1.0:
   resolved "https://registry.yarnpkg.com/grid-index/-/grid-index-1.1.0.tgz#97f8221edec1026c8377b86446a7c71e79522ea7"
   integrity sha512-HZRwumpOGUrHyxO5bqKZL0B0GlUpwtCAzZ42sgxUPniu33R1LSFH5yrIcBCHjkctCAh3mtWKcKd9J4vDDdeVHA==
 
+guid-typescript@^1.0.9:
+  version "1.0.9"
+  resolved "https://registry.yarnpkg.com/guid-typescript/-/guid-typescript-1.0.9.tgz#e35f77003535b0297ea08548f5ace6adb1480ddc"
+  integrity sha512-Y8T4vYhEfwJOTbouREvG+3XDsjr8E3kIr7uf+JZ0BYloFsttiHU0WfvANVsR7TxNUJa/WpCnw/Ino/p+DeBhBQ==
+
 gunzip-maybe@^1.4.2:
   version "1.4.2"
   resolved "https://registry.yarnpkg.com/gunzip-maybe/-/gunzip-maybe-1.4.2.tgz#b913564ae3be0eda6f3de36464837a9cd94b98ac"
@@ -24729,6 +25039,11 @@ node-addon-api@^2.0.0:
   resolved "https://registry.yarnpkg.com/node-addon-api/-/node-addon-api-2.0.2.tgz#432cfa82962ce494b132e9d72a15b29f71ff5d32"
   integrity sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==
 
+node-addon-api@^6.1.0:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/node-addon-api/-/node-addon-api-6.1.0.tgz#ac8470034e58e67d0c6f1204a18ae6995d9c0d76"
+  integrity sha512-+eawOlIgy680F0kBzPUNFhMZGtJ1YmqM6l4+Crf4IkImjYrO/mqPwRMh352g23uIaQKFItcQ64I7KMaJxHgAVA==
+
 node-datachannel@^0.4.3:
   version "0.4.3"
   resolved "https://registry.yarnpkg.com/node-datachannel/-/node-datachannel-0.4.3.tgz#56a18cc62df4727f4483309b7b0bb86d5173ba27"
@@ -25177,6 +25492,37 @@ onetime@^6.0.0:
   dependencies:
     mimic-fn "^4.0.0"
 
+onnx-proto@^4.0.4:
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/onnx-proto/-/onnx-proto-4.0.4.tgz#2431a25bee25148e915906dda0687aafe3b9e044"
+  integrity sha512-aldMOB3HRoo6q/phyB6QRQxSt895HNNw82BNyZ2CMh4bjeKv7g/c+VpAFtJuEMVfYLMbRx61hbuqnKceLeDcDA==
+  dependencies:
+    protobufjs "^6.8.8"
+
+onnxruntime-common@~1.14.0:
+  version "1.14.0"
+  resolved "https://registry.yarnpkg.com/onnxruntime-common/-/onnxruntime-common-1.14.0.tgz#2bb5dac5261269779aa5fb6536ca379657de8bf6"
+  integrity sha512-3LJpegM2iMNRX2wUmtYfeX/ytfOzNwAWKSq1HbRrKc9+uqG/FsEA0bbKZl1btQeZaXhC26l44NWpNUeXPII7Ew==
+
+onnxruntime-node@1.14.0:
+  version "1.14.0"
+  resolved "https://registry.yarnpkg.com/onnxruntime-node/-/onnxruntime-node-1.14.0.tgz#c4ae6c355cfae7d83abaf36dd39a905c4a010217"
+  integrity sha512-5ba7TWomIV/9b6NH/1x/8QEeowsb+jBEvFzU6z0T4mNsFwdPqXeFUM7uxC6QeSRkEbWu3qEB0VMjrvzN/0S9+w==
+  dependencies:
+    onnxruntime-common "~1.14.0"
+
+onnxruntime-web@1.14.0:
+  version "1.14.0"
+  resolved "https://registry.yarnpkg.com/onnxruntime-web/-/onnxruntime-web-1.14.0.tgz#c8cee538781b1d4c1c6b043934f4a3e6ddf1466e"
+  integrity sha512-Kcqf43UMfW8mCydVGcX9OMXI2VN17c0p6XvR7IPSZzBf/6lteBzXHvcEVWDPmCKuGombl997HgLqj91F11DzXw==
+  dependencies:
+    flatbuffers "^1.12.0"
+    guid-typescript "^1.0.9"
+    long "^4.0.0"
+    onnx-proto "^4.0.4"
+    onnxruntime-common "~1.14.0"
+    platform "^1.3.6"
+
 open@^8.0.4, open@^8.0.9, open@^8.4.0:
   version "8.4.2"
   resolved "https://registry.yarnpkg.com/open/-/open-8.4.2.tgz#5b5ffe2a8f793dcd2aad73e550cb87b59cb084f9"
@@ -25871,7 +26217,7 @@ planar-graph-to-polyline@^1.0.6:
     two-product "^1.0.0"
     uniq "^1.0.0"
 
-platform@^1.3.3, platform@^1.3.4:
+platform@^1.3.3, platform@^1.3.4, platform@^1.3.6:
   version "1.3.6"
   resolved "https://registry.yarnpkg.com/platform/-/platform-1.3.6.tgz#48b4ce983164b209c2d45a107adb31f473a6e7a7"
   integrity sha512-fnWVljUchTro6RiCFvCXBbNhJc2NijN7oIQxbwsyL0buWJPG85v81ehlHI9fXrJsMNgTofEoWIQeClKpgxFLrg==
@@ -26564,6 +26910,24 @@ prebuild-install@^7.0.1:
     tar-fs "^2.0.0"
     tunnel-agent "^0.6.0"
 
+prebuild-install@^7.1.1:
+  version "7.1.2"
+  resolved "https://registry.yarnpkg.com/prebuild-install/-/prebuild-install-7.1.2.tgz#a5fd9986f5a6251fbc47e1e5c65de71e68c0a056"
+  integrity sha512-UnNke3IQb6sgarcZIDU3gbMeTp/9SSU1DAIkil7PrqG1vZlBtY5msYccSKSHDqa3hNg436IXK+SNImReuA1wEQ==
+  dependencies:
+    detect-libc "^2.0.0"
+    expand-template "^2.0.3"
+    github-from-package "0.0.0"
+    minimist "^1.2.3"
+    mkdirp-classic "^0.5.3"
+    napi-build-utils "^1.0.1"
+    node-abi "^3.3.0"
+    pump "^3.0.0"
+    rc "^1.2.7"
+    simple-get "^4.0.0"
+    tar-fs "^2.0.0"
+    tunnel-agent "^0.6.0"
+
 prelude-ls@^1.2.1:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
@@ -27132,6 +27496,11 @@ queue-microtask@^1.2.2, queue-microtask@^1.2.3:
   resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
   integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
 
+queue-tick@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/queue-tick/-/queue-tick-1.0.1.tgz#f6f07ac82c1fd60f82e098b417a80e52f1f4c142"
+  integrity sha512-kJt5qhMxoszgU/62PLP1CJytzd2NKetjSRnyuj31fDd3Rlcz3fzlFdFLD1SItunPwyqEOkca6GbV612BWfaBag==
+
 quick-lru@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-4.0.1.tgz#5b8878f113a58217848c6482026c73e1ba57727f"
@@ -27337,6 +27706,11 @@ react-click-outside@^3.0.1:
   dependencies:
     hoist-non-react-statics "^2.1.1"
 
+react-codemirror2@^7.2.1:
+  version "7.3.0"
+  resolved "https://registry.yarnpkg.com/react-codemirror2/-/react-codemirror2-7.3.0.tgz#c26e9fe655458389c6218496076e4bc7a4c31166"
+  integrity sha512-gCgJPXDX+5iaPolkHAu1YbJ92a2yL7Je4TuyO3QEqOtI/d6mbEk08l0oIm18R4ctuT/Sl87X63xIMBnRQBXYXA==
+
 react-colorful@^5.1.2:
   version "5.6.1"
   resolved "https://registry.yarnpkg.com/react-colorful/-/react-colorful-5.6.1.tgz#7dc2aed2d7c72fac89694e834d179e32f3da563b"
@@ -27983,6 +28357,11 @@ redux-devtools-extension@^2.13.8:
   resolved "https://registry.yarnpkg.com/redux-devtools-extension/-/redux-devtools-extension-2.13.9.tgz#6b764e8028b507adcb75a1cae790f71e6be08ae7"
   integrity sha512-cNJ8Q/EtjhQaZ71c8I9+BPySIBVEKssbPpskBfsXqb8HJ002A3KRVHfeRzwRo6mGPqsm7XuHTqNSNeS1Khig0A==
 
+redux-observable@^3.0.0-rc.2:
+  version "3.0.0-rc.2"
+  resolved "https://registry.yarnpkg.com/redux-observable/-/redux-observable-3.0.0-rc.2.tgz#baef603781c5dabd9ddd70526357076cd5c128a2"
+  integrity sha512-gG/pWIKgSrcTyyavm2so5tc7tuyCQ47p3VdCAG6wt+CV0WGhDr50cMQHLcYKxFZSGgTm19a8ZmyfJGndmGDpYg==
+
 redux-thunk@^2.4.2:
   version "2.4.2"
   resolved "https://registry.yarnpkg.com/redux-thunk/-/redux-thunk-2.4.2.tgz#b9d05d11994b99f7a91ea223e8b04cf0afa5ef3b"
@@ -29194,6 +29573,20 @@ shallowequal@^1.1.0:
   resolved "https://registry.yarnpkg.com/shallowequal/-/shallowequal-1.1.0.tgz#188d521de95b9087404fd4dcb68b13df0ae4e7f8"
   integrity sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ==
 
+sharp@^0.32.0:
+  version "0.32.6"
+  resolved "https://registry.yarnpkg.com/sharp/-/sharp-0.32.6.tgz#6ad30c0b7cd910df65d5f355f774aa4fce45732a"
+  integrity sha512-KyLTWwgcR9Oe4d9HwCwNM2l7+J0dUQwn/yf7S0EnTtb0eVS4RxO0eUSvxPtzT4F3SY+C4K6fqdv/DO27sJ/v/w==
+  dependencies:
+    color "^4.2.3"
+    detect-libc "^2.0.2"
+    node-addon-api "^6.1.0"
+    prebuild-install "^7.1.1"
+    semver "^7.5.4"
+    simple-get "^4.0.1"
+    tar-fs "^3.0.4"
+    tunnel-agent "^0.6.0"
+
 shebang-command@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea"
@@ -29288,7 +29681,7 @@ simple-get@^2.7.0:
     once "^1.3.1"
     simple-concat "^1.0.0"
 
-simple-get@^4.0.0:
+simple-get@^4.0.0, simple-get@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/simple-get/-/simple-get-4.0.1.tgz#4a39db549287c979d352112fa03fd99fd6bc3543"
   integrity sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==
@@ -29826,6 +30219,16 @@ streamsearch@^1.1.0:
   resolved "https://registry.yarnpkg.com/streamsearch/-/streamsearch-1.1.0.tgz#404dd1e2247ca94af554e841a8ef0eaa238da764"
   integrity sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==
 
+streamx@^2.15.0, streamx@^2.16.1:
+  version "2.16.1"
+  resolved "https://registry.yarnpkg.com/streamx/-/streamx-2.16.1.tgz#2b311bd34832f08aa6bb4d6a80297c9caef89614"
+  integrity sha512-m9QYj6WygWyWa3H1YY69amr4nVgy61xfjys7xO7kviL5rfIEc2naf+ewFiOA+aEJD7y0JO3h2GoiUv4TDwEGzQ==
+  dependencies:
+    fast-fifo "^1.1.0"
+    queue-tick "^1.0.1"
+  optionalDependencies:
+    bare-events "^2.2.0"
+
 strict-uri-encode@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz#279b225df1d582b1f54e65addd4352e18faa0713"
@@ -30534,6 +30937,17 @@ tar-fs@^2.0.0, tar-fs@^2.1.1:
     pump "^3.0.0"
     tar-stream "^2.1.4"
 
+tar-fs@^3.0.4:
+  version "3.0.6"
+  resolved "https://registry.yarnpkg.com/tar-fs/-/tar-fs-3.0.6.tgz#eaccd3a67d5672f09ca8e8f9c3d2b89fa173f217"
+  integrity sha512-iokBDQQkUyeXhgPYaZxmczGPhnhXZ0CmrqI+MOb/WFGS9DW5wnfrLgtjUJBvz50vQ3qfRwJ62QVoCFu8mPVu5w==
+  dependencies:
+    pump "^3.0.0"
+    tar-stream "^3.1.5"
+  optionalDependencies:
+    bare-fs "^2.1.1"
+    bare-path "^2.1.0"
+
 tar-stream@^1.5.2:
   version "1.6.2"
   resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-1.6.2.tgz#8ea55dab37972253d9a9af90fdcd559ae435c555"
@@ -30558,6 +30972,15 @@ tar-stream@^2.1.4:
     inherits "^2.0.3"
     readable-stream "^3.1.1"
 
+tar-stream@^3.1.5:
+  version "3.1.7"
+  resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-3.1.7.tgz#24b3fb5eabada19fe7338ed6d26e5f7c482e792b"
+  integrity sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==
+  dependencies:
+    b4a "^1.6.4"
+    fast-fifo "^1.2.0"
+    streamx "^2.15.0"
+
 tar@^4.0.2:
   version "4.4.19"
   resolved "https://registry.yarnpkg.com/tar/-/tar-4.4.19.tgz#2e4d7263df26f2b914dee10c825ab132123742f3"