✨ Add better strategy for wasm loading on worker

2026-01-04 04:18:51 -05:00 · 2025-12-09 20:03:59 +01:00
167 changed files with 13188 additions and 20824 deletions
--- a/.github/workflows/build-tag.yml
+++ b/.github/workflows/build-tag.yml
@@ -11,7 +11,7 @@ jobs:
    secrets: inherit
    with:
      gh_ref: ${{ github.ref_name }}
-      build_wasm: "yes"
+      build_wasm: "no"
      build_storybook: "yes"

  build-docker:
--- a/.gitignore
+++ b/.gitignore
@@ -20,7 +20,6 @@
 .rebel_readline_history
 .repl
 .shadow-cljs
-.pnpm-store/
 /*.jpg
 /*.md
 /*.png
@@ -72,7 +71,6 @@
 /library/target/
 /library/*.zip
 /external
-/penpot-nitrate

 clj-profiler/
 node_modules
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -114,8 +114,6 @@ example. It's still usable as before, we just removed the example.
 - Fix unpublish library modal not scrolling a long file list [Taiga #12285](https://tree.taiga.io/project/penpot/issue/12285)
 - Fix incorrect interaction betwen hower and scroll on assets sidebar [Taiga #12389](https://tree.taiga.io/project/penpot/issue/12389)
 - Fix switch variants with paths [Taiga #12841](https://tree.taiga.io/project/penpot/issue/12841)
- Fix referencing typography tokens on font-family tokens [Taiga #12492](https://tree.taiga.io/project/penpot/issue/12492)
- Fix horizontal scroll on layer panel [Taiga #12843](https://tree.taiga.io/project/penpot/issue/12843)

 ## 2.11.1

--- a/backend/resources/app/onboarding.edn
+++ b/backend/resources/app/onboarding.edn
@@ -3,7 +3,7 @@
  :file-uri "https://github.com/penpot/penpot-files/raw/refs/heads/main/Tokens%20starter%20kit.penpot"}
 {:id "penpot-design-system"
  :name "Penpot Design System | Pencil"
-  :file-uri "https://github.com/penpot/penpot-files/raw/refs/heads/main/Pencil-Penpot-Design-System.penpot"}
+  :file-uri "https://github.com/penpot/penpot-files/raw/refs/heads/main/penpot-app.penpot"}
 {:id "wireframing-kit"
  :name "Wireframe library"
  :file-uri "https://github.com/penpot/penpot-files/raw/refs/heads/main/Wireframing%20kit%20v1.1.penpot"}
--- a/backend/scripts/_env
+++ b/backend/scripts/_env
@@ -36,8 +36,7 @@ export PENPOT_FLAGS="\
       enable-file-validation \
       enable-file-schema-validation \
       enable-redis-cache \
-       enable-subscriptions \
-       enable-nitrate";
+       enable-subscriptions";

 # Default deletion delay for devenv
 export PENPOT_DELETION_DELAY="24h"
@@ -56,8 +55,6 @@ export PENPOT_OBJECTS_STORAGE_BACKEND=s3
 export PENPOT_OBJECTS_STORAGE_S3_ENDPOINT=http://minio:9000
 export PENPOT_OBJECTS_STORAGE_S3_BUCKET=penpot

-export PENPOT_NITRATE_BACKEND_URI=http://localhost:3000
-
 export JAVA_OPTS="\
       -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager \
       -Djdk.attach.allowAttachSelf \
--- a/backend/src/app/config.clj
+++ b/backend/src/app/config.clj
@@ -225,8 +225,6 @@
    [:netty-io-threads {:optional true} ::sm/int]
    [:executor-threads {:optional true} ::sm/int]

-    [:nitrate-backend-uri {:optional true} ::sm/uri]
-
    ;; DEPRECATED
    [:assets-storage-backend {:optional true} :keyword]
    [:storage-assets-fs-directory {:optional true} :string]
--- a/backend/src/app/main.clj
+++ b/backend/src/app/main.clj
@@ -323,7 +323,6 @@
   {::http.client/client (ig/ref ::http.client/client)
    ::db/pool            (ig/ref ::db/pool)
    ::rds/pool           (ig/ref ::rds/pool)
-    :app.nitrate/client (ig/ref :app.nitrate/client)
    ::wrk/executor       (ig/ref ::wrk/netty-executor)
    ::session/manager    (ig/ref ::session/manager)
    ::ldap/provider      (ig/ref ::ldap/provider)
@@ -340,9 +339,6 @@
    ::email/blacklist    (ig/ref ::email/blacklist)
    ::email/whitelist    (ig/ref ::email/whitelist)}

-   :app.nitrate/client
-   {::http.client/client (ig/ref ::http.client/client)}
-
   :app.rpc/management-methods
   {::http.client/client (ig/ref ::http.client/client)
    ::db/pool            (ig/ref ::db/pool)
@@ -352,7 +348,6 @@
    ::sto/storage        (ig/ref ::sto/storage)
    ::mtx/metrics        (ig/ref ::mtx/metrics)
    ::mbus/msgbus        (ig/ref ::mbus/msgbus)
-    :app.nitrate/client (ig/ref :app.nitrate/client)
    ::rds/client         (ig/ref ::rds/client)
    ::setup/props        (ig/ref ::setup/props)}

--- a/backend/src/app/nitrate.clj
+++ b/backend/src/app/nitrate.clj
@@ -1,123 +0,0 @@
-;; This Source Code Form is subject to the terms of the Mozilla Public
-;; License, v. 2.0. If a copy of the MPL was not distributed with this
-;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
-;;
-;; Copyright (c) KALEIDOS INC
-
-(ns app.nitrate
-  "Module that make calls to the external nitrate aplication"
-  (:require
-   [app.common.logging :as l]
-   [app.common.schema :as sm]
-   [app.config :as cf]
-   [app.http.client :as http]
-   [app.rpc :as-alias rpc]
-   [app.setup :as-alias setup]
-   [app.util.json :as json]
-   [clojure.core :as c]
-   [integrant.core :as ig]))
-
-
-(def baseuri (cf/get :nitrate-backend-uri))
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; HELPERS
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn- coercer
-  [schema & {:as opts}]
-  (let [decode-fn (sm/decoder schema sm/json-transformer)
-        check-fn  (sm/check-fn schema opts)]
-    (fn [data]
-      (-> data decode-fn check-fn))))
-
-
-(defn- request-builder
-  [cfg method uri management-key profile-id]
-  (fn []
-    (http/req! cfg {:method method
-                    :headers {"content-type" "application/json"
-                              "accept" "application/json"
-                              "x-shared-key" management-key
-                              "x-profile-id" (str profile-id)}
-                    :uri uri
-                    :version :http1.1})))
-
-
-(defn- with-retries
-  [handler max-retries]
-  (fn []
-    (loop [attempt 1]
-      (let [result (try
-                     (handler)
-                     (catch Exception e
-                       (if (< attempt max-retries)
-                         ::retry
-                         (do
-                           ;; TODO Error handling
-                           (l/error :hint "request fail after multiple retries" :cause e)
-                           nil))))]
-        (if (= result ::retry)
-          (recur (inc attempt))
-          result)))))
-
-
-(defn- with-validate [handler uri schema]
-  (fn []
-    (let [coercer-http   (coercer schema
-                                  :type :validation
-                                  :hint (str "invalid data received calling " uri))]
-      (try
-        (coercer-http (-> (handler) :body json/decode))
-        (catch Exception e
-          ;; TODO Error handling
-          (l/error :hint "error validating json response" :cause e)
-          nil)))))
-
-(defn- request-to-nitrate
-  [{:keys [::management-key] :as cfg} method uri schema {:keys [::rpc/profile-id] :as params}]
-  (let [full-http-call (-> (request-builder cfg method uri management-key profile-id)
-                           (with-retries 3)
-                           (with-validate uri schema))]
-    (full-http-call)))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; API
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn call
-  [cfg method params]
-  (when (contains? cf/flags :nitrate)
-    (let [client (get cfg ::client)
-          method (get client method)]
-      (method params))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(def ^:private schema:organization
-  [:map
-   [:id ::sm/text]
-   [:name ::sm/text]])
-
-
-(defn- get-team-org
-  [cfg {:keys [team-id] :as params}]
-  (request-to-nitrate cfg :get (str baseuri "/api/teams/" (str team-id)) schema:organization params))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; INITIALIZATION
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defmethod ig/init-key ::client
-  [_ {:keys [::setup/props] :as cfg}]
-  (if (contains? cf/flags :nitrate)
-    (let [management-key (or (cf/get :management-api-key)
-                             (get props :management-key))
-          cfg (assoc cfg ::management-key management-key)]
-      {:get-team-org (partial get-team-org cfg)})
-    {}))
-
-(defmethod ig/halt-key! ::client
-  [_ {:keys []}]
-  (do :stuff))
--- a/backend/src/app/rpc.clj
+++ b/backend/src/app/rpc.clj
@@ -296,7 +296,6 @@
  (let [cfg (assoc cfg ::type "management" ::metrics-id :rpc-management-timing)]
    (->> (sv/scan-ns
          'app.rpc.management.subscription
-          'app.rpc.management.nitrate
          'app.rpc.management.exporter)
         (map (partial process-method cfg "management" wrap-management))
         (into {}))))
--- a/backend/src/app/rpc/commands/teams.clj
+++ b/backend/src/app/rpc/commands/teams.clj
@@ -23,7 +23,6 @@
   [app.main :as-alias main]
   [app.media :as media]
   [app.msgbus :as mbus]
-   [app.nitrate :as nitrate]
   [app.rpc :as-alias rpc]
   [app.rpc.commands.profile :as profile]
   [app.rpc.doc :as-alias doc]
@@ -173,12 +172,6 @@
   (map decode-row)
   (map process-permissions)))

-(defn- add-org-to-team
-  [cfg team params]
-  (let [params (assoc (or params {}) :team-id (:id team))
-        org (nitrate/call cfg :get-team-org params)]
-    (assoc team :organization-id (:id org) :organization-name (:name org))))
-
 (defn get-teams
  [conn profile-id]
  (let [profile (profile/get-profile conn profile-id)
@@ -197,9 +190,7 @@
   ::sm/params schema:get-teams}
  [{:keys [::db/pool] :as cfg} {:keys [::rpc/profile-id] :as params}]
  (dm/with-open [conn (db/open pool)]
-    (cond->> (get-teams conn profile-id)
-      (contains? cf/flags :nitrate)
-      (map #(add-org-to-team cfg % params)))))
+    (get-teams conn profile-id)))

 (def ^:private sql:get-owned-teams
  "SELECT t.id, t.name,
--- a/backend/src/app/rpc/management/nitrate.clj
+++ b/backend/src/app/rpc/management/nitrate.clj
@@ -1,112 +0,0 @@
-;; This Source Code Form is subject to the terms of the Mozilla Public
-;; License, v. 2.0. If a copy of the MPL was not distributed with this
-;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
-;;
-;; Copyright (c) KALEIDOS INC
-
-(ns app.rpc.management.nitrate
-  "Internal Nitrate HTTP API.
-       Provides authenticated access to organization management and token validation endpoints.
-       All requests must include a valid shared key token in the `x-shared-key` header, and
-       a cookie `auth-token` with the user token.
-       They will return `401 Unauthorized` if the shared key or user token are invalid."
-  (:require
-   [app.common.schema :as sm]
-   [app.common.uuid :as uuid]
-   [app.config :as cf]
-   [app.db :as db]
-   [app.msgbus :as mbus]
-   [app.rpc :as-alias rpc]
-   [app.rpc.commands.files :as files]
-   [app.rpc.commands.profile :as profile]
-   [app.rpc.doc :as doc]
-   [app.util.services :as sv]))
-
-;; ---- API: authenticate
-(def ^:private schema:profile
-  [:map
-   [:id ::sm/uuid]
-   [:name :string]
-   [:email :string]
-   [:photo-url :string]])
-
-(sv/defmethod ::authenticate
-  "Authenticate an user
-     @api GET /authenticate
-     @returns
-       200 OK: Returns the authenticated user."
-  {::doc/added "2.12"
-   ::sm/result schema:profile}
-  [cfg {:keys [::rpc/profile-id] :as params}]
-  (let [profile    (profile/get-profile cfg profile-id)]
-    {:id (get profile :id)
-     :name (get profile :fullname)
-     :email (get profile :email)
-     :photo-url (files/resolve-public-uri (get profile :photo-id))}))
-
-;; ---- API: get-teams
-
-(def ^:private sql:get-teams
-  "SELECT t.*
-     FROM team AS t
-     JOIN team_profile_rel AS tpr ON t.id = tpr.team_id
-    WHERE tpr.profile_id = ?
-      AND tpr.is_owner = 't'
-      AND t.is_default = 'f'
-      AND t.deleted_at is null;")
-
-(def ^:private schema:team
-  [:map
-   [:id ::sm/uuid]
-   [:name :string]])
-
-(def ^:private schema:get-teams-result
-  [:vector schema:team])
-
-(sv/defmethod ::get-teams
-  "List teams for which current user is owner.
-     @api GET /get-teams
-     @returns
-       200 OK: Returns the list of teams for the user."
-  {::doc/added "2.12"
-   ::sm/result schema:get-teams-result}
-  [cfg {:keys [::rpc/profile-id]}]
-  (when (contains? cf/flags :nitrate)
-    (let [current-user-id (-> (profile/get-profile cfg profile-id) :id)]
-      (->> (db/exec! cfg [sql:get-teams current-user-id])
-           (map #(select-keys % [:id :name]))))))
-
-;; ---- API: notify-team-change
-
-(def ^:private schema:notify-team-change
-  [:map
-   [:id ::sm/uuid]
-   [:organization-id ::sm/text]])
-
-
-(sv/defmethod ::notify-team-change
-  "Notify to Penpot a team change from nitrate
-     @api POST /notify-team-change
-     @returns
-       200 OK"
-  {::doc/added "2.12"
-   ::sm/params schema:notify-team-change
-   ::rpc/auth false}
-  [cfg {:keys [id organization-id organization-name]}]
-  (when (contains? cf/flags :nitrate)
-    (let [msgbus (::mbus/msgbus cfg)]
-      (mbus/pub! msgbus
-                 ;;TODO There is a bug on dashboard with teams notifications.
-                 ;;For now we send it to uuid/zero instead of team-id
-                 :topic uuid/zero
-                 :message {:type :team-org-change
-                           :team-id id
-                           :organization-id organization-id
-                           :organization-name organization-name}))))
-
-
-
-
-
-
-
--- a/common/src/app/common/files/shapes_builder.cljc
+++ b/common/src/app/common/files/shapes_builder.cljc
@@ -82,113 +82,6 @@
 (declare create-svg-children)
 (declare parse-svg-element)

-(defn- process-gradient-stops
-  "Processes gradient stops to extract stop-color and stop-opacity from style attributes
-   and convert them to direct attributes. This ensures stops with style='stop-color:#...;stop-opacity:1'
-   are properly converted to stop-color and stop-opacity attributes."
-  [stops]
-  (mapv (fn [stop]
-          (let [stop-attrs (:attrs stop)
-                stop-style (get stop-attrs :style)
-                ;; Parse style if it's a string using csvg/parse-style utility
-                parsed-style (when (and (string? stop-style) (seq stop-style))
-                               (csvg/parse-style stop-style))
-                ;; Extract stop-color and stop-opacity from style
-                style-stop-color (when parsed-style (:stop-color parsed-style))
-                style-stop-opacity (when parsed-style (:stop-opacity parsed-style))
-                ;; Merge: use direct attributes first, then style values as fallback
-                final-attrs (cond-> stop-attrs
-                              (and style-stop-color (not (contains? stop-attrs :stop-color)))
-                              (assoc :stop-color style-stop-color)
-
-                              (and style-stop-opacity (not (contains? stop-attrs :stop-opacity)))
-                              (assoc :stop-opacity style-stop-opacity)
-
-                              ;; Remove style attribute if we've extracted its values
-                              (or style-stop-color style-stop-opacity)
-                              (dissoc :style))]
-            (assoc stop :attrs final-attrs)))
-        stops))
-
-(defn- resolve-gradient-href
-  "Resolves xlink:href references in gradients by merging the referenced gradient's
-   stops and attributes with the referencing gradient. This ensures gradients that
-   reference other gradients (like linearGradient3550 referencing linearGradient3536)
-   inherit the stops from the base gradient.
-   
-   According to SVG spec, when a gradient has xlink:href:
-   - It inherits all attributes from the referenced gradient
-   - It inherits all stops from the referenced gradient
-   - The referencing gradient's attributes override the base ones
-   - If the referencing gradient has stops, they replace the base stops
-   
-   Returns the defs map with all gradient href references resolved."
-  [defs]
-  (letfn [(resolve-gradient [gradient-id gradient-node defs visited]
-            (if (contains? visited gradient-id)
-              (do
-                #?(:cljs (js/console.warn "[resolve-gradient] Circular reference detected for" gradient-id)
-                   :clj nil)
-                gradient-node)  ;; Avoid circular references
-              (let [attrs (:attrs gradient-node)
-                    href-id (or (:href attrs) (:xlink:href attrs))
-                    href-id (when (and (string? href-id) (pos? (count href-id)))
-                              (subs href-id 1))  ;; Remove leading #
-
-                    base-gradient (when (and href-id (contains? defs href-id))
-                                    (get defs href-id))
-
-                    resolved-base (when base-gradient (resolve-gradient href-id base-gradient defs (conj visited gradient-id)))]
-
-                (if resolved-base
-                  ;; Merge: base gradient attributes + referencing gradient attributes
-                  ;; Use referencing gradient's stops if present, otherwise use base stops
-                  (let [base-attrs (:attrs resolved-base)
-                        ref-attrs (:attrs gradient-node)
-
-                        ;; Start with base attributes (without id), then merge with ref attributes
-                        ;; This ensures ref attributes override base ones
-                        base-attrs-clean (dissoc base-attrs :id)
-                        ref-attrs-clean (dissoc ref-attrs :href :xlink:href :id)
-
-                        ;; Special handling for gradientTransform: if both have it, combine them
-                        base-transform (get base-attrs :gradientTransform)
-                        ref-transform (get ref-attrs :gradientTransform)
-                        combined-transform (cond
-                                             (and base-transform ref-transform)
-                                             (str base-transform " " ref-transform)  ;; Apply base first, then ref
-                                             :else (or ref-transform base-transform))
-
-                        ;; Merge attributes: base first, then ref (ref overrides)
-                        merged-attrs (-> (d/deep-merge base-attrs-clean ref-attrs-clean)
-                                         (cond-> combined-transform
-                                           (assoc :gradientTransform combined-transform)))
-
-                        ;; If referencing gradient has content (stops), use it; otherwise use base content
-                        final-content (if (seq (:content gradient-node))
-                                        (:content gradient-node)
-                                        (:content resolved-base))
-
-                        ;; Process stops to extract stop-color and stop-opacity from style attributes
-                        processed-content (process-gradient-stops final-content)
-
-                        result {:tag (:tag gradient-node)
-                                :attrs (assoc merged-attrs :id gradient-id)
-                                :content processed-content}]
-                    result)
-                  ;; Process stops even for gradients without references to extract style attributes
-                  (let [processed-content (process-gradient-stops (:content gradient-node))]
-                    (assoc gradient-node :content processed-content))))))]
-    (let [gradient-tags #{:linearGradient :radialGradient}
-          result (reduce-kv
-                  (fn [acc id node]
-                    (if (contains? gradient-tags (:tag node))
-                      (assoc acc id (resolve-gradient id node defs #{}))
-                      (assoc acc id node)))
-                  {}
-                  defs)]
-      result)))
-
 (defn create-svg-shapes
  ([svg-data pos objects frame-id parent-id selected center?]
   (create-svg-shapes (uuid/next) svg-data pos objects frame-id parent-id selected center?))
@@ -219,9 +112,6 @@
             (csvg/fix-percents)
             (csvg/extract-defs))

-         ;; Resolve gradient href references in all defs before processing shapes
-         def-nodes (resolve-gradient-href def-nodes)
-
         ;; In penpot groups have the size of their children. To
         ;; respect the imported svg size and empty space let's create
         ;; a transparent shape as background to respect the imported
@@ -252,23 +142,12 @@
         (reduce (partial create-svg-children objects selected frame-id root-id svg-data)
                 [unames []]
                 (d/enumerate (->> (:content svg-data)
-                                   (mapv #(csvg/inherit-attributes root-attrs %)))))
+                                   (mapv #(csvg/inherit-attributes root-attrs %)))))]

-         ;; Collect all defs from children and merge into root shape
-         all-defs-from-children (reduce (fn [acc child]
-                                          (if-let [child-defs (:svg-defs child)]
-                                            (merge acc child-defs)
-                                            acc))
-                                        {}
-                                        children)
-
-         ;; Merge defs from svg-data and children into root shape
-         root-shape-with-defs (assoc root-shape :svg-defs (merge def-nodes all-defs-from-children))]
-
-     [root-shape-with-defs children])))
+     [root-shape children])))

 (defn create-raw-svg
-  [name frame-id {:keys [x y width height offset-x offset-y defs] :as svg-data} {:keys [attrs] :as data}]
+  [name frame-id {:keys [x y width height offset-x offset-y]} {:keys [attrs] :as data}]
  (let [props (csvg/attrs->props attrs)
        vbox  (grc/make-rect offset-x offset-y width height)]
    (cts/setup-shape
@@ -281,11 +160,10 @@
      :y y
      :content data
      :svg-attrs props
-      :svg-viewbox vbox
-      :svg-defs defs})))
+      :svg-viewbox vbox})))

 (defn create-svg-root
-  [id frame-id parent-id {:keys [name x y width height offset-x offset-y attrs defs] :as svg-data}]
+  [id frame-id parent-id {:keys [name x y width height offset-x offset-y attrs]}]
  (let [props (-> (dissoc attrs :viewBox :view-box :xmlns)
                  (d/without-keys csvg/inheritable-props)
                  (csvg/attrs->props))]
@@ -299,8 +177,7 @@
      :height height
      :x (+ x offset-x)
      :y (+ y offset-y)
-      :svg-attrs props
-      :svg-defs defs})))
+      :svg-attrs props})))

 (defn create-svg-children
  [objects selected frame-id parent-id svg-data [unames children] [_index svg-element]]
@@ -321,7 +198,7 @@


 (defn create-group
-  [name frame-id {:keys [x y width height offset-x offset-y defs] :as svg-data} {:keys [attrs]}]
+  [name frame-id {:keys [x y width height offset-x offset-y] :as svg-data} {:keys [attrs]}]
  (let [transform (csvg/parse-transform (:transform attrs))
        attrs     (-> attrs
                      (d/without-keys csvg/inheritable-props)
@@ -337,8 +214,7 @@
      :height height
      :svg-transform transform
      :svg-attrs attrs
-      :svg-viewbox vbox
-      :svg-defs defs})))
+      :svg-viewbox vbox})))

 (defn create-path-shape [name frame-id svg-data {:keys [attrs] :as data}]
  (when (and (contains? attrs :d) (seq (:d attrs)))
@@ -647,21 +523,6 @@
                 :else (dm/str tag))]
    (dm/str "svg-" suffix)))

-(defn- filter-valid-def-references
-  "Filters out false positive references that are not valid def IDs.
-   Filters out:
-   - Colors in style attributes (hex colors like #f9dd67)
-   - Style fragments that contain CSS keywords (like stop-opacity)
-   - References that don't exist in defs"
-  [ref-ids defs]
-  (let [is-style-fragment? (fn [ref-id]
-                             (or (clr/hex-color-string? (str "#" ref-id))
-                                 (str/includes? ref-id ";")  ;; Contains CSS separator
-                                 (str/includes? ref-id "stop-opacity")  ;; CSS keyword
-                                 (str/includes? ref-id "stop-color")))]  ;; CSS keyword
-    (->> ref-ids
-         (remove is-style-fragment?)  ;; Filter style fragments and hex colors
-         (filter #(contains? defs %)))))  ;; Only existing defs

 (defn parse-svg-element
  [frame-id svg-data {:keys [tag attrs hidden] :as element} unames]
@@ -673,11 +534,7 @@
  (let [name         (or (:id attrs) (tag->name tag))
        att-refs     (csvg/find-attr-references attrs)
        defs         (get svg-data :defs)
-        valid-refs   (filter-valid-def-references att-refs defs)
-        all-refs     (csvg/find-def-references defs valid-refs)
-        ;; Filter the final result to ensure all references are valid defs
-        ;; This prevents false positives from style attributes in gradient stops
-        references   (filter-valid-def-references all-refs defs)
+        references   (csvg/find-def-references defs att-refs)

        href-id      (or (:href attrs) (:xlink:href attrs) " ")
        href-id      (if (and (string? href-id)
--- a/common/src/app/common/flags.cljc
+++ b/common/src/app/common/flags.cljc
@@ -145,10 +145,7 @@

    ;; A temporal flag, enables backend code use more extensivelly
    ;; redis for caching data
-    :redis-cache
-
-    ;; Activates the nitrate module
-    :nitrate})
+    :redis-cache})

 (def all-flags
  (set/union email login varia))
--- a/common/src/app/common/path_names.cljc
+++ b/common/src/app/common/path_names.cljc
@@ -132,94 +132,3 @@ Some naming conventions:
  (if-let [last-period (str/last-index-of s ".")]
    [(subs s 0 (inc last-period)) (subs s (inc last-period))]
    [s ""]))
-
-;; Tree building functions --------------------------------------------------
-
-"Build tree structure from flat list of paths"
-
-"`build-tree-root` is the main function to build the tree."
-
-"Receives a list of segments with 'name' properties representing paths,
-   and a separator string."
-"E.g segments = [{... :name 'one/two/three'} {... :name 'one/two/four'} {... :name 'one/five'}]"
-
-"Transforms into a tree structure like:
-   [{:name 'one'
-     :path 'one'
-     :depth 0
-     :leaf nil
-     :children-fn (fn [] [{:name 'two'
-                           :path 'one.two'
-                           :depth 1
-                           :leaf nil
-                           :children-fn (fn [] [{... :name 'three'} {... :name 'four'}])}
-                          {:name 'five'
-                           :path 'one.five'
-                           :depth 1
-                           :leaf {... :name 'five'}
-                           ...}])}]"
-
-(defn- sort-by-children
-  "Sorts segments so that those with children come first."
-  [segments separator]
-  (sort-by (fn [segment]
-             (let [path (split-path (:name segment) :separator separator)
-                   path-length (count path)]
-               (if (= path-length 1)
-                 1
-                 0)))
-           segments))
-
-(defn- group-by-first-segment
-  "Groups segments by their first path segment and update segment name."
-  [segments separator]
-  (reduce (fn [acc segment]
-            (let [[first-segment & remaining-segments] (split-path (:name segment) :separator separator)
-                  rest-path (when (seq remaining-segments) (join-path remaining-segments :separator separator :with-spaces? false))]
-              (update acc first-segment (fnil conj [])
-                      (if rest-path
-                        (assoc segment :name rest-path)
-                        segment))))
-          {}
-          segments))
-
-(defn- sort-and-group-segments
-  "Sorts elements and groups them by their first path segment."
-  [segments separator]
-  (let [sorted  (sort-by-children segments separator)
-        grouped (group-by-first-segment sorted separator)]
-    grouped))
-
-(defn- build-tree-node
-  "Builds a single tree node with lazy children."
-  [segment-name remaining-segments separator parent-path depth]
-  (let [current-path (if parent-path
-                       (str parent-path "." segment-name)
-                       segment-name)
-
-        is-leaf? (and (seq remaining-segments)
-                      (every? (fn [segment]
-                                (let [remaining-segment-name (first (split-path (:name segment) :separator separator))]
-                                  (= segment-name remaining-segment-name)))
-                              remaining-segments))
-
-        leaf-segment (when is-leaf? (first remaining-segments))
-        node {:name segment-name
-              :path current-path
-              :depth depth
-              :leaf leaf-segment
-              :children-fn (when-not is-leaf?
-                             (fn []
-                               (let [grouped-elements (sort-and-group-segments remaining-segments separator)]
-                                 (mapv (fn [[child-segment-name remaining-child-segments]]
-                                         (build-tree-node child-segment-name remaining-child-segments separator current-path (inc depth)))
-                                       grouped-elements))))}]
-    node))
-
-(defn build-tree-root
-  "Builds the root level of the tree."
-  [segments separator]
-  (let [grouped-elements (sort-and-group-segments segments separator)]
-    (mapv (fn [[segment-name remaining-segments]]
-            (build-tree-node segment-name remaining-segments separator nil 0))
-          grouped-elements)))
--- a/common/src/app/common/svg.cljc
+++ b/common/src/app/common/svg.cljc
@@ -546,19 +546,9 @@
           filter-values)))

 (defn extract-ids [val]
-  ;; Extract referenced ids from string values like "url(#myId)".
-  ;; Non-string values (maps, numbers, nil, etc.) return an empty seq
-  ;; to avoid re-seq type errors when attributes carry nested structures.
-  (cond
-    (string? val)
+  (when (some? val)
    (->> (re-seq xml-id-regex val)
-         (mapv second))
-
-    (sequential? val)
-    (mapcat extract-ids val)
-
-    :else
-    []))
+         (mapv second))))

 (defn fix-dot-number
  "Fixes decimal numbers starting in dot but without leading 0"
--- a/common/src/app/common/types/path.cljc
+++ b/common/src/app/common/types/path.cljc
@@ -234,15 +234,16 @@
  "Calculate the boolean content from shape and objects. Returns a
  packed PathData instance"
  [shape objects]
-  (let [content (calc-bool-content* shape objects)]
+  (let [content (if (fn? wasm:calc-bool-content)
+                  (wasm:calc-bool-content (get shape :bool-type)
+                                          (get shape :shapes))
+                  (calc-bool-content* shape objects))]
    (impl/path-data content)))

 (defn update-bool-shape
  "Calculates the selrect+points for the boolean shape"
  [shape objects]
-  (let [content (if (fn? wasm:calc-bool-content)
-                  (wasm:calc-bool-content shape objects)
-                  (calc-bool-content shape objects))
+  (let [content (calc-bool-content shape objects)
        shape   (assoc shape :content content)]
    (update-geometry shape)))

--- a/docker/devenv/files/start-tmux.sh
+++ b/docker/devenv/files/start-tmux.sh
@@ -50,9 +50,4 @@ tmux select-window -t penpot:4
 tmux send-keys -t penpot 'cd penpot/backend' enter C-l
 tmux send-keys -t penpot './scripts/start-dev' enter

-tmux new-window -t penpot:5 -n 'nitrate'
-tmux select-window -t penpot:5
-tmux send-keys -t penpot 'cd penpot/penpot-nitrate' enter C-l
-tmux send-keys -t penpot 'pnpm dev --host' enter
-
 tmux -2 attach-session -t penpot
--- a/docker/images/files/nginx-entrypoint.sh
+++ b/docker/images/files/nginx-entrypoint.sh
@@ -29,9 +29,8 @@ update_flags /var/www/app/js/config.js

 export PENPOT_BACKEND_URI=${PENPOT_BACKEND_URI:-http://penpot-backend:6060}
 export PENPOT_EXPORTER_URI=${PENPOT_EXPORTER_URI:-http://penpot-exporter:6061}
-export PENPOT_NITRATE_URI=${PENPOT_NITRATE_URI:-http://penpot-nitrate:3000}
 export PENPOT_HTTP_SERVER_MAX_MULTIPART_BODY_SIZE=${PENPOT_HTTP_SERVER_MAX_MULTIPART_BODY_SIZE:-367001600} # Default to 350MiB
-envsubst "\$PENPOT_BACKEND_URI,\$PENPOT_EXPORTER_URI,\$PENPOT_NITRATE_URI,\$PENPOT_HTTP_SERVER_MAX_MULTIPART_BODY_SIZE" \
+envsubst "\$PENPOT_BACKEND_URI,\$PENPOT_EXPORTER_URI,\$PENPOT_HTTP_SERVER_MAX_MULTIPART_BODY_SIZE" \
         < /tmp/nginx.conf.template > /etc/nginx/nginx.conf

 PENPOT_DEFAULT_INTERNAL_RESOLVER="$(awk 'BEGIN{ORS=" "} $1=="nameserver" { sub(/%.*$/,"",$2); print ($2 ~ ":")? "["$2"]": $2}' /etc/resolv.conf)"
--- a/docker/images/files/nginx.conf.template
+++ b/docker/images/files/nginx.conf.template
@@ -139,14 +139,6 @@ http {
            proxy_pass $PENPOT_BACKEND_URI/ws/notifications;
        }

-        location /control-center {
-            proxy_http_version 1.1;
-            proxy_set_header Host $http_host;
-            proxy_set_header X-Real-IP $http_cf_connecting_ip;
-            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-            proxy_pass $PENPOT_NITRATE_URI$request_uri;
-        }
-
        include /etc/nginx/overrides/server.d/*.conf;

        location / {
--- a/exporter/package.json
+++ b/exporter/package.json
@@ -21,7 +21,6 @@
    "raw-body": "^3.0.1",
    "source-map-support": "^0.5.21",
    "svgo": "penpot/svgo#v3.1",
-    "undici": "^7.16.0",
    "xml-js": "^1.6.11",
    "xregexp": "^5.1.2"
  },
--- a/exporter/scripts/wait-and-start.sh
+++ b/exporter/scripts/wait-and-start.sh
@@ -7,4 +7,5 @@ bb -i '(babashka.wait/wait-for-port "localhost" 9630)';
 bb -i '(babashka.wait/wait-for-path "target/app.js")';
 sleep 2;

+export NODE_TLS_REJECT_UNAUTHORIZED=0
 exec node target/app.js
--- a/exporter/src/app/handlers/export_shapes.cljs
+++ b/exporter/src/app/handlers/export_shapes.cljs
@@ -107,12 +107,12 @@
                                    :on-progress on-progress)

        append      (fn [{:keys [filename path] :as resource}]
-                      (rsc/add-to-zip zip path (str/replace filename sanitize-file-regex "_")))
+                      (rsc/add-to-zip! zip path (str/replace filename sanitize-file-regex "_")))

        proc        (->> exports
                         (map (fn [export] (rd/render export append)))
                         (p/all)
-                         (p/mcat (fn [_] (rsc/close-zip zip)))
+                         (p/fnly (fn [_] (.finalize zip)))
                         (p/fmap (constantly resource))
                         (p/mcat (partial rsc/upload-resource auth-token))
                         (p/fmap (fn [resource]
--- a/exporter/src/app/handlers/resources.cljs
+++ b/exporter/src/app/handlers/resources.cljs
@@ -11,7 +11,6 @@
   ["node:fs" :as fs]
   ["node:fs/promises" :as fsp]
   ["node:path" :as path]
-   ["undici" :as http]
   [app.common.exceptions :as ex]
   [app.common.transit :as t]
   [app.common.uri :as u]
@@ -54,40 +53,30 @@
    (.pipe zip out)
    zip))

-(defn add-to-zip
+(defn add-to-zip!
  [zip path name]
  (.file ^js zip path #js {:name name}))

-(defn close-zip
+(defn close-zip!
  [zip]
-  (p/create (fn [resolve]
-              (.on ^js zip "close" resolve)
-              (.finalize ^js zip))))
+  (.finalize ^js zip))

 (defn upload-resource
  [auth-token resource]
  (->> (fsp/readFile (:path resource))
       (p/fmap (fn [buffer]
-                 (js/console.log buffer)
                 (new js/Blob #js [buffer] #js {:type (:mtype resource)})))
       (p/mcat (fn [blob]
-                 (let [fdata  (new http/FormData)
-                       agent  (new http/Agent #js {:connect #js {:rejectUnauthorized false}})
-                       headers #js {"X-Shared-Key" cf/management-key
-                                    "Authorization" (str "Bearer " auth-token)}
-
-                       request #js {:headers headers
-                                    :method "POST"
-                                    :body fdata
-                                    :dispatcher agent}
-                       uri     (-> (cf/get :public-uri)
-                                   (u/ensure-path-slash)
-                                   (u/join "api/management/methods/upload-tempfile")
-                                   (str))]
-
+                 (let [fdata (new js/FormData)
+                       uri   (-> (cf/get :public-uri)
+                                 (u/ensure-path-slash)
+                                 (u/join "api/management/methods/upload-tempfile")
+                                 (str))]
                   (.append fdata "content" blob (:filename resource))
-                   (http/fetch uri request))))
-
+                   (js/fetch uri #js {:headers #js {"X-Shared-Key" cf/management-key
+                                                    "Authorization" (str "Bearer " auth-token)}
+                                      :method "POST"
+                                      :body fdata}))))
       (p/mcat (fn [response]
                 (if (not= (.-status response) 200)
                   (ex/raise :type :internal
--- a/exporter/src/app/util/shell.cljs
+++ b/exporter/src/app/util/shell.cljs
@@ -75,8 +75,7 @@
  [path]
  (->> (.stat fs/promises path)
       (p/fmap (fn [data]
-                 {:path path
-                  :created-at (inst-ms (.-ctime ^js data))
+                 {:created-at (inst-ms (.-ctime ^js data))
                  :size (.-size data)}))
       (p/merr (fn [_cause]
                 (p/resolved nil)))))
--- a/exporter/yarn.lock
+++ b/exporter/yarn.lock
@@ -582,7 +582,6 @@ __metadata:
    raw-body: "npm:^3.0.1"
    source-map-support: "npm:^0.5.21"
    svgo: "penpot/svgo#v3.1"
-    undici: "npm:^7.16.0"
    ws: "npm:^8.18.3"
    xml-js: "npm:^1.6.11"
    xregexp: "npm:^5.1.2"
@@ -1514,13 +1513,6 @@ __metadata:
  languageName: node
  linkType: hard

-"undici@npm:^7.16.0":
-  version: 7.16.0
-  resolution: "undici@npm:7.16.0"
-  checksum: 10c0/efd867792e9f233facf9efa0a087e2d9c3e4415c0b234061b9b40307ca4fa01d945fee4d43c7b564e1b80e0d519bcc682f9f6e0de13c717146c00a80e2f1fb0f
-  languageName: node
-  linkType: hard
-
 "unique-filename@npm:^4.0.0":
  version: 4.0.0
  resolution: "unique-filename@npm:4.0.0"
--- a/frontend/deps.edn
+++ b/frontend/deps.edn
@@ -50,8 +50,5 @@

  :shadow-cljs
  {:main-opts ["-m" "shadow.cljs.devtools.cli"]
-   :jvm-opts ["--sun-misc-unsafe-memory-access=allow"
-              "-Dpenpot.wasm.profile-marks=true"
-              "-XX:+UnlockExperimentalVMOptions"
-              "-XX:CompileCommand=blackhole,criterium.blackhole.Blackhole::consume"]}
+   :jvm-opts ["--sun-misc-unsafe-memory-access=allow" "-Dpenpot.wasm.profile-marks=true"]}
  }}
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -32,8 +32,8 @@
    "e2e:server": "node ./scripts/e2e-server.js",
    "fmt:clj": "cljfmt fix --parallel=true src/ test/",
    "fmt:clj:check": "cljfmt check --parallel=false src/ test/",
-    "fmt:js": "yarn run prettier -c src/**/*.stories.jsx -c playwright/**/*.js -c scripts/**/*.js -c text-editor/**/*.js -w",
-    "fmt:js:check": "yarn run prettier -c src/**/*.stories.jsx -c playwright/**/*.js -c scripts/**/*.js text-editor/**/*.js",
+    "fmt:js": "yarn run prettier -c src/**/*.stories.jsx -c playwright/**/*.js -c scripts/**/*.js -w",
+    "fmt:js:check": "yarn run prettier -c src/**/*.stories.jsx -c playwright/**/*.js -c scripts/**/*.js",
    "lint:clj": "clj-kondo --parallel --lint src/",
    "lint:scss": "yarn run prettier -c resources/styles -c src/**/*.scss",
    "lint:scss:fix": "yarn run prettier -c resources/styles -c src/**/*.scss -w",
@@ -106,7 +106,7 @@
    "@penpot/hljs": "portal:./vendor/hljs",
    "@penpot/mousetrap": "portal:./vendor/mousetrap",
    "@penpot/plugins-runtime": "1.3.2",
-    "@penpot/svgo": "penpot/svgo#v3.2",
+    "@penpot/svgo": "penpot/svgo#v3.1",
    "@penpot/text-editor": "portal:./text-editor",
    "@tokens-studio/sd-transforms": "1.2.11",
    "@zip.js/zip.js": "patch:@zip.js/zip.js@npm%3A2.7.60#~/.yarn/patches/@zip.js-zip.js-npm-2.7.60-b6b814410b.patch",
--- a/frontend/playwright/data/text-editor/get-file-blank.json
+++ b/frontend/playwright/data/text-editor/get-file-blank.json
@@ -1,58 +0,0 @@
-{
-  "~:features": {
-    "~#set": [
-      "layout/grid",
-      "styles/v2",
-      "fdata/pointer-map",
-      "fdata/objects-map",
-      "components/v2",
-      "fdata/shape-data-type"
-    ]
-  },
-  "~:permissions": {
-    "~:type": "~:membership",
-    "~:is-owner": true,
-    "~:is-admin": true,
-    "~:can-edit": true,
-    "~:can-read": true,
-    "~:is-logged": true
-  },
-  "~:has-media-trimmed": false,
-  "~:comment-thread-seqn": 0,
-  "~:name": "New File 1",
-  "~:revn": 11,
-  "~:modified-at": "~m1713873823633",
-  "~:id": "~uc7ce0794-0992-8105-8004-38f280443849",
-  "~:is-shared": false,
-  "~:version": 46,
-  "~:project-id": "~uc7ce0794-0992-8105-8004-38e630f7920b",
-  "~:created-at": "~m1713536343369",
-  "~:data": {
-    "~:pages": [
-      "~u66697432-c33d-8055-8006-2c62cc084cad"
-    ],
-    "~:pages-index": {
-      "~u66697432-c33d-8055-8006-2c62cc084cad": {
-        "~#penpot/pointer": [
-          "~ude58c8f6-c5c2-8196-8004-3df9e2e52d88",
-          {
-            "~:created-at": "~m1713873823636"
-          }
-        ]
-      }
-    },
-    "~:id": "~uc7ce0794-0992-8105-8004-38f280443849",
-    "~:options": {
-      "~:components-v2": true
-    },
-    "~:recent-colors": [
-      {
-        "~:color": "#0000ff",
-        "~:opacity": 1,
-        "~:id": null,
-        "~:file-id": null,
-        "~:image": null
-      }
-    ]
-  }
-}
--- a/frontend/playwright/data/text-editor/get-file-lorem-ipsum.json
+++ b/frontend/playwright/data/text-editor/get-file-lorem-ipsum.json
@@ -1,345 +0,0 @@
-{
-  "~:features": {
-    "~#set": [
-      "fdata/path-data",
-      "plugins/runtime",
-      "design-tokens/v1",
-      "layout/grid",
-      "styles/v2",
-      "fdata/pointer-map",
-      "fdata/objects-map",
-      "components/v2",
-      "fdata/shape-data-type",
-      "text-editor/v2"
-    ]
-  },
-  "~:team-id": "~u9e6e22b2-db76-81d6-8006-75d7cdbb8bad",
-  "~:permissions": {
-    "~:type": "~:membership",
-    "~:is-owner": true,
-    "~:is-admin": true,
-    "~:can-edit": true,
-    "~:can-read": true,
-    "~:is-logged": true
-  },
-  "~:has-media-trimmed": false,
-  "~:comment-thread-seqn": 0,
-  "~:name": "Bug 11552",
-  "~:revn": 3,
-  "~:modified-at": "~m1753957736516",
-  "~:vern": 0,
-  "~:id": "~u238a17e0-75ff-8075-8006-934586ea2230",
-  "~:is-shared": false,
-  "~:migrations": {
-    "~#ordered-set": [
-      "legacy-2",
-      "legacy-3",
-      "legacy-5",
-      "legacy-6",
-      "legacy-7",
-      "legacy-8",
-      "legacy-9",
-      "legacy-10",
-      "legacy-11",
-      "legacy-12",
-      "legacy-13",
-      "legacy-14",
-      "legacy-16",
-      "legacy-17",
-      "legacy-18",
-      "legacy-19",
-      "legacy-25",
-      "legacy-26",
-      "legacy-27",
-      "legacy-28",
-      "legacy-29",
-      "legacy-31",
-      "legacy-32",
-      "legacy-33",
-      "legacy-34",
-      "legacy-36",
-      "legacy-37",
-      "legacy-38",
-      "legacy-39",
-      "legacy-40",
-      "legacy-41",
-      "legacy-42",
-      "legacy-43",
-      "legacy-44",
-      "legacy-45",
-      "legacy-46",
-      "legacy-47",
-      "legacy-48",
-      "legacy-49",
-      "legacy-50",
-      "legacy-51",
-      "legacy-52",
-      "legacy-53",
-      "legacy-54",
-      "legacy-55",
-      "legacy-56",
-      "legacy-57",
-      "legacy-59",
-      "legacy-62",
-      "legacy-65",
-      "legacy-66",
-      "legacy-67",
-      "0001-remove-tokens-from-groups",
-      "0002-normalize-bool-content-v2",
-      "0002-clean-shape-interactions",
-      "0003-fix-root-shape",
-      "0003-convert-path-content-v2",
-      "0004-clean-shadow-color",
-      "0005-deprecate-image-type",
-      "0006-fix-old-texts-fills",
-      "0007-clear-invalid-strokes-and-fills-v2",
-      "0008-fix-library-colors-v4",
-      "0009-clean-library-colors",
-      "0009-add-partial-text-touched-flags"
-    ]
-  },
-  "~:version": 67,
-  "~:project-id": "~u9e6e22b2-db76-81d6-8006-75d7cdc30669",
-  "~:created-at": "~m1753957644225",
-  "~:data": {
-    "~:pages": ["~u238a17e0-75ff-8075-8006-934586ea2231"],
-    "~:pages-index": {
-      "~u238a17e0-75ff-8075-8006-934586ea2231": {
-        "~:objects": {
-          "~u00000000-0000-0000-0000-000000000000": {
-            "~#shape": {
-              "~:y": 0,
-              "~:hide-fill-on-export": false,
-              "~:transform": {
-                "~#matrix": {
-                  "~:a": 1.0,
-                  "~:b": 0.0,
-                  "~:c": 0.0,
-                  "~:d": 1.0,
-                  "~:e": 0.0,
-                  "~:f": 0.0
-                }
-              },
-              "~:rotation": 0,
-              "~:name": "Root Frame",
-              "~:width": 0.01,
-              "~:type": "~:frame",
-              "~:points": [
-                {
-                  "~#point": {
-                    "~:x": 0.0,
-                    "~:y": 0.0
-                  }
-                },
-                {
-                  "~#point": {
-                    "~:x": 0.01,
-                    "~:y": 0.0
-                  }
-                },
-                {
-                  "~#point": {
-                    "~:x": 0.01,
-                    "~:y": 0.01
-                  }
-                },
-                {
-                  "~#point": {
-                    "~:x": 0.0,
-                    "~:y": 0.01
-                  }
-                }
-              ],
-              "~:r2": 0,
-              "~:proportion-lock": false,
-              "~:transform-inverse": {
-                "~#matrix": {
-                  "~:a": 1.0,
-                  "~:b": 0.0,
-                  "~:c": 0.0,
-                  "~:d": 1.0,
-                  "~:e": 0.0,
-                  "~:f": 0.0
-                }
-              },
-              "~:r3": 0,
-              "~:r1": 0,
-              "~:id": "~u00000000-0000-0000-0000-000000000000",
-              "~:parent-id": "~u00000000-0000-0000-0000-000000000000",
-              "~:frame-id": "~u00000000-0000-0000-0000-000000000000",
-              "~:strokes": [],
-              "~:x": 0,
-              "~:proportion": 1.0,
-              "~:r4": 0,
-              "~:selrect": {
-                "~#rect": {
-                  "~:x": 0,
-                  "~:y": 0,
-                  "~:width": 0.01,
-                  "~:height": 0.01,
-                  "~:x1": 0,
-                  "~:y1": 0,
-                  "~:x2": 0.01,
-                  "~:y2": 0.01
-                }
-              },
-              "~:fills": [
-                {
-                  "~:fill-color": "#FFFFFF",
-                  "~:fill-opacity": 1
-                }
-              ],
-              "~:flip-x": null,
-              "~:height": 0.01,
-              "~:flip-y": null,
-              "~:shapes": ["~ucc6f0580-449c-8019-8006-9345db077fa0"]
-            }
-          },
-          "~ucc6f0580-449c-8019-8006-9345db077fa0": {
-            "~#shape": {
-              "~:y": 438,
-              "~:transform": {
-                "~#matrix": {
-                  "~:a": 1.0,
-                  "~:b": 0.0,
-                  "~:c": 0.0,
-                  "~:d": 1.0,
-                  "~:e": 0.0,
-                  "~:f": 0.0
-                }
-              },
-              "~:rotation": 0,
-              "~:grow-type": "~:auto-width",
-              "~:content": {
-                "~:type": "root",
-                "~:key": "1s4am1jl24s",
-                "~:children": [
-                  {
-                    "~:type": "paragraph-set",
-                    "~:children": [
-                      {
-                        "~:line-height": "1.2",
-                        "~:font-style": "normal",
-                        "~:children": [
-                          {
-                            "~:line-height": "1.2",
-                            "~:font-style": "normal",
-                            "~:typography-ref-id": null,
-                            "~:text-transform": "none",
-                            "~:font-id": "sourcesanspro",
-                            "~:key": "13p0zwl2yhc",
-                            "~:font-size": "14",
-                            "~:font-weight": "400",
-                            "~:typography-ref-file": null,
-                            "~:font-variant-id": "regular",
-                            "~:text-decoration": "none",
-                            "~:letter-spacing": "0",
-                            "~:fills": [
-                              {
-                                "~:fill-color": "#000000",
-                                "~:fill-opacity": 1
-                              }
-                            ],
-                            "~:font-family": "sourcesanspro",
-                            "~:text": "Lorem ipsum"
-                          }
-                        ],
-                        "~:typography-ref-id": null,
-                        "~:text-transform": "none",
-                        "~:text-align": "left",
-                        "~:font-id": "sourcesanspro",
-                        "~:key": "20hf3kmyoub",
-                        "~:font-size": "14",
-                        "~:font-weight": "400",
-                        "~:typography-ref-file": null,
-                        "~:text-direction": "ltr",
-                        "~:type": "paragraph",
-                        "~:font-variant-id": "regular",
-                        "~:text-decoration": "none",
-                        "~:letter-spacing": "0",
-                        "~:fills": [
-                          {
-                            "~:fill-color": "#000000",
-                            "~:fill-opacity": 1
-                          }
-                        ],
-                        "~:font-family": "sourcesanspro"
-                      }
-                    ]
-                  }
-                ],
-                "~:vertical-align": "top"
-              },
-              "~:hide-in-viewer": false,
-              "~:name": "Lorem ipsum",
-              "~:width": 77,
-              "~:type": "~:text",
-              "~:points": [
-                {
-                  "~#point": {
-                    "~:x": 404,
-                    "~:y": 438
-                  }
-                },
-                {
-                  "~#point": {
-                    "~:x": 481,
-                    "~:y": 438
-                  }
-                },
-                {
-                  "~#point": {
-                    "~:x": 481,
-                    "~:y": 455
-                  }
-                },
-                {
-                  "~#point": {
-                    "~:x": 404,
-                    "~:y": 455
-                  }
-                }
-              ],
-              "~:transform-inverse": {
-                "~#matrix": {
-                  "~:a": 1.0,
-                  "~:b": 0.0,
-                  "~:c": 0.0,
-                  "~:d": 1.0,
-                  "~:e": 0.0,
-                  "~:f": 0.0
-                }
-              },
-              "~:id": "~ucc6f0580-449c-8019-8006-9345db077fa0",
-              "~:parent-id": "~u00000000-0000-0000-0000-000000000000",
-              "~:frame-id": "~u00000000-0000-0000-0000-000000000000",
-              "~:x": 404,
-              "~:selrect": {
-                "~#rect": {
-                  "~:x": 404,
-                  "~:y": 438,
-                  "~:width": 77,
-                  "~:height": 17,
-                  "~:x1": 404,
-                  "~:y1": 438,
-                  "~:x2": 481,
-                  "~:y2": 455
-                }
-              },
-              "~:flip-x": null,
-              "~:height": 17,
-              "~:flip-y": null
-            }
-          }
-        },
-        "~:id": "~u238a17e0-75ff-8075-8006-934586ea2231",
-        "~:name": "Page 1"
-      }
-    },
-    "~:id": "~u238a17e0-75ff-8075-8006-934586ea2230",
-    "~:options": {
-      "~:components-v2": true,
-      "~:base-font-size": "16px"
-    }
-  }
-}
--- a/frontend/playwright/data/text-editor/update-file-11552.json
+++ b/frontend/playwright/data/text-editor/update-file-11552.json
@@ -1 +1,5 @@
-w
+{
+    "~:revn": 2,
+    "~:lagged": []
+
+}
--- a/frontend/playwright/data/text-editor/update-file.json
+++ b/frontend/playwright/data/text-editor/update-file.json
@@ -1,4 +0,0 @@
-{
-  "~:revn": 2,
-  "~:lagged": []
-}
--- a/frontend/playwright/data/workspace/update-file-empty.json
+++ b/frontend/playwright/data/workspace/update-file-empty.json
@@ -1,9 +0,0 @@
-[
-  {
-    "~:id": "~u088df3d4-d383-80f6-8004-527e50ea4f1f",
-    "~:revn": 21,
-    "~:file-id": "~uc7ce0794-0992-8105-8004-38f280443849",
-    "~:session-id": "~u1dc6d4fa-7bd3-803a-8004-527dd9df2c62",
-    "~:changes": []
-  }
-]
--- a/frontend/playwright/helpers/Clipboard.js
+++ b/frontend/playwright/helpers/Clipboard.js
@@ -1,36 +0,0 @@
-export class Clipboard {
-  static Permission = {
-    ONLY_READ: ["clipboard-read"],
-    ONLY_WRITE: ["clipboard-write"],
-    ALL: ["clipboard-read", "clipboard-write"],
-  };
-
-  static enable(context, permissions) {
-    return context.grantPermissions(permissions);
-  }
-
-  static writeText(page, text) {
-    return page.evaluate((text) => navigator.clipboard.writeText(text), text);
-  }
-
-  static readText(page) {
-    return page.evaluate(() => navigator.clipboard.readText());
-  }
-
-  constructor(page, context) {
-    this.page = page;
-    this.context = context;
-  }
-
-  enable(permissions) {
-    return Clipboard.enable(this.context, permissions);
-  }
-
-  writeText(text) {
-    return Clipboard.writeText(this.page, text);
-  }
-
-  readText() {
-    return Clipboard.readText(this.page);
-  }
-}
--- a/frontend/playwright/helpers/Transit.js
+++ b/frontend/playwright/helpers/Transit.js
@@ -1,28 +0,0 @@
-export class Transit {
-  static parse(value) {
-    if (typeof value !== "string") return value;
-
-    if (value.startsWith("~")) return value.slice(2);
-
-    return value;
-  }
-
-  static get(object, ...path) {
-    let aux = object;
-    for (const name of path) {
-      if (typeof name !== "string") {
-        if (!(name in aux)) {
-          return undefined;
-        }
-        aux = aux[name];
-      } else {
-        const transitName = `~:${name}`;
-        if (!(transitName in aux)) {
-          return undefined;
-        }
-        aux = aux[transitName];
-      }
-    }
-    return this.parse(aux);
-  }
-}
--- a/frontend/playwright/ui/pages/BasePage.js
+++ b/frontend/playwright/ui/pages/BasePage.js
@@ -1,27 +1,4 @@
 export class BasePage {
-  /**
-   * Mocks multiple RPC calls in a single call.
-   *
-   * @param {Page} page
-   * @param {object<string, string>} paths
-   * @param {*} options
-   * @returns {Promise<void>}
-   */
-  static async mockRPCs(page, paths, options) {
-    for (const [path, jsonFilename] of Object.entries(paths)) {
-      await this.mockRPC(page, path, jsonFilename, options);
-    }
-  }
-
-  /**
-   * Mocks an RPC call using a file.
-   *
-   * @param {Page} page
-   * @param {string} path
-   * @param {string} jsonFilename
-   * @param {*} options
-   * @returns {Promise<void>}
-   */
  static async mockRPC(page, path, jsonFilename, options) {
    if (!page) {
      throw new TypeError("Invalid page argument. Must be a Playwright page.");
@@ -116,10 +93,6 @@ export class BasePage {
    return this.#page;
  }

-  async mockRPCs(paths, options) {
-    return BasePage.mockRPCs(this.page, paths, options);
-  }
-
  async mockRPC(path, jsonFilename, options) {
    return BasePage.mockRPC(this.page, path, jsonFilename, options);
  }
--- a/frontend/playwright/ui/pages/WorkspacePage.js
+++ b/frontend/playwright/ui/pages/WorkspacePage.js
@@ -1,146 +1,7 @@
 import { expect } from "@playwright/test";
-import { readFile } from "node:fs/promises";
 import { BaseWebSocketPage } from "./BaseWebSocketPage";
-import { Transit } from "../../helpers/Transit";

 export class WorkspacePage extends BaseWebSocketPage {
-  static TextEditor = class TextEditor {
-    constructor(workspacePage) {
-      this.workspacePage = workspacePage;
-
-      // locators.
-      this.fontSize = this.workspacePage.rightSidebar.getByRole("textbox", {
-        name: "Font Size",
-      });
-      this.lineHeight = this.workspacePage.rightSidebar.getByRole("textbox", {
-        name: "Line Height",
-      });
-      this.letterSpacing = this.workspacePage.rightSidebar.getByRole(
-        "textbox",
-        {
-          name: "Letter Spacing",
-        },
-      );
-    }
-
-    get page() {
-      return this.workspacePage.page;
-    }
-
-    async waitForStyle(locator, styleName) {
-      return locator.evaluate(
-        (element, styleName) => element.style.getPropertyValue(styleName),
-        styleName,
-      );
-    }
-
-    async waitForEditor() {
-      return this.page.waitForSelector('[data-itype="editor"]');
-    }
-
-    async waitForRoot() {
-      return this.page.waitForSelector('[data-itype="root"]');
-    }
-
-    async waitForParagraph(nth) {
-      if (!nth) {
-        return this.page.waitForSelector('[data-itype="paragraph"]');
-      }
-      return this.page.waitForSelector(
-        `[data-itype="paragraph"]:nth-child(${nth})`,
-      );
-    }
-
-    async waitForParagraphStyle(nth, styleName) {
-      const paragraph = await this.waitForParagraph(nth);
-      return this.waitForStyle(paragraph, styleName);
-    }
-
-    async waitForTextSpan(nth = 0) {
-      if (!nth) {
-        return this.page.waitForSelector('[data-itype="inline"]');
-      }
-      return this.page.waitForSelector(
-        `[data-itype="inline"]:nth-child(${nth})`,
-      );
-    }
-
-    async waitForTextSpanContent(nth = 0) {
-      const textSpan = await this.waitForTextSpan(nth);
-      const textContent = await textSpan.textContent();
-      return textContent;
-    }
-
-    async waitForTextSpanStyle(nth, styleName) {
-      const textSpan = await this.waitForTextSpan(nth);
-      return this.waitForStyle(textSpan, styleName);
-    }
-
-    async startEditing() {
-      await this.page.keyboard.press("Enter");
-      return this.waitForEditor();
-    }
-
-    stopEditing() {
-      return this.page.keyboard.press("Escape");
-    }
-
-    async moveToLeft(amount = 0) {
-      for (let i = 0; i < amount; i++) {
-        await this.page.keyboard.press("ArrowLeft");
-      }
-    }
-
-    async moveToRight(amount = 0) {
-      for (let i = 0; i < amount; i++) {
-        await this.page.keyboard.press("ArrowRight");
-      }
-    }
-
-    async moveFromStart(offset = 0) {
-      await this.page.keyboard.press("ArrowLeft");
-      await this.moveToRight(offset);
-    }
-
-    async moveFromEnd(offset = 0) {
-      await this.page.keyboard.press("ArrowRight");
-      await this.moveToLeft(offset);
-    }
-
-    async selectFromStart(length, offset = 0) {
-      await this.moveFromStart(offset);
-      await this.page.keyboard.down("Shift");
-      await this.moveToRight(length);
-      await this.page.keyboard.up("Shift");
-    }
-
-    async selectFromEnd(length, offset = 0) {
-      await this.moveFromEnd(offset);
-      await this.page.keyboard.down("Shift");
-      await this.moveToLeft(length);
-      await this.page.keyboard.up("Shift");
-    }
-
-    async changeNumericInput(locator, newValue) {
-      await expect(locator).toBeVisible();
-      await locator.focus();
-      await locator.fill(`${newValue}`);
-      await locator.blur();
-    }
-
-    changeFontSize(newValue) {
-      return this.changeNumericInput(this.fontSize, newValue);
-    }
-
-    changeLineHeight(newValue) {
-      return this.changeNumericInput(this.lineHeight, newValue);
-    }
-
-    changeLetterSpacing(newValue) {
-      return this.changeNumericInput(this.letterSpacing, newValue);
-    }
-  };
-
  /**
   * This should be called on `test.beforeEach`.
   *
@@ -150,21 +11,50 @@ export class WorkspacePage extends BaseWebSocketPage {
  static async init(page) {
    await BaseWebSocketPage.initWebSockets(page);

-    await BaseWebSocketPage.mockRPCs(page, {
-      "get-profile": "logged-in-user/get-profile-logged-in.json",
-      "get-team-users?file-id=*":
-        "logged-in-user/get-team-users-single-user.json",
-      "get-comment-threads?file-id=*":
-        "workspace/get-comment-threads-empty.json",
-      "get-project?id=*": "workspace/get-project-default.json",
-      "get-team?id=*": "workspace/get-team-default.json",
-      "get-teams": "get-teams.json",
-      "get-team-members?team-id=*":
-        "logged-in-user/get-team-members-your-penpot.json",
-      "get-profiles-for-file-comments?file-id=*":
-        "workspace/get-profile-for-file-comments.json",
-      "update-profile-props": "workspace/update-profile-empty.json",
-    });
+    await BaseWebSocketPage.mockRPC(
+      page,
+      "get-profile",
+      "logged-in-user/get-profile-logged-in.json",
+    );
+    await BaseWebSocketPage.mockRPC(
+      page,
+      "get-team-users?file-id=*",
+      "logged-in-user/get-team-users-single-user.json",
+    );
+    await BaseWebSocketPage.mockRPC(
+      page,
+      "get-comment-threads?file-id=*",
+      "workspace/get-comment-threads-empty.json",
+    );
+    await BaseWebSocketPage.mockRPC(
+      page,
+      "get-project?id=*",
+      "workspace/get-project-default.json",
+    );
+    await BaseWebSocketPage.mockRPC(
+      page,
+      "get-team?id=*",
+      "workspace/get-team-default.json",
+    );
+    await BaseWebSocketPage.mockRPC(page, "get-teams", "get-teams.json");
+
+    await BaseWebSocketPage.mockRPC(
+      page,
+      "get-team-members?team-id=*",
+      "logged-in-user/get-team-members-your-penpot.json",
+    );
+
+    await BaseWebSocketPage.mockRPC(
+      page,
+      "get-profiles-for-file-comments?file-id=*",
+      "workspace/get-profile-for-file-comments.json",
+    );
+
+    await BaseWebSocketPage.mockRPC(
+      page,
+      "update-profile-props",
+      "workspace/update-profile-empty.json",
+    );
  }

  static anyTeamId = "c7ce0794-0992-8105-8004-38e630f7920a";
@@ -172,20 +62,9 @@ export class WorkspacePage extends BaseWebSocketPage {
  static anyFileId = "c7ce0794-0992-8105-8004-38f280443849";
  static anyPageId = "c7ce0794-0992-8105-8004-38f28044384a";

-  /**
-   * WebSocket mock
-   *
-   * @type {MockWebSocketHelper}
-   */
  #ws = null;

-  /**
-   * Constructor
-   *
-   * @param {Page} page
-   * @param {} [options]
-   */
-  constructor(page, options) {
+  constructor(page) {
    super(page);
    this.pageName = page.getByTestId("page-name");

@@ -233,14 +112,11 @@ export class WorkspacePage extends BaseWebSocketPage {
      "tokens-context-menu-for-set",
    );
    this.contextMenuForShape = page.getByTestId("context-menu");
-    if (options?.textEditor) {
-      this.textEditor = new WorkspacePage.TextEditor(this);
-    }
  }

  async goToWorkspace({
-    fileId = this.fileId ?? WorkspacePage.anyFileId,
-    pageId = this.pageId ?? WorkspacePage.anyPageId,
+    fileId = WorkspacePage.anyFileId,
+    pageId = WorkspacePage.anyPageId,
  } = {}) {
    await this.page.goto(
      `/#/workspace?team-id=${WorkspacePage.anyTeamId}&file-id=${fileId}&page-id=${pageId}`,
@@ -265,59 +141,48 @@ export class WorkspacePage extends BaseWebSocketPage {
  }

  async setupEmptyFile() {
-    await this.mockRPCs({
-      "get-profile": "logged-in-user/get-profile-logged-in.json",
-      "get-team-users?file-id=*":
-        "logged-in-user/get-team-users-single-user.json ",
-      "get-comment-threads?file-id=*":
-        "workspace/get-comment-threads-empty.json",
-      "get-project?id=*": "workspace/get-project-default.json",
-      "get-team?id=*": "workspace/get-team-default.json",
-      "get-profiles-for-file-comments?file-id=*":
-        "workspace/get-profile-for-file-comments.json",
-      "get-file-object-thumbnails?file-id=*":
-        "workspace/get-file-object-thumbnails-blank.json",
-      "get-font-variants?team-id=*": "workspace/get-font-variants-empty.json",
-      "get-file-fragment?file-id=*": "workspace/get-file-fragment-blank.json",
-      "get-file-libraries?file-id=*": "workspace/get-file-libraries-empty.json",
-    });
-
-    if (this.textEditor) {
-      await this.mockRPC("update-file?id=*", "text-editor/update-file.json");
-    }
-
-    // by default we mock the blank file.
-    await this.mockGetFile("workspace/get-file-blank.json");
+    await this.mockRPC(
+      "get-profile",
+      "logged-in-user/get-profile-logged-in.json",
+    );
+    await this.mockRPC(
+      "get-team-users?file-id=*",
+      "logged-in-user/get-team-users-single-user.json",
+    );
+    await this.mockRPC(
+      "get-comment-threads?file-id=*",
+      "workspace/get-comment-threads-empty.json",
+    );
+    await this.mockRPC(
+      "get-project?id=*",
+      "workspace/get-project-default.json",
+    );
+    await this.mockRPC("get-team?id=*", "workspace/get-team-default.json");
+    await this.mockRPC(
+      "get-profiles-for-file-comments?file-id=*",
+      "workspace/get-profile-for-file-comments.json",
+    );
+    await this.mockRPC(/get\-file\?/, "workspace/get-file-blank.json");
+    await this.mockRPC(
+      "get-file-object-thumbnails?file-id=*",
+      "workspace/get-file-object-thumbnails-blank.json",
+    );
+    await this.mockRPC(
+      "get-font-variants?team-id=*",
+      "workspace/get-font-variants-empty.json",
+    );
+    await this.mockRPC(
+      "get-file-fragment?file-id=*",
+      "workspace/get-file-fragment-blank.json",
+    );
+    await this.mockRPC(
+      "get-file-libraries?file-id=*",
+      "workspace/get-file-libraries-empty.json",
+    );
  }

-  async mockGetFile(jsonFilename, options) {
-    const page = this.page;
-    const jsonPath = `playwright/data/${jsonFilename}`;
-    const body = await readFile(jsonPath, "utf-8");
-    const payload = JSON.parse(body);
-
-    const fileId = Transit.get(payload, "id");
-    const pageId = Transit.get(payload, "data", "pages", 0);
-    const teamId = Transit.get(payload, "team-id");
-
-    this.fileId = fileId ?? this.anyFileId;
-    this.pageId = pageId ?? this.anyPageId;
-    this.teamId = teamId ?? this.anyTeamId;
-
-    const path = /get\-file\?/;
-    const url = typeof path === "string" ? `**/api/main/methods/${path}` : path;
-    const interceptConfig = {
-      status: 200,
-      contentType: "application/transit+json",
-      ...options,
-    };
-    return page.route(url, (route) =>
-      route.fulfill({
-        ...interceptConfig,
-        body,
-      }),
-    );
-    // await this.mockRPC(/get\-file\?/, jsonFile);
+  async mockGetFile(jsonFile) {
+    await this.mockRPC(/get\-file\?/, jsonFile);
  }

  async mockGetAsset(regex, asset) {
@@ -325,15 +190,22 @@ export class WorkspacePage extends BaseWebSocketPage {
  }

  async setupFileWithComments() {
-    await this.mockRPCs({
-      "get-comment-threads?file-id=*":
-        "workspace/get-comment-threads-unread.json",
-      "get-file-fragment?file-id=*&fragment-id=*":
-        "viewer/get-file-fragment-single-board.json",
-      "get-comments?thread-id=*": "workspace/get-thread-comments.json",
-      "update-comment-thread-status":
-        "workspace/update-comment-thread-status.json",
-    });
+    await this.mockRPC(
+      "get-comment-threads?file-id=*",
+      "workspace/get-comment-threads-unread.json",
+    );
+    await this.mockRPC(
+      "get-file-fragment?file-id=*&fragment-id=*",
+      "viewer/get-file-fragment-single-board.json",
+    );
+    await this.mockRPC(
+      "get-comments?thread-id=*",
+      "workspace/get-thread-comments.json",
+    );
+    await this.mockRPC(
+      "update-comment-thread-status",
+      "workspace/update-comment-thread-status.json",
+    );
  }

  async clickWithDragViewportAt(x, y, width, height) {
@@ -351,67 +223,6 @@ export class WorkspacePage extends BaseWebSocketPage {
    await this.page.mouse.up();
  }

-  /**
-   * Clicks and moves from the coordinates x1,y1 to x2,y2
-   *
-   * @param {number} x1
-   * @param {number} y1
-   * @param {number} x2
-   * @param {number} y2
-   */
-  async clickAndMove(x1, y1, x2, y2) {
-    await this.page.waitForTimeout(100);
-    await this.viewport.hover({ position: { x: x1, y: y1 } });
-    await this.page.mouse.down();
-    await this.viewport.hover({ position: { x: x2, y: y2 } });
-    await this.page.mouse.up();
-  }
-
-  /**
-   * Creates a new Text Shape in the specified coordinates
-   * with an initial text.
-   *
-   * @param {number} x1
-   * @param {number} y1
-   * @param {number} x2
-   * @param {number} y2
-   * @param {string} initialText
-   * @param {*} [options]
-   */
-  async createTextShape(x1, y1, x2, y2, initialText, options) {
-    const timeToWait = options?.timeToWait ?? 100;
-    await this.page.keyboard.press("T");
-    await this.page.waitForTimeout(timeToWait);
-    await this.clickAndMove(x1, y1, x2, y2);
-    await this.page.waitForTimeout(timeToWait);
-    if (initialText) {
-      await this.page.keyboard.type(initialText);
-    }
-  }
-
-  /**
-   * Copies the selected element into the clipboard.
-   *
-   * @returns {Promise<void>}
-   */
-  async copy() {
-    return this.page.keyboard.press("Control+C");
-  }
-
-  /**
-   * Pastes something from the clipboard.
-   *
-   * @param {"keyboard"|"context-menu"} [kind="keyboard"]
-   * @returns {Promise<void>}
-   */
-  async paste(kind = "keyboard") {
-    if (kind === "context-menu") {
-      await this.viewport.click({ button: "right" });
-      return this.page.getByText("PasteCtrlV").click();
-    }
-    return this.page.keyboard.press("Control+V");
-  }
-
  async panOnViewportAt(x, y, width, height) {
    await this.page.waitForTimeout(100);
    await this.viewport.hover({ position: { x, y } });
@@ -439,15 +250,10 @@ export class WorkspacePage extends BaseWebSocketPage {
    await this.page.waitForTimeout(500);
  }

-  async doubleClickLeafLayer(name, clickOptions = {}) {
-    await this.clickLeafLayer(name, clickOptions);
-    await this.clickLeafLayer(name, clickOptions);
-  }
-
  async clickToggableLayer(name, clickOptions = {}) {
    const layer = this.layers
-      .getByTestId("layer-row")
-      .filter({ hasText: name });
+          .getByTestId("layer-row")
+          .filter({ hasText: name });
    const button = layer.getByRole("button");

    await button.waitFor();
--- a/frontend/playwright/ui/render-wasm-specs/shapes.spec.js-snapshots/Renders-a-file-with-nested-clipping-frames-1.png
+++ b/frontend/playwright/ui/render-wasm-specs/shapes.spec.js-snapshots/Renders-a-file-with-nested-clipping-frames-1.png
--- a/frontend/playwright/ui/render-wasm-specs/texts.spec.js
+++ b/frontend/playwright/ui/render-wasm-specs/texts.spec.js
@@ -360,7 +360,7 @@ test("Renders a file with texts with paragraphs and breaking lines", async ({
    id: "a5f238bd-dd8a-8164-8007-1bc3481eaf05",
    pageId: "a5f238bd-dd8a-8164-8007-1bc3481eaf06",
  });
-  await workspace.waitForFirstRenderWithoutUI();
+  await workspace.waitForFirstRender();
  await expect(workspace.canvas).toHaveScreenshot();
 });

--- a/frontend/playwright/ui/specs/inspect-tab.spec.js
+++ b/frontend/playwright/ui/specs/inspect-tab.spec.js
@@ -18,10 +18,6 @@ const setupFile = async (workspacePage) => {
    fileId: "7b2da435-6186-815a-8007-0daa95d2f26d",
    pageId: "ce79274b-11ab-8088-8007-0487ad43f789",
  });
-  await workspacePage.mockRPC(
-    "update-file?id=*",
-    "workspace/update-file-empty.json",
-  );
 };

 const shapeToLayerName = {
--- a/frontend/playwright/ui/specs/render-wasm.spec.js
+++ b/frontend/playwright/ui/specs/render-wasm.spec.js
@@ -51,7 +51,7 @@ test.skip("BUG 12164 - Crash when trying to fetch a missing font", async ({
    pageId: "2b7f0188-51a1-8193-8006-e05bad87b74d",
  });

-  await workspacePage.page.waitForTimeout(1000);
+  await workspacePage.page.waitForTimeout(1000)
  await workspacePage.waitForFirstRender();

  await expect(
--- a/frontend/playwright/ui/specs/text-editor-v2.spec.js
+++ b/frontend/playwright/ui/specs/text-editor-v2.spec.js
@@ -1,323 +1,12 @@
 import { test, expect } from "@playwright/test";
-import { Clipboard } from "../../helpers/Clipboard";
 import { WorkspacePage } from "../pages/WorkspacePage";

-const timeToWait = 100;
-
-test.beforeEach(async ({ page, context }) => {
-  await Clipboard.enable(context, Clipboard.Permission.ONLY_WRITE);
-
+test.beforeEach(async ({ page }) => {
  await WorkspacePage.init(page);
  await WorkspacePage.mockConfigFlags(page, ["enable-feature-text-editor-v2"]);
 });

-test.afterEach(async ({ context }) => {
-  context.clearPermissions();
-});
-
-test("Create a new text shape", async ({ page }) => {
-  const initialText = "Lorem ipsum";
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.goToWorkspace();
-  await workspace.createTextShape(190, 150, 300, 200, initialText);
-
-  const textContent = await workspace.textEditor.waitForTextSpanContent();
-  expect(textContent).toBe(initialText);
-
-  await workspace.textEditor.stopEditing();
-});
-
-test("Create a new text shape from pasting text", async ({ page, context }) => {
-  const textToPaste = "Lorem ipsum";
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.mockRPC("update-file?id=*", "text-editor/update-file.json");
-  await workspace.goToWorkspace();
-
-  await Clipboard.writeText(page, textToPaste);
-
-  await workspace.clickAt(190, 150);
-  await workspace.paste("keyboard");
-
-  await page.waitForTimeout(timeToWait);
-
-  const textContent = await workspace.textEditor.waitForTextSpanContent();
-  expect(textContent).toBe(textToPaste);
-
-  await workspace.textEditor.stopEditing();
-});
-
-test("Create a new text shape from pasting text using context menu", async ({
-  page,
-  context,
-}) => {
-  const textToPaste = "Lorem ipsum";
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.goToWorkspace();
-
-  await Clipboard.writeText(page, textToPaste);
-
-  await workspace.clickAt(190, 150);
-  await workspace.paste("context-menu");
-
-  const textContent = await workspace.textEditor.waitForTextSpanContent();
-  expect(textContent).toBe(textToPaste);
-
-  await workspace.textEditor.stopEditing();
-});
-
-test("Update an already created text shape by appending text", async ({
-  page,
-}) => {
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.mockGetFile("text-editor/get-file-lorem-ipsum.json");
-  await workspace.goToWorkspace();
-  await workspace.clickLeafLayer("Lorem ipsum");
-  await workspace.textEditor.startEditing();
-  await workspace.textEditor.moveFromEnd(0);
-  await page.keyboard.type(" dolor sit amet");
-  const textContent = await workspace.textEditor.waitForTextSpanContent();
-  expect(textContent).toBe("Lorem ipsum dolor sit amet");
-  await workspace.textEditor.stopEditing();
-});
-
-test("Update an already created text shape by prepending text", async ({
-  page,
-}) => {
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.mockGetFile("text-editor/get-file-lorem-ipsum.json");
-  await workspace.goToWorkspace();
-  await workspace.clickLeafLayer("Lorem ipsum");
-  await workspace.textEditor.startEditing();
-  await workspace.textEditor.moveFromStart(0);
-  await page.keyboard.type("Dolor sit amet ");
-  const textContent = await workspace.textEditor.waitForTextSpanContent();
-  expect(textContent).toBe("Dolor sit amet Lorem ipsum");
-  await workspace.textEditor.stopEditing();
-});
-
-test("Update an already created text shape by inserting text in between", async ({
-  page,
-}) => {
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.mockGetFile("text-editor/get-file-lorem-ipsum.json");
-  await workspace.goToWorkspace();
-  await workspace.clickLeafLayer("Lorem ipsum");
-  await workspace.textEditor.startEditing();
-  await workspace.textEditor.moveFromStart(5);
-  await page.keyboard.type(" dolor sit amet");
-  const textContent = await workspace.textEditor.waitForTextSpanContent();
-  expect(textContent).toBe("Lorem dolor sit amet ipsum");
-  await workspace.textEditor.stopEditing();
-});
-
-test("Update a new text shape appending text by pasting text", async ({
-  page,
-  context,
-}) => {
-  const textToPaste = " dolor sit amet";
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.mockGetFile("text-editor/get-file-lorem-ipsum.json");
-  await workspace.goToWorkspace();
-
-  await Clipboard.writeText(page, textToPaste);
-
-  await workspace.clickLeafLayer("Lorem ipsum");
-  await workspace.textEditor.startEditing();
-  await workspace.textEditor.moveFromEnd();
-  await workspace.paste("keyboard");
-  const textContent = await workspace.textEditor.waitForTextSpanContent();
-  expect(textContent).toBe("Lorem ipsum dolor sit amet");
-  await workspace.textEditor.stopEditing();
-});
-
-test("Update a new text shape prepending text by pasting text", async ({
-  page,
-  context,
-}) => {
-  const textToPaste = "Dolor sit amet ";
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.mockGetFile("text-editor/get-file-lorem-ipsum.json");
-  await workspace.goToWorkspace();
-
-  await Clipboard.writeText(page, textToPaste);
-
-  await workspace.clickLeafLayer("Lorem ipsum");
-  await workspace.textEditor.startEditing();
-  await workspace.textEditor.moveFromStart();
-  await workspace.paste("keyboard");
-  const textContent = await workspace.textEditor.waitForTextSpanContent();
-  expect(textContent).toBe("Dolor sit amet Lorem ipsum");
-  await workspace.textEditor.stopEditing();
-});
-
-test("Update a new text shape replacing (starting) text with pasted text", async ({
-  page,
-}) => {
-  const textToPaste = "Dolor sit amet";
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.mockGetFile("text-editor/get-file-lorem-ipsum.json");
-  await workspace.goToWorkspace();
-  await workspace.clickLeafLayer("Lorem ipsum");
-  await workspace.textEditor.startEditing();
-  await workspace.textEditor.selectFromStart(5);
-
-  await Clipboard.writeText(page, textToPaste);
-
-  await workspace.paste("keyboard");
-
-  const textContent = await workspace.textEditor.waitForTextSpanContent();
-  expect(textContent).toBe("Dolor sit amet ipsum");
-
-  await workspace.textEditor.stopEditing();
-});
-
-test("Update a new text shape replacing (ending) text with pasted text", async ({
-  page,
-}) => {
-  const textToPaste = "dolor sit amet";
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.mockGetFile("text-editor/get-file-lorem-ipsum.json");
-  await workspace.goToWorkspace();
-  await workspace.clickLeafLayer("Lorem ipsum");
-  await workspace.textEditor.startEditing();
-  await workspace.textEditor.selectFromEnd(5);
-
-  await Clipboard.writeText(page, textToPaste);
-
-  await workspace.paste("keyboard");
-
-  const textContent = await workspace.textEditor.waitForTextSpanContent();
-  expect(textContent).toBe("Lorem dolor sit amet");
-
-  await workspace.textEditor.stopEditing();
-});
-
-test("Update a new text shape replacing (in between) text with pasted text", async ({
-  page,
-}) => {
-  const textToPaste = "dolor sit amet";
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.mockGetFile("text-editor/get-file-lorem-ipsum.json");
-  await workspace.goToWorkspace();
-  await workspace.clickLeafLayer("Lorem ipsum");
-  await workspace.textEditor.startEditing();
-  await workspace.textEditor.selectFromStart(5, 3);
-
-  await Clipboard.writeText(page, textToPaste);
-
-  await workspace.paste("keyboard");
-
-  const textContent = await workspace.textEditor.waitForTextSpanContent();
-  expect(textContent).toBe("Lordolor sit ametsum");
-
-  await workspace.textEditor.stopEditing();
-});
-
-test("Update text font size selecting a part of it (starting)", async ({
-  page,
-}) => {
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.mockGetFile("text-editor/get-file-lorem-ipsum.json");
-  await workspace.mockRPC("update-file?id=*", "text-editor/update-file.json");
-  await workspace.goToWorkspace();
-  await workspace.clickLeafLayer("Lorem ipsum");
-  await workspace.textEditor.startEditing();
-  await workspace.textEditor.selectFromStart(5);
-  await workspace.textEditor.changeFontSize(36);
-
-  const textContent1 = await workspace.textEditor.waitForTextSpanContent(1);
-  expect(textContent1).toBe("Lorem");
-  const textContent2 = await workspace.textEditor.waitForTextSpanContent(2);
-  expect(textContent2).toBe(" ipsum");
-  await workspace.textEditor.stopEditing();
-});
-
-test.skip("Update text line height selecting a part of it (starting)", async ({
-  page,
-}) => {
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.mockGetFile("text-editor/get-file-lorem-ipsum.json");
-  await workspace.mockRPC("update-file?id=*", "text-editor/update-file.json");
-  await workspace.goToWorkspace();
-  await workspace.clickLeafLayer("Lorem ipsum");
-  await workspace.textEditor.startEditing();
-  await workspace.textEditor.selectFromStart(5);
-  await workspace.textEditor.changeLineHeight(1.4);
-
-  const lineHeight = await workspace.textEditor.waitForParagraphStyle(
-    1,
-    "line-height",
-  );
-  expect(lineHeight).toBe("1.4");
-
-  const textContent = await workspace.textEditor.waitForTextSpanContent();
-  expect(textContent).toBe("Lorem ipsum");
-
-  await workspace.textEditor.stopEditing();
-});
-
-test.skip("Update text letter spacing selecting a part of it (starting)", async ({
-  page,
-}) => {
-  const workspace = new WorkspacePage(page, {
-    textEditor: true,
-  });
-  await workspace.setupEmptyFile();
-  await workspace.mockGetFile("text-editor/get-file-lorem-ipsum.json");
-  await workspace.mockRPC("update-file?id=*", "text-editor/update-file.json");
-  await workspace.goToWorkspace();
-  await workspace.clickLeafLayer("Lorem ipsum");
-  await workspace.textEditor.startEditing();
-  await workspace.textEditor.selectFromStart(5);
-  await workspace.textEditor.changeLetterSpacing(10);
-
-  const textContent1 = await workspace.textEditor.waitForTextSpanContent(1);
-  expect(textContent1).toBe("Lorem");
-  const textContent2 = await workspace.textEditor.waitForTextSpanContent(2);
-  expect(textContent2).toBe(" ipsum");
-  await workspace.textEditor.stopEditing();
-});
-
-test("BUG 11552 - Apply styles to the current caret", async ({ page }) => {
+test.skip("BUG 11552 - Apply styles to the current caret", async ({ page }) => {
  const workspace = new WorkspacePage(page);
  await workspace.setupEmptyFile();
  await workspace.mockGetFile("text-editor/get-file-11552.json");
@@ -325,16 +14,21 @@ test("BUG 11552 - Apply styles to the current caret", async ({ page }) => {
    "update-file?id=*",
    "text-editor/update-file-11552.json",
  );
-  await workspace.goToWorkspace();
-  await workspace.doubleClickLeafLayer("Lorem ipsum");
+
+  await workspace.goToWorkspace({
+    fileId: "238a17e0-75ff-8075-8006-934586ea2230",
+    pageId: "238a17e0-75ff-8075-8006-934586ea2231",
+  });
+  await workspace.clickLeafLayer("Lorem ipsum");
+  await workspace.clickLeafLayer("Lorem ipsum");

  const fontSizeInput = workspace.rightSidebar.getByRole("textbox", {
    name: "Font Size",
  });
  await expect(fontSizeInput).toBeVisible();

-  await page.keyboard.press("Enter");
-  await page.keyboard.press("ArrowRight");
+  await workspace.page.keyboard.press("Enter");
+  await workspace.page.keyboard.press("ArrowRight");

  await fontSizeInput.fill("36");

--- a/frontend/playwright/ui/specs/tokens.spec.js
+++ b/frontend/playwright/ui/specs/tokens.spec.js
--- a/frontend/resources/fonts/gfonts.2025.05.19.json
+++ b/frontend/resources/fonts/gfonts.2025.05.19.json
--- a/frontend/scripts/build
+++ b/frontend/scripts/build
@@ -20,26 +20,25 @@ echo $PATH
 set -ex

 corepack enable;
-corepack install;
+corepack install || exit 1;
 yarn install || exit 1;

-rm -rf target/dist;
 rm -rf resources/public;
+rm -rf target/dist;

 mkdir -p resources/public;
 mkdir -p target/dist;

-pushd ../render-wasm;
-./build
-popd
+yarn run build:app:main $EXTRA_PARAMS || exit 1

-yarn run build:app:main $EXTRA_PARAMS;
-yarn run build:app:libs;
-yarn run build:app:assets;
+if [ "$INCLUDE_WASM" = "yes" ];  then
+    yarn run build:wasm || exit 1;
+fi

-sed -i "s/\.\/render.js/.\/render.js?version=$CURRENT_VERSION/g" resources/public/js/worker/main*.js
+yarn run build:app:libs || exit 1;
+yarn run build:app:assets || exit 1;

-rsync -avr resources/public/ target/dist/
+rsync -avr resources/public/ target/dist/;

 if [ "$INCLUDE_STORYBOOK" = "yes" ];  then
    # build storybook
--- a/frontend/shadow-cljs.edn
+++ b/frontend/shadow-cljs.edn
@@ -92,7 +92,7 @@
   {:main
    {:entries [app.worker]
     :web-worker true
-     :prepend-js "importScripts('./render.js');"
+     :prepend-js "importScripts('/js/worker/render.js');"
     :depends-on #{}}}

   :js-options
--- a/frontend/src/app/main/data/changes.cljs
+++ b/frontend/src/app/main/data/changes.cljs
@@ -76,7 +76,7 @@
  (map :page-id))

 (defn- apply-changes-localy
-  [{:keys [file-id redo-changes ignore-wasm?] :as commit} pending]
+  [{:keys [file-id redo-changes] :as commit} pending]
  (ptk/reify ::apply-changes-localy
    ptk/UpdateEvent
    (update [_ state]
@@ -103,7 +103,7 @@
                    pids (into #{} xf:map-page-id redo-changes)]
                (reduce #(ctst/update-object-indices %1 %2) fdata pids)))]

-        (if (and (not ignore-wasm?) (features/active-feature? state "render-wasm/v1"))
+        (if (features/active-feature? state "render-wasm/v1")
          ;; Update the wasm model
          (let [shape-changes (volatile! {})

@@ -122,7 +122,7 @@
 (defn commit
  "Create a commit event instance"
  [{:keys [commit-id redo-changes undo-changes origin save-undo? features
-           file-id file-revn file-vern undo-group tags stack-undo? source ignore-wasm?]}]
+           file-id file-revn file-vern undo-group tags stack-undo? source]}]

  (assert (cpc/check-changes redo-changes)
          "expect valid vector of changes for redo-changes")
@@ -147,8 +147,7 @@
                   :save-undo? save-undo?
                   :undo-group undo-group
                   :tags tags
-                   :stack-undo? stack-undo?
-                   :ignore-wasm? ignore-wasm?}]
+                   :stack-undo? stack-undo?}]

    (ptk/reify ::commit
      cljs.core/IDeref
--- a/frontend/src/app/main/data/dashboard.cljs
+++ b/frontend/src/app/main/data/dashboard.cljs
@@ -649,22 +649,10 @@
      (rx/of (dcm/change-team-role params)
             (modal/hide)))))

-(defn handle-change-team-org
-  [{:keys [team-id organization-id organization-name] :as message}]
-  (ptk/reify ::handle-change-team-org
-    ptk/UpdateEvent
-    (update [_ state]
-      (if (contains? (:teams state) team-id)
-        (-> state
-            (assoc-in [:teams team-id :organization-id] organization-id)
-            (assoc-in [:teams team-id :organization-name] organization-name))
-        state))))
-
 (defn- process-message
  [{:keys [type] :as msg}]
  (case type
    :notification           (dcm/handle-notification msg)
    :team-role-change       (handle-change-team-role msg)
    :team-membership-change (dcm/team-membership-change msg)
-    :team-org-change        (handle-change-team-org msg)
    nil))
--- a/frontend/src/app/main/data/persistence.cljs
+++ b/frontend/src/app/main/data/persistence.cljs
@@ -24,8 +24,6 @@
 (def revn-data (atom {}))
 (def queue-conj (fnil conj #queue []))

-(def force-persist? #(= % ::force-persist))
-
 (defn- update-status
  [status]
  (ptk/reify ::update-status
--- a/frontend/src/app/main/data/style_dictionary.cljs
+++ b/frontend/src/app/main/data/style_dictionary.cljs
@@ -261,19 +261,14 @@

 (defn- parse-sd-token-font-family-value
  [value]
-  (let [value (-> (js->clj value) (flatten))
-        valid-font-family (or (string? value) (every? string? value))
-        missing-references (seq (some cto/find-token-value-references value))]
+  (let [missing-references (seq (some cto/find-token-value-references value))]
    (cond
-      (not valid-font-family)
-      {:errors [(wte/error-with-value :error.style-dictionary/invalid-token-value-font-family value)]}
-
      missing-references
      {:errors [(wte/error-with-value :error.style-dictionary/missing-reference missing-references)]
       :references missing-references}

      :else
-      {:value value})))
+      {:value (-> (js->clj value) (flatten))})))

 (defn parse-atomic-typography-value [token-type token-value]
  (case token-type
--- a/frontend/src/app/main/data/workspace.cljs
+++ b/frontend/src/app/main/data/workspace.cljs
@@ -32,7 +32,7 @@
   [app.main.data.helpers :as dsh]
   [app.main.data.modal :as modal]
   [app.main.data.notifications :as ntf]
-   [app.main.data.persistence :as dps]
+   [app.main.data.persistence :as-alias dps]
   [app.main.data.plugins :as dp]
   [app.main.data.profile :as du]
   [app.main.data.project :as dpj]
@@ -67,7 +67,6 @@
   [app.main.errors]
   [app.main.features :as features]
   [app.main.features.pointer-map :as fpmap]
-   [app.main.refs :as refs]
   [app.main.repo :as rp]
   [app.main.router :as rt]
   [app.render-wasm :as wasm]
@@ -380,59 +379,6 @@
                          (->> (rx/from added)
                               (rx/map process-wasm-object)))))))

-              (when render-wasm?
-                (let [local-commits-s
-                      (->> stream
-                           (rx/filter dch/commit?)
-                           (rx/map deref)
-                           (rx/filter #(and (= :local (:source %))
-                                            (not (contains? (:tags %) :position-data))))
-                           (rx/filter (complement empty?)))
-
-                      notifier-s
-                      (rx/merge
-                       (->> local-commits-s (rx/debounce 1000))
-                       (->> stream (rx/filter dps/force-persist?)))
-
-                      objects-s
-                      (rx/from-atom refs/workspace-page-objects {:emit-current-value? true})
-
-                      current-page-id-s
-                      (rx/from-atom refs/current-page-id {:emit-current-value? true})]
-
-                  (->> local-commits-s
-                       (rx/buffer-until notifier-s)
-                       (rx/with-latest-from objects-s)
-                       (rx/map
-                        (fn [[commits objects]]
-                          (->> commits
-                               (mapcat :redo-changes)
-                               (filter #(contains? #{:mod-obj :add-obj} (:type %)))
-                               (filter #(cfh/text-shape? objects (:id %)))
-                               (map #(vector
-                                      (:id %)
-                                      (wasm.api/calculate-position-data (get objects (:id %))))))))
-
-                       (rx/with-latest-from current-page-id-s)
-                       (rx/map
-                        (fn [[text-position-data page-id]]
-                          (let [changes
-                                (->> text-position-data
-                                     (mapv (fn [[id position-data]]
-                                             {:type :mod-obj
-                                              :id id
-                                              :page-id page-id
-                                              :operations
-                                              [{:type :set
-                                                :attr :position-data
-                                                :val position-data
-                                                :ignore-touched true
-                                                :ignore-geometry true}]})))]
-                            (dch/commit-changes
-                             {:redo-changes changes :undo-changes []
-                              :save-undo? false
-                              :tags #{:position-data}})))))))
-
              (->> stream
                   (rx/filter dch/commit?)
                   (rx/map deref)
--- a/frontend/src/app/main/data/workspace/fix_deleted_fonts.cljs
+++ b/frontend/src/app/main/data/workspace/fix_deleted_fonts.cljs
@@ -102,8 +102,7 @@
                  {:origin it
                   :redo-changes changes
                   :undo-changes []
-                   :save-undo? false
-                   :ignore-wasm? true})))))))
+                   :save-undo? false})))))))

 ;; FIXME: would be nice to not execute this code twice per page in the
 ;; same working session, maybe some local memoization can improve that
@@ -120,5 +119,4 @@
                  {:origin it
                   :redo-changes changes
                   :undo-changes []
-                   :save-undo? false
-                   :ignore-wasm? true})))))))
+                   :save-undo? false})))))))
--- a/frontend/src/app/main/data/workspace/modifiers.cljs
+++ b/frontend/src/app/main/data/workspace/modifiers.cljs
@@ -649,7 +649,7 @@
            (propagate-structure-modifiers modif-tree (dsh/lookup-page-objects state))

            ids
-            (into (set (keys modif-tree)) xf:without-uuid-zero (keys transforms))
+            (into [] xf:without-uuid-zero (keys transforms))

            update-shape
            (fn [shape]
--- a/frontend/src/app/main/data/workspace/texts.cljs
+++ b/frontend/src/app/main/data/workspace/texts.cljs
@@ -831,8 +831,7 @@
    (effect [_ state _]
      (when (features/active-feature? state "text-editor/v2")
        (let [instance (:workspace-editor state)
-              attrs-to-override (some-> (editor.v2/getCurrentStyle instance)
-                                        (styles/get-styles-from-style-declaration))
+              attrs-to-override (some-> (editor.v2/getCurrentStyle instance) (styles/get-styles-from-style-declaration))
              overriden-attrs (merge attrs-to-override attrs)
              styles  (styles/attrs->styles overriden-attrs)]
          (editor.v2/applyStylesToSelection instance styles))))))
--- a/frontend/src/app/main/data/workspace/tokens/errors.cljs
+++ b/frontend/src/app/main/data/workspace/tokens/errors.cljs
@@ -88,10 +88,6 @@
   {:error/code :error.style-dictionary/invalid-token-value-font-weight
    :error/fn #(tr "workspace.tokens.invalid-font-weight-token-value" %)}

-   :error.style-dictionary/invalid-token-value-font-family
-   {:error/code :error.style-dictionary/invalid-token-value-font-family
-    :error/fn #(tr "workspace.tokens.invalid-font-family-token-value" %)}
-
   :error.style-dictionary/invalid-token-value-typography
   {:error/code :error.style-dictionary/invalid-token-value-typography
    :error/fn #(tr "workspace.tokens.invalid-token-value-typography" %)}
--- a/frontend/src/app/main/fonts.cljs
+++ b/frontend/src/app/main/fonts.cljs
@@ -26,7 +26,7 @@
 (log/set-level! :warn)

 (def google-fonts
-  (preload-gfonts "fonts/gfonts.2025.11.28.json"))
+  (preload-gfonts "fonts/gfonts.2025.05.19.json"))

 (def local-fonts
  [{:id "sourcesanspro"
@@ -342,8 +342,8 @@
        (fn [result {:keys [font-id] :as node}]
          (let [current-font
                (if (some? font-id)
-                  (select-keys node [:font-id :font-variant-id :font-weight :font-style])
-                  (select-keys txt/default-typography [:font-id :font-variant-id :font-weight :font-style]))]
+                  (select-keys node [:font-id :font-variant-id])
+                  (select-keys txt/default-typography [:font-id :font-variant-id]))]
            (conj result current-font)))
        #{})))

--- a/frontend/src/app/main/refs.cljs
+++ b/frontend/src/app/main/refs.cljs
@@ -30,9 +30,6 @@
 (def profile
  (l/derived (l/key :profile) st/state))

-(def current-page-id
-  (l/derived (l/key :current-page-id) st/state))
-
 (def team
  (l/derived (fn [state]
               (let [team-id (:current-team-id state)
@@ -375,9 +372,6 @@
 (def workspace-modifiers
  (l/derived :workspace-modifiers st/state))

-(def workspace-wasm-modifiers
-  (l/derived :workspace-wasm-modifiers st/state))
-
 (def ^:private workspace-modifiers-with-objects
  (l/derived
   (fn [state]
--- a/frontend/src/app/main/ui/components/select.cljs
+++ b/frontend/src/app/main/ui/components/select.cljs
@@ -60,7 +60,6 @@
        current-id    (get state :id)
        current-value (get state :current-value)
        current-label (get label-index current-value)
-
        is-open?      (get state :is-open?)

        node-ref      (mf/use-ref nil)
--- a/frontend/src/app/main/ui/context.cljs
+++ b/frontend/src/app/main/ui/context.cljs
@@ -30,7 +30,6 @@
 (def current-zoom         (mf/create-context nil))

 (def workspace-read-only? (mf/create-context nil))
-(def is-render?           (mf/create-context false))
 (def is-component?        (mf/create-context false))

 (def sidebar
--- a/frontend/src/app/main/ui/dashboard/sidebar.cljs
+++ b/frontend/src/app/main/ui/dashboard/sidebar.cljs
@@ -280,8 +280,8 @@

 (mf/defc teams-selector-dropdown*
  {::mf/private true}
-  [{:keys [team profile teams show-default-team allow-create-teams allow-create-org] :rest props}]
-  (let [on-create-team-click
+  [{:keys [team profile teams] :rest props}]
+  (let [on-create-click
        (mf/use-fn #(st/emit! (modal/show :team-form {})))

        on-team-click
@@ -290,25 +290,18 @@
           (let [team-id (-> (dom/get-current-target event)
                             (dom/get-data "value")
                             (uuid/parse))]
-             (st/emit! (dcm/go-to-dashboard-recent :team-id team-id)))))
-
-        on-create-org-click
-        (mf/use-fn
-         (fn []
-           ;; TODO update when org creation route is ready
-           (dom/open-new-window "localhost:3000/org/create")))]
+             (st/emit! (dcm/go-to-dashboard-recent :team-id team-id)))))]

    [:> dropdown-menu* props

-     (when show-default-team
-       [:> dropdown-menu-item* {:on-click    on-team-click
-                                :data-value  (:default-team-id profile)
-                                :class       (stl/css :team-dropdown-item)}
-        [:span {:class (stl/css :penpot-icon)} deprecated-icon/logo-icon]
+     [:> dropdown-menu-item* {:on-click    on-team-click
+                              :data-value  (:default-team-id profile)
+                              :class       (stl/css :team-dropdown-item)}
+      [:span {:class (stl/css :penpot-icon)} deprecated-icon/logo-icon]

-        [:span {:class (stl/css :team-text)} (tr "dashboard.your-penpot")]
-        (when (= (:default-team-id profile) (:id team))
-          tick-icon)])
+      [:span {:class (stl/css :team-text)} (tr "dashboard.your-penpot")]
+      (when (= (:default-team-id profile) (:id team))
+        tick-icon)]

     (for [team-item (remove :is-default (vals teams))]
       [:> dropdown-menu-item* {:on-click    on-team-click
@@ -329,19 +322,11 @@
        (when (= (:id team-item) (:id team))
          tick-icon)])

-     (when allow-create-teams
-       [:hr {:role "separator" :class (stl/css :team-separator)}]
-       [:> dropdown-menu-item* {:on-click    on-create-team-click
-                                :class       (stl/css :team-dropdown-item :action)}
-        [:span {:class (stl/css :icon-wrapper)} add-icon]
-        [:span {:class (stl/css :team-text)} (tr "dashboard.create-new-team")]])
-
-     (when allow-create-org
-       [:hr {:role "separator" :class (stl/css :team-separator)}]
-       [:> dropdown-menu-item* {:on-click    on-create-org-click
-                                :class       (stl/css :team-dropdown-item :action)}
-        [:span {:class (stl/css :icon-wrapper)} add-icon]
-        [:span {:class (stl/css :team-text)} (tr "dashboard.create-new-org")]])]))
+     [:hr {:role "separator" :class (stl/css :team-separator)}]
+     [:> dropdown-menu-item* {:on-click    on-create-click
+                              :class       (stl/css :team-dropdown-item :action)}
+      [:span {:class (stl/css :icon-wrapper)} add-icon]
+      [:span {:class (stl/css :team-text)} (tr "dashboard.create-new-team")]]]))

 (mf/defc team-options-dropdown*
  {::mf/private true}
@@ -491,80 +476,9 @@
                                :data-testid "delete-team"}
        (tr "dashboard.delete-team")])]))

-
-(mf/defc sidebar-org-switch*
-  [{:keys [team profile]}]
-  (let [teams (->> (mf/deref refs/teams)
-                   vals
-                   (group-by :organization-id)
-                   (map (fn [[_group entries]] (first entries)))
-                   vec
-                   (d/index-by :id))
-
-        teams (update-vals teams
-                           (fn [t]
-                             (assoc t :name (str "ORG: " (:organization-name t)))))
-
-        team (assoc team :name (str "ORG: " (:organization-name team)))
-
-        show-teams-menu*
-        (mf/use-state false)
-
-        show-teams-menu?
-        (deref show-teams-menu*)
-
-        on-show-teams-click
-        (mf/use-fn
-         (fn [event]
-           (dom/stop-propagation event)
-           (swap! show-teams-menu* not)))
-
-        on-show-teams-keydown
-        (mf/use-fn
-         (fn [event]
-           (when (or (kbd/space? event)
-                     (kbd/enter? event))
-             (dom/prevent-default event)
-             (dom/stop-propagation event)
-             (some-> (dom/get-current-target event)
-                     (dom/click!)))))
-        close-teams-menu
-        (mf/use-fn #(reset! show-teams-menu* false))]
-
-    [:div {:class (stl/css :sidebar-team-switch)}
-     [:div {:class (stl/css :switch-content)}
-      [:button {:class (stl/css :current-team)
-                :on-click on-show-teams-click
-                :on-key-down on-show-teams-keydown}
-
-       [:div {:class (stl/css :team-name)}
-        [:img {:src (cf/resolve-team-photo-url team)
-               :class (stl/css :team-picture)
-               :alt (:name team)}]
-        [:span {:class (stl/css :team-text) :title (:name team)} (:name team)]]
-
-       arrow-icon]]
-
-     ;; Teams Dropdown
-
-     [:> teams-selector-dropdown* {:show show-teams-menu?
-                                   :on-close close-teams-menu
-                                   :id "organizations-list"
-                                   :class (stl/css :dropdown :teams-dropdown)
-                                   :team team
-                                   :profile profile
-                                   :teams teams
-                                   :show-default-team false
-                                   :allow-create-teams false
-                                   :allow-create-org true}]]))
-
 (mf/defc sidebar-team-switch*
  [{:keys [team profile]}]
-  (let [nitrate?     (contains? cf/flags :nitrate)
-        org-id (when nitrate? (:organization-id team))
-        teams (cond->> (mf/deref refs/teams)
-                nitrate?
-                (filter #(= (-> % val :organization-id) org-id)))
+  (let [teams (mf/deref refs/teams)

        subscription
        (get team :subscription)
@@ -672,10 +586,7 @@
                                   :class (stl/css :dropdown :teams-dropdown)
                                   :team team
                                   :profile profile
-                                   :teams teams
-                                   :show-default-team true
-                                   :allow-create-teams true
-                                   :allow-create-org false}]
+                                   :teams teams}]

     [:> team-options-dropdown* {:show show-team-options-menu?
                                 :on-close close-team-options-menu
@@ -792,8 +703,6 @@
    [:*
     [:div {:class (stl/css-case :sidebar-content true)
            :ref container}
-      (when (contains? cf/flags :nitrate)
-        [:> sidebar-org-switch* {:team team :profile profile}])
      [:> sidebar-team-switch* {:team team :profile profile}]

      [:> sidebar-search* {:search-term search-term
--- a/frontend/src/app/main/ui/delete_shared.scss
+++ b/frontend/src/app/main/ui/delete_shared.scss
@@ -45,7 +45,7 @@
 .element-list {
  @include t.use-typography("body-large");
  color: var(--modal-text-foreground-color);
-  overflow-y: auto;
+  overflow-y: scroll;
  margin-block: 0;
 }

--- a/frontend/src/app/main/ui/ds/layers/layer_button.cljs
+++ b/frontend/src/app/main/ui/ds/layers/layer_button.cljs
@@ -1,49 +0,0 @@
-;; This Source Code Form is subject to the terms of the Mozilla Public
-;; License, v. 2.0. If a copy of the MPL was not distributed with this
-;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
-;;
-;; Copyright (c) KALEIDOS INC
-
-(ns app.main.ui.ds.layers.layer-button
-  (:require-macros
-   [app.main.style :as stl])
-  (:require
-   [app.main.ui.ds.foundations.assets.icon :as i :refer [icon*]]
-   [rumext.v2 :as mf]))
-
-(def ^:private schema:layer-button
-  [:map
-   [:label :string]
-   [:description {:optional true} [:maybe :string]]
-   [:class {:optional true} :string]
-   [:expandable {:optional true} :boolean]
-   [:expanded {:optional true} :boolean]
-   [:icon {:optional true} :string]
-   [:on-toggle-expand fn?]])
-
-(mf/defc layer-button*
-  {::mf/schema schema:layer-button}
-  [{:keys [label description class is-expandable expanded icon on-toggle-expand children] :rest props}]
-  (let [button-props (mf/spread-props props
-                                      {:class [class (stl/css-case :layer-button true
-                                                                   :layer-button--expandable is-expandable
-                                                                   :layer-button--expanded expanded)]
-                                       :type "button"
-                                       :on-click on-toggle-expand})]
-    [:div {:class (stl/css :layer-button-wrapper)}
-     [:> "button" button-props
-      [:div {:class (stl/css :layer-button-content)}
-       (when is-expandable
-         (if expanded
-           [:> icon* {:icon-id i/arrow-down :class (stl/css :folder-node-icon)}]
-           [:> icon* {:icon-id i/arrow-right :class (stl/css :folder-node-icon)}]))
-       (when icon
-         [:> icon* {:icon-id icon :class (stl/css :layer-button-icon)}])
-       [:span {:class (stl/css :layer-button-name)}
-        label]
-       (when description
-         [:span {:class (stl/css :layer-button-description)}
-          description])
-       [:span {:class (stl/css :layer-button-quantity)}]]]
-     [:div {:class (stl/css :layer-button-actions)}
-      children]]))
--- a/frontend/src/app/main/ui/ds/layers/layer_button.scss
+++ b/frontend/src/app/main/ui/ds/layers/layer_button.scss
@@ -1,56 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-//
-// Copyright (c) KALEIDOS INC
-
-@use "ds/_borders.scss" as *;
-@use "ds/_sizes.scss" as *;
-@use "ds/typography.scss" as *;
-@use "ds/colors.scss" as *;
-
-.layer-button-wrapper {
-  --layer-button-block-size: #{$sz-32};
-  --layer-button-background: var(--color-background-primary);
-  --layer-button-text: var(--color-foreground-secondary);
-
-  display: flex;
-  justify-content: space-between;
-
-  block-size: var(--layer-button-block-size);
-
-  background: var(--layer-button-background);
-  color: var(--layer-button-text);
-}
-
-.layer-button {
-  @include use-typography("body-small");
-
-  appearance: none;
-
-  flex: 1;
-  display: flex;
-  align-items: center;
-
-  border: none;
-  background: none;
-  color: inherit;
-}
-
-.layer-button--expanded {
-  & .layer-button-name {
-    color: var(--color-foreground-primary);
-  }
-}
-
-.layer-button-content {
-  display: flex;
-  align-items: center;
-  gap: var(--sp-xs);
-}
-
-.layer-button-description {
-  padding: var(--sp-xs);
-  background-color: var(--color-background-tertiary);
-  border-radius: $br-6;
-}
--- a/frontend/src/app/main/ui/exports/assets.cljs
+++ b/frontend/src/app/main/ui/exports/assets.cljs
@@ -223,30 +223,24 @@
        circ              (* 2 Math/PI 12)
        pct               (- circ (* circ (/ progress total)))

-        pwidth
-        (if error?
-          280
-          (/ (* progress 280) total))
+        pwidth (if error?
+                 280
+                 (/ (* progress 280) total))
+        color  (cond
+                 error?         clr/new-danger
+                 healthy?       (if is-default-theme?
+                                  clr/new-primary
+                                  clr/new-primary-light)
+                 (not healthy?) clr/new-warning)

-        color
-        (cond
-          error?         clr/new-danger
-          healthy?       (if is-default-theme?
-                           clr/new-primary
-                           clr/new-primary-light)
-          (not healthy?) clr/new-warning)
-
-        background-clr
-        (if is-default-theme?
-          clr/background-quaternary
-          clr/background-quaternary-light)
-
-        title
-        (cond
-          error?          (tr "workspace.options.exporting-object-error")
-          complete?       (tr "workspace.options.exporting-complete")
-          healthy?        (tr "workspace.options.exporting-object")
-          (not healthy?)  (tr "workspace.options.exporting-object-slow"))
+        background-clr (if is-default-theme?
+                         clr/background-quaternary
+                         clr/background-quaternary-light)
+        title  (cond
+                 error?          (tr "workspace.options.exporting-object-error")
+                 complete?       (tr "workspace.options.exporting-complete")
+                 healthy?        (tr "workspace.options.exporting-object")
+                 (not healthy?)  (tr "workspace.options.exporting-object-slow"))

        retry-last-export
        (mf/use-fn #(st/emit! (de/retry-last-export)))
@@ -290,7 +284,7 @@
                     :on-click retry-last-export}
            (tr "workspace.options.retry")]

-           [:span {:class (stl/css :progress)}
+           [:p {:class (stl/css :progress)}
            (dm/str progress " / " total)])]

        [:button {:class (stl/css :progress-close-button)
--- a/frontend/src/app/main/ui/flex_controls/gap.cljs
+++ b/frontend/src/app/main/ui/flex_controls/gap.cljs
@@ -7,7 +7,6 @@
 (ns app.main.ui.flex-controls.gap
  (:require
   [app.common.data :as d]
-   [app.common.data.macros :as dm]
   [app.common.files.helpers :as cfh]
   [app.common.geom.point :as gpt]
   [app.common.geom.shapes :as gsh]
@@ -17,8 +16,6 @@
   [app.common.types.shape.layout :as ctl]
   [app.main.data.helpers :as dsh]
   [app.main.data.workspace.modifiers :as dwm]
-   [app.main.data.workspace.transforms :as dwt]
-   [app.main.features :as features]
   [app.main.refs :as refs]
   [app.main.store :as st]
   [app.main.ui.css-cursors :as cur]
@@ -30,11 +27,10 @@
 (mf/defc gap-display
  [{:keys [frame-id zoom gap-type gap on-pointer-enter on-pointer-leave
           rect-data hover? selected? mouse-pos hover-value
-           on-move-selected on-context-menu on-change]}]
+           on-move-selected on-context-menu]}]
  (let [resizing             (mf/use-var nil)
        start                (mf/use-var nil)
        original-value       (mf/use-var 0)
-        last-pos             (mf/use-var nil)
        negate?              (:resize-negate? rect-data)
        axis                 (:resize-axis rect-data)

@@ -47,55 +43,32 @@
           (reset! start (dom/get-client-position event))
           (reset! original-value (:initial-value rect-data))))

-        calc-modifiers
-        (mf/use-fn
-         (mf/deps frame-id gap-type gap)
-         (fn [pos]
-           (let [delta
-                 (-> (gpt/to-vec @start pos)
-                     (cond-> negate? gpt/negate)
-                     (get axis))
-                 val
-                 (int (max (+ @original-value (/ delta zoom)) 0))
-
-                 layout-gap (assoc gap gap-type val)]
-             [val
-              (dwm/create-modif-tree
-               [frame-id]
-               (ctm/change-property (ctm/empty) :layout-gap layout-gap))])))
-
        on-lost-pointer-capture
        (mf/use-fn
-         (mf/deps calc-modifiers)
+         (mf/deps frame-id gap-type gap)
         (fn [event]
           (dom/release-pointer event)
-
-           (when (and (features/active-feature? @st/state "render-wasm/v1") (= @resizing gap-type))
-             (let [[_ modifiers]  (calc-modifiers @last-pos)]
-               (st/emit! (dwm/apply-wasm-modifiers modifiers)
-                         (dwt/finish-transform))))
-
           (reset! resizing nil)
           (reset! start nil)
           (reset! original-value 0)
-           (when (not (features/active-feature? @st/state "render-wasm/v1"))
-             (st/emit! (dwm/apply-modifiers)))))
+           (st/emit! (dwm/apply-modifiers))))

        on-pointer-move
        (mf/use-fn
-         (mf/deps calc-modifiers on-change)
+         (mf/deps frame-id gap-type gap)
         (fn [event]
           (let [pos (dom/get-client-position event)]
-             (reset! last-pos pos)
             (reset! mouse-pos (point->viewport pos))
             (when (= @resizing gap-type)
-               (let [[val modifiers]  (calc-modifiers pos)]
+               (let [delta      (-> (gpt/to-vec @start pos)
+                                    (cond-> negate? gpt/negate)
+                                    (get axis))
+                     val            (int (max (+ @original-value (/ delta zoom)) 0))
+                     layout-gap (assoc gap gap-type val)
+                     modifiers  (dwm/create-modif-tree [frame-id] (ctm/change-property (ctm/empty) :layout-gap layout-gap))]
+
                 (reset! hover-value val)
-                 (if (features/active-feature? @st/state "render-wasm/v1")
-                   (st/emit! (dwm/set-wasm-modifiers modifiers))
-                   (st/emit! (dwm/set-modifiers modifiers)))
-                 (when on-change
-                   (on-change modifiers)))))))]
+                 (st/emit! (dwm/set-modifiers modifiers)))))))]

    [:g.gap-rect
     [:rect.info-area
@@ -147,17 +120,10 @@
        pill-width                 (/ fcc/flex-display-pill-width zoom)
        pill-height                (/ fcc/flex-display-pill-height zoom)
        workspace-modifiers        (mf/deref refs/workspace-modifiers)
-        workspace-wasm-modifiers   (mf/deref refs/workspace-wasm-modifiers)
-
        gap-selected               (mf/deref refs/workspace-gap-selected)
        hover                      (mf/use-state nil)
        hover-value                (mf/use-state 0)
        mouse-pos                  (mf/use-state nil)
-        current-modifiers          (mf/use-state nil)
-
-        frame
-        (ctm/apply-structure-modifiers frame (dm/get-in @current-modifiers [frame-id :modifiers]))
-
        padding                    (:layout-padding frame)
        gap                        (:layout-gap frame)
        {:keys [width height x1 y1]} (:selrect frame)
@@ -166,12 +132,6 @@
                                     (reset! hover-value val))

        on-pointer-leave           #(reset! hover nil)
-
-        on-change
-        (mf/use-fn
-         (fn [modifiers]
-           (reset! current-modifiers modifiers)))
-
        negate                     {:column-gap (if flip-x true false)
                                    :row-gap (if flip-y true false)}

@@ -183,16 +143,8 @@
                                    (= :column-reverse saved-dir))
                              (drop-last children)
                              (rest children))
-        children-to-display
-        (if (features/active-feature? @st/state "render-wasm/v1")
-          (let [modifiers (into {} workspace-wasm-modifiers)]
-            (->> children-to-display
-                 ;;(map #(gsh/transform-shape % (get-in workspace-modifiers [(:id %) :modifiers])))
-                 (map (fn [shape]
-                        (gsh/apply-transform shape (get modifiers (:id shape)))))))
-
-          (->> children-to-display
-               (map #(gsh/transform-shape % (get-in workspace-modifiers [(:id %) :modifiers])))))
+        children-to-display (->> children-to-display
+                                 (map #(gsh/transform-shape % (get-in workspace-modifiers [(:id %) :modifiers]))))

        wrap-blocks
        (let [block-children (->> children
@@ -320,22 +272,20 @@
    [:g.gaps {:pointer-events "visible"}
     (for [[index display-item] (d/enumerate (concat display-blocks display-children))]
       (let [gap-type (:gap-type display-item)]
-         [:& gap-display
-          {:key (str frame-id index)
-           :frame-id frame-id
-           :zoom zoom
-           :gap-type gap-type
-           :gap gap
-           :on-pointer-enter (partial on-pointer-enter gap-type (get gap gap-type))
-           :on-pointer-leave on-pointer-leave
-           :on-move-selected on-move-selected
-           :on-context-menu on-context-menu
-           :on-change on-change
-           :rect-data display-item
-           :hover?    (= @hover gap-type)
-           :selected? (= gap-selected gap-type)
-           :mouse-pos mouse-pos
-           :hover-value hover-value}]))
+         [:& gap-display {:key (str frame-id index)
+                          :frame-id frame-id
+                          :zoom zoom
+                          :gap-type gap-type
+                          :gap gap
+                          :on-pointer-enter (partial on-pointer-enter gap-type (get gap gap-type))
+                          :on-pointer-leave on-pointer-leave
+                          :on-move-selected on-move-selected
+                          :on-context-menu on-context-menu
+                          :rect-data display-item
+                          :hover?    (= @hover gap-type)
+                          :selected? (= gap-selected gap-type)
+                          :mouse-pos mouse-pos
+                          :hover-value hover-value}]))

     (when @hover
       [:& fcc/flex-display-pill
--- a/frontend/src/app/main/ui/flex_controls/margin.cljs
+++ b/frontend/src/app/main/ui/flex_controls/margin.cljs
@@ -6,12 +6,9 @@

 (ns app.main.ui.flex-controls.margin
  (:require
-   [app.common.data.macros :as dm]
   [app.common.geom.point :as gpt]
   [app.common.types.modifiers :as ctm]
   [app.main.data.workspace.modifiers :as dwm]
-   [app.main.data.workspace.transforms :as dwt]
-   [app.main.features :as features]
   [app.main.refs :as refs]
   [app.main.store :as st]
   [app.main.ui.css-cursors :as cur]
@@ -20,14 +17,11 @@
   [app.util.dom :as dom]
   [rumext.v2 :as mf]))

-(mf/defc margin-display
-  [{:keys [shape-id zoom hover-all? hover-v? hover-h? margin-num margin
-           on-pointer-enter on-pointer-leave on-change
-           rect-data hover? selected? mouse-pos hover-value]}]
+(mf/defc margin-display [{:keys [shape-id zoom hover-all? hover-v? hover-h? margin-num margin on-pointer-enter on-pointer-leave
+                                 rect-data hover? selected? mouse-pos hover-value]}]
  (let [resizing?            (mf/use-var false)
        start                (mf/use-var nil)
        original-value       (mf/use-var 0)
-        last-pos             (mf/use-var nil)
        negate?              (true? (:resize-negate? rect-data))
        axis                 (:resize-axis rect-data)

@@ -40,69 +34,39 @@
           (reset! start (dom/get-client-position event))
           (reset! original-value (:initial-value rect-data))))

-        calc-modifiers
-        (mf/use-fn
-         (mf/deps shape-id margin-num margin hover-all? hover-v? hover-h?)
-         (fn [pos]
-           (let [delta
-                 (-> (gpt/to-vec @start pos)
-                     (cond-> negate? gpt/negate)
-                     (get axis))
-
-                 val
-                 (int (max (+ @original-value (/ delta zoom)) 0))
-
-                 layout-item-margin
-                 (cond
-                   hover-all? (assoc margin :m1 val :m2 val :m3 val :m4 val)
-                   hover-v?   (assoc margin :m1 val :m3 val)
-                   hover-h?   (assoc margin :m2 val :m4 val)
-                   :else      (assoc margin margin-num val))
-
-                 layout-item-margin-type
-                 (if (= (:m1 margin) (:m2 margin) (:m3 margin) (:m4 margin)) :simple :multiple)]
-
-             [val
-              (dwm/create-modif-tree
-               [shape-id]
-               (-> (ctm/empty)
-                   (ctm/change-property  :layout-item-margin layout-item-margin)
-                   (ctm/change-property  :layout-item-margin-type layout-item-margin-type)))])))
-
        on-lost-pointer-capture
        (mf/use-fn
-         (mf/deps calc-modifiers)
+         (mf/deps shape-id margin-num margin)
         (fn [event]
           (dom/release-pointer event)
-
-           (when (features/active-feature? @st/state "render-wasm/v1")
-             (let [[_ modifiers]  (calc-modifiers @last-pos)]
-               (st/emit! (dwm/apply-wasm-modifiers modifiers)
-                         (dwt/finish-transform))))
-
           (reset! resizing? false)
           (reset! start nil)
           (reset! original-value 0)
-
-           (when (not (features/active-feature? @st/state "render-wasm/v1"))
-             (st/emit! (dwm/apply-modifiers)))))
+           (st/emit! (dwm/apply-modifiers))))

        on-pointer-move
        (mf/use-fn
-         (mf/deps calc-modifiers on-change)
+         (mf/deps shape-id margin-num margin hover-all? hover-v? hover-h?)
         (fn [event]
           (let [pos (dom/get-client-position event)]
             (reset! mouse-pos (point->viewport pos))
-             (reset! last-pos pos)
             (when @resizing?
-               (let [[val modifiers] (calc-modifiers pos)]
+               (let [delta          (-> (gpt/to-vec @start pos)
+                                        (cond-> negate? gpt/negate)
+                                        (get axis))
+                     val            (int (max (+ @original-value (/ delta zoom)) 0))
+                     layout-item-margin (cond
+                                          hover-all? (assoc margin :m1 val :m2 val :m3 val :m4 val)
+                                          hover-v?   (assoc margin :m1 val :m3 val)
+                                          hover-h?   (assoc margin :m2 val :m4 val)
+                                          :else      (assoc margin margin-num val))
+                     layout-item-margin-type (if (= (:m1 margin) (:m2 margin) (:m3 margin) (:m4 margin)) :simple :multiple)
+                     modifiers      (dwm/create-modif-tree [shape-id]
+                                                           (-> (ctm/empty)
+                                                               (ctm/change-property  :layout-item-margin layout-item-margin)
+                                                               (ctm/change-property  :layout-item-margin-type layout-item-margin-type)))]
                 (reset! hover-value val)
-                 (if (features/active-feature? @st/state "render-wasm/v1")
-                   (st/emit! (dwm/set-wasm-modifiers modifiers))
-                   (st/emit! (dwm/set-modifiers modifiers)))
-
-                 (when on-change
-                   (on-change modifiers)))))))]
+                 (st/emit! (dwm/set-modifiers modifiers)))))))]

    [:rect.margin-rect
     {:x (:x rect-data)
@@ -125,11 +89,6 @@
        pill-width                 (/ fcc/flex-display-pill-width zoom)
        pill-height                (/ fcc/flex-display-pill-height zoom)
        margins-selected           (mf/deref refs/workspace-margins-selected)
-        current-modifiers          (mf/use-state nil)
-
-        shape
-        (ctm/apply-structure-modifiers shape (dm/get-in @current-modifiers [shape-id :modifiers]))
-
        hover-value                (mf/use-state 0)
        mouse-pos                  (mf/use-state nil)
        hover                      (mf/use-state nil)
@@ -138,67 +97,50 @@
        hover-h?                   (and (or (= @hover :m2) (= @hover :m4)) shift?)
        margin                    (:layout-item-margin shape)
        {:keys [width height x1 x2 y1 y2]} (:selrect shape)
-
-        on-pointer-enter
-        (mf/use-fn
-         (fn [hover-type val]
-           (reset! hover hover-type)
-           (reset! hover-value val)))
-
-        on-pointer-leave
-        (mf/use-fn
-         (fn []
-           (reset! hover nil)))
-
-        on-change
-        (mf/use-fn
-         (fn [modifiers]
-           (reset! current-modifiers modifiers)))
-
-        hover?
-        (fn [value]
-          (or hover-all?
-              (and (or (= value :m1) (= value :m3)) hover-v?)
-              (and (or (= value :m2) (= value :m4)) hover-h?)
-              (= @hover value)))
-
-        margin-display-data
-        {:m1 {:key (str shape-id "-m1")
-              :x x1
-              :y (if (:flip-y frame) y2 (- y1 (:m1 margin)))
-              :width width
-              :height (:m1 margin)
-              :initial-value (:m1 margin)
-              :resize-type :top
-              :resize-axis :y
-              :resize-negate? (:flip-y frame)}
-         :m2 {:key (str shape-id "-m2")
-              :x (if (:flip-x frame) (- x1 (:m2 margin)) x2)
-              :y y1
-              :width (:m2 margin)
-              :height height
-              :initial-value (:m2 margin)
-              :resize-type :left
-              :resize-axis :x
-              :resize-negate? (:flip-x frame)}
-         :m3 {:key (str shape-id "-m3")
-              :x x1
-              :y (if (:flip-y frame) (- y1 (:m3 margin)) y2)
-              :width width
-              :height (:m3 margin)
-              :initial-value (:m3 margin)
-              :resize-type :top
-              :resize-axis :y
-              :resize-negate? (:flip-y frame)}
-         :m4 {:key (str shape-id "-m4")
-              :x (if (:flip-x frame) x2 (- x1 (:m4 margin)))
-              :y y1
-              :width (:m4 margin)
-              :height height
-              :initial-value (:m4 margin)
-              :resize-type :left
-              :resize-axis :x
-              :resize-negate? (:flip-x frame)}}]
+        on-pointer-enter          (fn [hover-type val]
+                                    (reset! hover hover-type)
+                                    (reset! hover-value val))
+        on-pointer-leave           #(reset! hover nil)
+        hover? #(or hover-all?
+                    (and (or (= % :m1) (= % :m3)) hover-v?)
+                    (and (or (= % :m2) (= % :m4)) hover-h?)
+                    (= @hover %))
+        margin-display-data       {:m1 {:key (str shape-id "-m1")
+                                        :x x1
+                                        :y (if (:flip-y frame) y2 (- y1 (:m1 margin)))
+                                        :width width
+                                        :height (:m1 margin)
+                                        :initial-value (:m1 margin)
+                                        :resize-type :top
+                                        :resize-axis :y
+                                        :resize-negate? (:flip-y frame)}
+                                   :m2 {:key (str shape-id "-m2")
+                                        :x (if (:flip-x frame) (- x1 (:m2 margin)) x2)
+                                        :y y1
+                                        :width (:m2 margin)
+                                        :height height
+                                        :initial-value (:m2 margin)
+                                        :resize-type :left
+                                        :resize-axis :x
+                                        :resize-negate? (:flip-x frame)}
+                                   :m3 {:key (str shape-id "-m3")
+                                        :x x1
+                                        :y (if (:flip-y frame) (- y1 (:m3 margin)) y2)
+                                        :width width
+                                        :height (:m3 margin)
+                                        :initial-value (:m3 margin)
+                                        :resize-type :top
+                                        :resize-axis :y
+                                        :resize-negate? (:flip-y frame)}
+                                   :m4 {:key (str shape-id "-m4")
+                                        :x (if (:flip-x frame) x2 (- x1 (:m4 margin)))
+                                        :y y1
+                                        :width (:m4 margin)
+                                        :height height
+                                        :initial-value (:m4 margin)
+                                        :resize-type :left
+                                        :resize-axis :x
+                                        :resize-negate? (:flip-x frame)}}]

    [:g.margins {:pointer-events "visible"}
     (for [[margin-num rect-data] margin-display-data]
@@ -213,7 +155,6 @@
         :margin margin
         :on-pointer-enter (partial on-pointer-enter margin-num (get margin margin-num))
         :on-pointer-leave on-pointer-leave
-         :on-change on-change
         :rect-data rect-data
         :hover?  (hover? margin-num)
         :selected? (get margins-selected margin-num)
--- a/frontend/src/app/main/ui/flex_controls/padding.cljs
+++ b/frontend/src/app/main/ui/flex_controls/padding.cljs
@@ -6,12 +6,9 @@

 (ns app.main.ui.flex-controls.padding
  (:require
-   [app.common.data.macros :as dm]
   [app.common.geom.point :as gpt]
   [app.common.types.modifiers :as ctm]
   [app.main.data.workspace.modifiers :as dwm]
-   [app.main.data.workspace.transforms :as dwt]
-   [app.main.features :as features]
   [app.main.refs :as refs]
   [app.main.store :as st]
   [app.main.ui.css-cursors :as cur]
@@ -21,13 +18,11 @@
   [rumext.v2 :as mf]))

 (mf/defc padding-display
-  [{:keys [frame-id zoom hover-all? hover-v? hover-h? padding-num padding on-pointer-enter
-           on-pointer-leave rect-data hover? selected? mouse-pos hover-value on-move-selected
-           on-context-menu on-change]}]
+  [{:keys [frame-id zoom hover-all? hover-v? hover-h? padding-num padding on-pointer-enter on-pointer-leave
+           rect-data hover? selected? mouse-pos hover-value on-move-selected on-context-menu]}]
  (let [resizing?            (mf/use-var false)
        start                (mf/use-var nil)
        original-value       (mf/use-var 0)
-        last-pos             (mf/use-var nil)
        negate?              (true? (:resize-negate? rect-data))
        axis                 (:resize-axis rect-data)

@@ -40,69 +35,41 @@
           (reset! start (dom/get-client-position event))
           (reset! original-value (:initial-value rect-data))))

-        calc-modifiers
-        (mf/use-fn
-         (mf/deps frame-id padding-num padding hover-all? hover-v? hover-h?)
-         (fn [pos]
-           (let [delta
-                 (-> (gpt/to-vec @start pos)
-                     (cond-> negate? gpt/negate)
-                     (get axis))
-
-                 val
-                 (int (max (+ @original-value (/ delta zoom)) 0))
-
-                 layout-padding
-                 (cond
-                   hover-all? (assoc padding :p1 val :p2 val :p3 val :p4 val)
-                   hover-v?   (assoc padding :p1 val :p3 val)
-                   hover-h?   (assoc padding :p2 val :p4 val)
-                   :else      (assoc padding padding-num val))
-
-
-                 layout-padding-type
-                 (if (= (:p1 padding) (:p2 padding) (:p3 padding) (:p4 padding)) :simple :multiple)]
-             [val
-              (dwm/create-modif-tree
-               [frame-id]
-               (-> (ctm/empty)
-                   (ctm/change-property  :layout-padding layout-padding)
-                   (ctm/change-property  :layout-padding-type layout-padding-type)))])))
-
        on-lost-pointer-capture
        (mf/use-fn
-         (mf/deps calc-modifiers)
+         (mf/deps frame-id padding-num padding)
         (fn [event]
           (dom/release-pointer event)
-
-           (when (features/active-feature? @st/state "render-wasm/v1")
-             (let [[_ modifiers]  (calc-modifiers @last-pos)]
-               (st/emit! (dwm/apply-wasm-modifiers modifiers)
-                         (dwt/finish-transform))))
-
           (reset! resizing? false)
           (reset! start nil)
           (reset! original-value 0)
-
-           (when (not (features/active-feature? @st/state "render-wasm/v1"))
-             (st/emit! (dwm/apply-modifiers)))))
+           (st/emit! (dwm/apply-modifiers))))

        on-pointer-move
        (mf/use-fn
-         (mf/deps calc-modifiers on-change)
+         (mf/deps frame-id padding-num padding hover-all? hover-v? hover-h?)
         (fn [event]
           (let [pos (dom/get-client-position event)]
             (reset! mouse-pos (point->viewport pos))
-             (reset! last-pos pos)
             (when @resizing?
-               (let [[val modifiers] (calc-modifiers pos)]
-                 (reset! hover-value val)
-                 (if (features/active-feature? @st/state "render-wasm/v1")
-                   (st/emit! (dwm/set-wasm-modifiers modifiers))
-                   (st/emit! (dwm/set-modifiers modifiers)))
+               (let [delta               (-> (gpt/to-vec @start pos)
+                                             (cond-> negate? gpt/negate)
+                                             (get axis))
+                     val                 (int (max (+ @original-value (/ delta zoom)) 0))
+                     layout-padding      (cond
+                                           hover-all? (assoc padding :p1 val :p2 val :p3 val :p4 val)
+                                           hover-v?   (assoc padding :p1 val :p3 val)
+                                           hover-h?   (assoc padding :p2 val :p4 val)
+                                           :else      (assoc padding padding-num val))

-                 (when on-change
-                   (on-change modifiers)))))))]
+
+                     layout-padding-type (if (= (:p1 padding) (:p2 padding) (:p3 padding) (:p4 padding)) :simple :multiple)
+                     modifiers           (dwm/create-modif-tree [frame-id]
+                                                                (-> (ctm/empty)
+                                                                    (ctm/change-property  :layout-padding layout-padding)
+                                                                    (ctm/change-property  :layout-padding-type layout-padding-type)))]
+                 (reset! hover-value val)
+                 (st/emit! (dwm/set-modifiers modifiers)))))))]

    [:g.padding-rect
     [:rect.info-area
@@ -138,108 +105,77 @@
         :on-lost-pointer-capture on-lost-pointer-capture
         :on-pointer-move on-pointer-move
         :on-context-menu on-context-menu
-         :class
-         (when (or hover? selected?)
-           (if (= (:resize-axis rect-data) :x)
-             (cur/get-dynamic "resize-ew" 0)
-             (cur/get-dynamic "resize-ew" 90)))
-
-         :style
-         {:fill (if (or hover? selected?) fcc/distance-color "none")
-          :opacity (if selected? 0 1)}}])]))
+         :class (when (or hover? selected?)
+                  (if (= (:resize-axis rect-data) :x) (cur/get-dynamic "resize-ew" 0) (cur/get-dynamic "resize-ew" 90)))
+         :style {:fill (if (or hover? selected?) fcc/distance-color "none")
+                 :opacity (if selected? 0 1)}}])]))

 (mf/defc padding-rects
  [{:keys [frame zoom alt? shift? on-move-selected on-context-menu]}]
  (let [frame-id                           (:id frame)
        paddings-selected                  (mf/deref refs/workspace-paddings-selected)
-        current-modifiers                  (mf/use-state nil)
-
-        frame
-        (ctm/apply-structure-modifiers frame (dm/get-in @current-modifiers [frame-id :modifiers]))
-
        hover-value                        (mf/use-state 0)
        mouse-pos                          (mf/use-state nil)
        hover                              (mf/use-state nil)
-
        hover-all?                         (and (not (nil? @hover)) alt?)
        hover-v?                           (and (or (= @hover :p1) (= @hover :p3)) shift?)
        hover-h?                           (and (or (= @hover :p2) (= @hover :p4)) shift?)
        padding                            (:layout-padding frame)
        {:keys [width height x1 x2 y1 y2]} (:selrect frame)
+        on-pointer-enter                   (fn [hover-type val]
+                                             (reset! hover hover-type)
+                                             (reset! hover-value val))
+        on-pointer-leave                   #(reset! hover nil)
        pill-width                         (/ fcc/flex-display-pill-width zoom)
        pill-height                        (/ fcc/flex-display-pill-height zoom)
+        hover?                             #(or hover-all?
+                                                (and (or (= % :p1) (= % :p3)) hover-v?)
+                                                (and (or (= % :p2) (= % :p4)) hover-h?)
+                                                (= @hover %))
+        negate                             {:p1 (if (:flip-y frame) true false)
+                                            :p2 (if (:flip-x frame) true false)
+                                            :p3 (if (:flip-y frame) true false)
+                                            :p4 (if (:flip-x frame) true false)}
+        negate                             (cond-> negate
+                                             (not= :auto (:layout-item-h-sizing frame)) (assoc :p2 (not (:p2 negate)))
+                                             (not= :auto (:layout-item-v-sizing frame)) (assoc :p3 (not (:p3 negate))))

-        negate
-        {:p1 (if (:flip-y frame) true false)
-         :p2 (if (:flip-x frame) true false)
-         :p3 (if (:flip-y frame) true false)
-         :p4 (if (:flip-x frame) true false)}
-
-        negate
-        (cond-> negate
-          (not= :auto (:layout-item-h-sizing frame)) (assoc :p2 (not (:p2 negate)))
-          (not= :auto (:layout-item-v-sizing frame)) (assoc :p3 (not (:p3 negate))))
-
-        padding-rect-data
-        {:p1 {:key (str frame-id "-p1")
-              :x x1
-              :y (if (:flip-y frame) (- y2 (:p1 padding)) y1)
-              :width width
-              :height (:p1 padding)
-              :initial-value (:p1 padding)
-              :resize-type (if (:flip-y frame) :bottom :top)
-              :resize-axis :y
-              :resize-negate? (:p1 negate)}
-         :p2 {:key (str frame-id "-p2")
-              :x (if (:flip-x frame) x1 (- x2 (:p2 padding)))
-              :y y1
-              :width (:p2 padding)
-              :height height
-              :initial-value (:p2 padding)
-              :resize-type :left
-              :resize-axis :x
-              :resize-negate? (:p2 negate)}
-         :p3 {:key (str frame-id "-p3")
-              :x x1
-              :y (if (:flip-y frame) y1 (- y2 (:p3 padding)))
-              :width width
-              :height (:p3 padding)
-              :initial-value (:p3 padding)
-              :resize-type :bottom
-              :resize-axis :y
-              :resize-negate? (:p3 negate)}
-         :p4 {:key (str frame-id "-p4")
-              :x (if (:flip-x frame) (- x2 (:p4 padding)) x1)
-              :y y1
-              :width (:p4 padding)
-              :height height
-              :initial-value (:p4 padding)
-              :resize-type (if (:flip-x frame) :right :left)
-              :resize-axis :x
-              :resize-negate? (:p4 negate)}}
-
-        on-pointer-enter
-        (mf/use-fn
-         (fn [hover-type val]
-           (reset! hover hover-type)
-           (reset! hover-value val)))
-
-        on-pointer-leave
-        (mf/use-fn
-         (fn []
-           (reset! hover nil)))
-
-        on-change
-        (mf/use-fn
-         (fn [modifiers]
-           (reset! current-modifiers modifiers)))
-
-        hover?
-        (fn [value]
-          (or hover-all?
-              (and (or (= value :p1) (= value :p3)) hover-v?)
-              (and (or (= value :p2) (= value :p4)) hover-h?)
-              (= @hover value)))]
+        padding-rect-data                  {:p1 {:key (str frame-id "-p1")
+                                                 :x x1
+                                                 :y (if (:flip-y frame) (- y2 (:p1 padding)) y1)
+                                                 :width width
+                                                 :height (:p1 padding)
+                                                 :initial-value (:p1 padding)
+                                                 :resize-type (if (:flip-y frame) :bottom :top)
+                                                 :resize-axis :y
+                                                 :resize-negate? (:p1 negate)}
+                                            :p2 {:key (str frame-id "-p2")
+                                                 :x (if (:flip-x frame) x1 (- x2 (:p2 padding)))
+                                                 :y y1
+                                                 :width (:p2 padding)
+                                                 :height height
+                                                 :initial-value (:p2 padding)
+                                                 :resize-type :left
+                                                 :resize-axis :x
+                                                 :resize-negate? (:p2 negate)}
+                                            :p3 {:key (str frame-id "-p3")
+                                                 :x x1
+                                                 :y (if (:flip-y frame) y1 (- y2 (:p3 padding)))
+                                                 :width width
+                                                 :height (:p3 padding)
+                                                 :initial-value (:p3 padding)
+                                                 :resize-type :bottom
+                                                 :resize-axis :y
+                                                 :resize-negate? (:p3 negate)}
+                                            :p4 {:key (str frame-id "-p4")
+                                                 :x (if (:flip-x frame) (- x2 (:p4 padding)) x1)
+                                                 :y y1
+                                                 :width (:p4 padding)
+                                                 :height height
+                                                 :initial-value (:p4 padding)
+                                                 :resize-type (if (:flip-x frame) :right :left)
+                                                 :resize-axis :x
+                                                 :resize-negate? (:p4 negate)}}]

    [:g.paddings {:pointer-events "visible"}
     (for [[padding-num rect-data] padding-rect-data]
@@ -258,11 +194,9 @@
         :on-pointer-leave on-pointer-leave
         :on-move-selected on-move-selected
         :on-context-menu on-context-menu
-         :on-change on-change
         :hover?  (hover? padding-num)
         :selected? (get paddings-selected padding-num)
         :rect-data rect-data}])
-
     (when @hover
       [:& fcc/flex-display-pill
        {:height pill-height
--- a/frontend/src/app/main/ui/settings/subscription.cljs
+++ b/frontend/src/app/main/ui/settings/subscription.cljs
@@ -77,7 +77,7 @@
     [:button {:class (stl/css :cta-button :bottom-link)
               :on-click cta-link-trial} cta-text-trial])])

-(defn- make-management-form-schema [min-editors]
+(defn schema:seats-form [min-editors]
  [:map {:title "SeatsForm"}
   [:min-members [::sm/number {:min min-editors
                               :max 9999}]]
@@ -87,6 +87,7 @@
  {::mf/register modal/components
   ::mf/register-as :management-dialog}
  [{:keys [subscription-type current-subscription editors subscribe-to-trial]}]
+
  (let [unlimited-modal-step*
        (mf/use-state 1)

@@ -111,12 +112,9 @@
          {:min-members min-editors
           :redirect-to-payment-details false})

-        schema
-        (mf/with-memo [min-editors]
-          (make-management-form-schema min-editors))
-
        form
-        (fm/use-form :schema schema :initial initial)
+        (fm/use-form :schema (schema:seats-form min-editors)
+                     :initial initial)

        submit-in-progress
        (mf/use-ref false)
@@ -336,15 +334,11 @@
        [:> raw-svg* {:id (if (= "light" (:theme profile)) "logo-subscription-light" "logo-subscription")}]]

       [:div {:class (stl/css :modal-end)}
-        [:div {:class (stl/css :modal-title)}
-         (tr "subscription.settings.sucess.dialog.title" subscription-name)]
+        [:div {:class (stl/css :modal-title)} (tr "subscription.settings.sucess.dialog.title" subscription-name)]
        (when (not= subscription-name "professional")
-          [:p {:class (stl/css :modal-text-large)}
-           (tr "subscription.settings.success.dialog.thanks" subscription-name)])
-        [:p {:class (stl/css :modal-text-large)}
-         (tr "subscription.settings.success.dialog.description")]
-        [:p {:class (stl/css :modal-text-large)}
-         (tr "subscription.settings.sucess.dialog.footer")]
+          [:p {:class (stl/css :modal-text-large)} (tr "subscription.settings.success.dialog.thanks" subscription-name)])
+        [:p {:class (stl/css :modal-text-large)} (tr "subscription.settings.success.dialog.description")]
+        [:p {:class (stl/css :modal-text-large)} (tr "subscription.settings.sucess.dialog.footer")]

        [:div {:class (stl/css :success-action-buttons)}
         [:input
@@ -424,11 +418,7 @@
    (mf/with-effect []
      (dom/set-html-title (tr "subscription.labels")))

-    (mf/with-effect [authenticated?
-                     show-subscription-success-modal?
-                     show-trial-subscription-modal?
-                     success-modal-is-trial?
-                     subscription]
+    (mf/with-effect [authenticated? show-subscription-success-modal? show-trial-subscription-modal? success-modal-is-trial? subscription]
      (when ^boolean authenticated?
        (cond
          ^boolean show-trial-subscription-modal?
--- a/frontend/src/app/main/ui/shapes/text.cljs
+++ b/frontend/src/app/main/ui/shapes/text.cljs
@@ -28,7 +28,6 @@
  {::mf/wrap-props false}
  [props]
  (let [{:keys [position-data content] :as shape} (obj/get props "shape")
-        is-render? (mf/use-ctx ctx/is-render?)
        is-component? (mf/use-ctx ctx/is-component?)]

    (mf/with-memo [content]
@@ -42,5 +41,5 @@
      ;; Only use this for component preview, otherwise the dashboard thumbnails
      ;; will give a tainted canvas error because the `foreignObject` cannot be
      ;; rendered.
-      (and (nil? position-data) (or is-component? is-render?))
+      (and (nil? position-data) is-component?)
      [:> fo/text-shape props])))
--- a/frontend/src/app/main/ui/workspace/shapes/text/text_edition_outline.cljs
+++ b/frontend/src/app/main/ui/workspace/shapes/text/text_edition_outline.cljs
@@ -12,20 +12,18 @@
   [app.main.features :as features]
   [app.main.refs :as refs]
   [app.main.store :as st]
-   [app.render-wasm.api :as wasm.api]
   [rumext.v2 :as mf]))

 (mf/defc text-edition-outline
  [{:keys [shape zoom modifiers]}]
  (if (features/active-feature? @st/state "render-wasm/v1")
-    (let [{:keys [width height]} (wasm.api/get-text-dimensions (:id shape))
-          selrect-transform (mf/deref refs/workspace-selrect)
-          [selrect transform] (dsh/get-selrect selrect-transform shape)]
+    (let [selrect-transform (mf/deref refs/workspace-selrect)
+          [{:keys [x y width height]} transform] (dsh/get-selrect selrect-transform shape)]
      [:rect.main.viewport-selrect
-       {:x (:x selrect)
-        :y (:y selrect)
-        :width (max width (:width selrect))
-        :height (max height (:height selrect))
+       {:x x
+        :y y
+        :width width
+        :height height
        :transform transform
        :style {:stroke "var(--color-accent-tertiary)"
                :stroke-width (/ 1 zoom)
--- a/frontend/src/app/main/ui/workspace/shapes/text/v2_editor.cljs
+++ b/frontend/src/app/main/ui/workspace/shapes/text/v2_editor.cljs
@@ -320,12 +320,10 @@

        [{:keys [x y width height]} transform]
        (if render-wasm?
-          (let [{:keys [width height]} (wasm.api/get-text-dimensions shape-id)
+          (let [{:keys [height]} (wasm.api/get-text-dimensions shape-id)
                selrect-transform (mf/deref refs/workspace-selrect)
                [selrect transform] (dsh/get-selrect selrect-transform shape)
                selrect-height (:height selrect)
-                selrect-width (:width selrect)
-                max-width (max width selrect-width)
                max-height (max height selrect-height)
                valign (-> shape :content :vertical-align)
                y (:y selrect)
@@ -333,9 +331,9 @@
                    (case valign
                      "bottom" (- y (- height selrect-height))
                      "center" (- y (/ (- height selrect-height) 2))
-                      y)
+                      "top"    y)
                    y)]
-            [(assoc selrect :y y :width max-width :height max-height) transform])
+            [(assoc selrect :y y :width (:width selrect) :height max-height) transform])

          (let [bounds (gst/shape->rect shape)
                x      (mth/min (dm/get-prop bounds :x)
@@ -354,7 +352,7 @@
          (obj/merge!
           #js {"--editor-container-width" (dm/str width "px")
                "--editor-container-height" (dm/str height "px")
-                "--fallback-families" (if (seq fallback-families) (dm/str (str/join ", " fallback-families)) "sourcesanspro")})
+                "--fallback-families" (dm/str (str/join ", " fallback-families))})

          (not render-wasm?)
          (obj/merge!
--- a/frontend/src/app/main/ui/workspace/sidebar/layer_item.scss
+++ b/frontend/src/app/main/ui/workspace/sidebar/layer_item.scss
@@ -5,7 +5,6 @@
 // Copyright (c) KALEIDOS INC

@use "refactor/common-refactor.scss" as deprecated;
-@use "ds/_utils.scss" as *;

 .layer-row {
  --layer-indentation-size: calc(#{deprecated.$s-4} * 6);
@@ -88,7 +87,7 @@
  height: deprecated.$s-32;
  width: calc(100% - (var(--depth) * var(--layer-indentation-size)));
  cursor: pointer;
-  min-width: px2rem(140);
+
  &.filtered {
    width: calc(100% - deprecated.$s-12);
  }
--- a/frontend/src/app/main/ui/workspace/sidebar/layers.scss
+++ b/frontend/src/app/main/ui/workspace/sidebar/layers.scss
@@ -211,7 +211,9 @@
  overflow-x: auto;
  overflow-y: overlay;
  scrollbar-gutter: stable;
-}
-.element-list {
-  display: grid;
+
+  .element-list {
+    width: var(--left-sidebar-width);
+    display: grid;
+  }
 }
--- a/frontend/src/app/main/ui/workspace/sidebar/options/menus/border_radius.cljs
+++ b/frontend/src/app/main/ui/workspace/sidebar/options/menus/border_radius.cljs
@@ -102,7 +102,7 @@
        [:> deprecated-input/numeric-input*
         {:placeholder (cond
                         (not all-equal?)
-                         (tr "settings.multiple")
+                         "Mixed"
                         (= :multiple (:r1 values))
                         (tr "settings.multiple")
                         :else
--- a/frontend/src/app/main/ui/workspace/sidebar/options/menus/layout_item.cljs
+++ b/frontend/src/app/main/ui/workspace/sidebar/options/menus/layout_item.cljs
@@ -16,7 +16,6 @@
   [app.main.ui.components.numeric-input :as deprecated-input]
   [app.main.ui.components.radio-buttons :refer [radio-button radio-buttons]]
   [app.main.ui.components.title-bar :refer [title-bar*]]
-   [app.main.ui.ds.foundations.assets.icon :as i]
   [app.main.ui.icons :as deprecated-icon]
   [app.main.ui.workspace.sidebar.options.menus.layout-container :refer [get-layout-flex-icon]]
   [app.util.dom :as dom]
@@ -235,20 +234,20 @@

    [:& radio-button
     {:value "fix"
-      :icon  i/fixed-width
+      :icon  deprecated-icon/fixed-width
      :title "Fix width"
      :id    "behaviour-h-fix"}]

    (when has-fill
      [:& radio-button
       {:value "fill"
-        :icon  i/fill-content
+        :icon  deprecated-icon/fill-content
        :title "Width 100%"
        :id    "behaviour-h-fill"}])
    (when is-auto
      [:& radio-button
       {:value "auto"
-        :icon  i/hug-content
+        :icon  deprecated-icon/hug-content
        :title "Fit content (Horizontal)"
        :id    "behaviour-h-auto"}])]])

@@ -269,7 +268,7 @@

    [:& radio-button
     {:value      "fix"
-      :icon       i/fixed-width
+      :icon       deprecated-icon/fixed-width
      :icon-class (stl/css :rotated)
      :title      "Fix height"
      :id         "behaviour-v-fix"}]
@@ -277,14 +276,14 @@
    (when has-fill
      [:& radio-button
       {:value      "fill"
-        :icon       i/fill-content
+        :icon       deprecated-icon/fill-content
        :icon-class (stl/css :rotated)
        :title      "Height 100%"
        :id         "behaviour-v-fill"}])
    (when is-auto
      [:& radio-button
       {:value      "auto"
-        :icon       i/hug-content
+        :icon       deprecated-icon/hug-content
        :icon-class (stl/css :rotated)
        :title      "Fit content (Vertical)"
        :id         "behaviour-v-auto"}])]])
--- a/frontend/src/app/main/ui/workspace/sidebar/options/menus/typography.cljs
+++ b/frontend/src/app/main/ui/workspace/sidebar/options/menus/typography.cljs
@@ -265,13 +265,11 @@
         (mf/deps font on-change)
         (fn [new-variant-id]
           (let [variant (d/seek #(= new-variant-id (:id %)) (:variants font))]
-             (when-not (nil? variant)
-               (on-change {:font-id (:id font)
-                           :font-family (:family font)
-                           :font-variant-id new-variant-id
-                           :font-weight (:weight variant)
-                           :font-style (:style variant)}))
-
+             (on-change {:font-id (:id font)
+                         :font-family (:family font)
+                         :font-variant-id new-variant-id
+                         :font-weight (:weight variant)
+                         :font-style (:style variant)})
             (dom/blur! (dom/get-target new-variant-id)))))

        on-font-select
@@ -344,13 +342,12 @@
                                               {:value (:id variant)
                                                :key (pr-str variant)
                                                :label (:name variant)})))
-             variant-options (if (= font-variant-id :multiple)
+             variant-options (if (= font-size :multiple)
                               (conj basic-variant-options
-                                     {:value ""
+                                     {:value :multiple
                                      :key :multiple-variants
                                      :label "--"})
                               basic-variant-options)]
-
         ;;  TODO Add disabled mode
         [:& select
          {:class (stl/css :font-variant-select)
@@ -382,7 +379,6 @@
        :step 0.1
        :default-value "1.2"
        :class (stl/css :line-height-input)
-        :aria-label (tr "inspect.attributes.typography.line-height")
        :value (attr->string line-height)
        :placeholder (if (= :multiple line-height) (tr "settings.multiple") "--")
        :nillable (= :multiple line-height)
@@ -401,7 +397,6 @@
        :step 0.1
        :default-value "0"
        :class (stl/css :letter-spacing-input)
-        :aria-label (tr "inspect.attributes.typography.letter-spacing")
        :value (attr->string letter-spacing)
        :placeholder (if (= :multiple letter-spacing) (tr "settings.multiple") "--")
        :on-change #(handle-change % :letter-spacing)
--- a/frontend/src/app/main/ui/workspace/sidebar/options/rows/color_row.cljs
+++ b/frontend/src/app/main/ui/workspace/sidebar/options/rows/color_row.cljs
@@ -68,7 +68,7 @@

 (mf/defc color-token-row*
  {::mf/private true}
-  [{:keys [active-tokens applied-token-name color on-swatch-click-token detach-token open-modal-from-token]}]
+  [{:keys [active-tokens color-token color on-swatch-click-token detach-token open-modal-from-token]}]
  (let [;; `active-tokens` may be provided as a `delay` (lazy computation).
        ;; In that case we must deref it (`@active-tokens`) to force evaluation
        ;; and obtain the actual value. If it’s already realized (not a delay),
@@ -77,22 +77,21 @@
                        @active-tokens
                        active-tokens)

-        active-color-tokens (:color active-tokens)
+        color-tokens (:color active-tokens)

-        token (some #(when (= (:name %) applied-token-name) %) active-color-tokens)
+        token (some #(when (= (:name %) color-token) %) color-tokens)

        on-detach-token
        (mf/use-fn
-         (mf/deps detach-token token applied-token-name)
+         (mf/deps detach-token token color-token)
         (fn []
-           (let [token (or token applied-token-name)]
+           (let [token (or token color-token)]
             (detach-token token))))

        has-errors (some? (:errors token))
        token-name (:name token)
        resolved (:resolved-value token)
-        not-active (and (empty? active-tokens)
-                        (nil? token))
+        not-active (and (some? active-tokens) (nil? token))
        id (dm/str (:id token) "-name")
        swatch-tooltip-content (cond
                                 not-active
@@ -110,7 +109,7 @@
                               #(mf/html
                                 [:div
                                  [:span (dm/str (tr "workspace.tokens.token-name") ": ")]
-                                  [:span {:class (stl/css :token-name-tooltip)} applied-token-name]]))]
+                                  [:span {:class (stl/css :token-name-tooltip)} color-token]]))]

    [:div {:class (stl/css :color-info)}
     [:div {:class (stl/css-case :token-color-wrapper true
@@ -129,7 +128,7 @@
                    :class (stl/css :token-tooltip)}
       [:div {:class (stl/css :token-name)
              :aria-labelledby id}
-        (or token-name applied-token-name)]]
+        (or token-name color-token)]]
      [:div {:class (stl/css :token-actions)}
       [:> icon-button*
        {:variant "action"
@@ -147,11 +146,7 @@
           on-change on-reorder on-detach on-open on-close on-remove origin on-detach-token
           disable-drag on-focus on-blur select-only select-on-focus on-token-change applied-token]}]

-  (let [;; TODO: Remove this workaround fixing `get-attrs*` fn on sidebar/options/shapes/multiple.cljs
-        applied-token (if (= :multiple applied-token)
-                        nil
-                        applied-token)
-        token-color      (contains? cfg/flags :token-color)
+  (let [token-color      (contains? cfg/flags :token-color)
        libraries        (mf/deref refs/files)

        color-without-hash (mf/use-memo
@@ -182,6 +177,7 @@
                                (-> (deref active-tokens*)
                                    (select-keys (get tk/tokens-by-input origin))
                                    (not-empty)))))
+
        on-focus'
        (mf/use-fn
         (mf/deps on-focus)
@@ -356,7 +352,7 @@
     (cond
       (and token-color applied-token)
       [:> color-token-row* {:active-tokens tokens
-                             :applied-token-name applied-token
+                             :color-token applied-token
                             :color (dissoc color :ref-id :ref-file)
                             :on-swatch-click-token  on-swatch-click-token
                             :detach-token detach-token
--- a/frontend/src/app/main/ui/workspace/sidebar/options/rows/stroke_row.cljs
+++ b/frontend/src/app/main/ui/workspace/sidebar/options/rows/stroke_row.cljs
@@ -63,8 +63,7 @@
           :data {:index index})
          [nil nil])

-        stroke-color-token
-        (:stroke-color applied-tokens)
+        stroke-color-token (:stroke-color applied-tokens)

        on-color-change-refactor
        (mf/use-fn
--- a/frontend/src/app/main/ui/workspace/tokens/import/modal.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/import/modal.cljs
@@ -268,8 +268,8 @@
                   :on-click modal/hide!}
       (tr "labels.cancel")]
      [:> import-type-dropdown*
-       {:options [{:label (tr "workspace.tokens.import-menu-json-option") :value :file}
-                  {:label (tr "workspace.tokens.import-menu-zip-option") :value :zip}
+       {:options [{:label (tr "workspace.tokens.import-menu-zip-option") :value :zip}
+                  {:label (tr "workspace.tokens.import-menu-json-option") :value :file}
                  {:label (tr "workspace.tokens.import-menu-folder-option") :value :folder}]
        :on-click handle-import-action
        :text-render render-button-text
--- a/frontend/src/app/main/ui/workspace/tokens/management.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management.cljs
@@ -44,39 +44,6 @@
        [(seq (array/sort! empty))
         (seq (array/sort! filled))]))))

-(mf/defc selected-set-info*
-  {::mf/private true}
-  [{:keys [tokens-lib selected-token-set-id]}]
-  (let [selected-token-set
-        (mf/with-memo [tokens-lib]
-          (when selected-token-set-id
-            (some-> tokens-lib (ctob/get-set selected-token-set-id))))
-
-        active-token-sets-names
-        (mf/with-memo [tokens-lib]
-          (some-> tokens-lib (ctob/get-active-themes-set-names)))
-
-        token-set-active?
-        (mf/use-fn
-         (mf/deps active-token-sets-names)
-         (fn [name]
-           (contains? active-token-sets-names name)))]
-    [:div {:class (stl/css :sets-header-container)}
-     [:> text* {:as "span"
-                :typography "headline-small"
-                :class (stl/css :sets-header)}
-      (tr "workspace.tokens.tokens-section-title" (ctob/get-name selected-token-set))]
-     [:div {:class (stl/css :sets-header-status) :title (tr "workspace.tokens.inactive-set-description")}
-        ;; NOTE: when no set in tokens-lib, the selected-token-set-id
-        ;; will be `nil`, so for properly hide the inactive message we
-        ;; check that at least `selected-token-set-id` has a value
-      (when (and (some? selected-token-set-id)
-                 (not (token-set-active? (ctob/get-name selected-token-set))))
-        [:*
-         [:> icon* {:class (stl/css :sets-header-status-icon) :icon-id i/eye-off}]
-         [:> text* {:as "span" :typography "body-small" :class (stl/css :sets-header-status-text)}
-          (tr "workspace.tokens.inactive-set")]])]]))
-
 (mf/defc tokens-section*
  {::mf/private true}
  [{:keys [tokens-lib active-tokens resolved-active-tokens]}]
@@ -98,7 +65,9 @@
        selected-token-set-id
        (mf/deref refs/selected-token-set-id)

-
+        selected-token-set
+        (when selected-token-set-id
+          (some-> tokens-lib (ctob/get-set selected-token-set-id)))

        ;; If we have not selected any set explicitly we just
        ;; select the first one from the list of sets
@@ -123,9 +92,15 @@
                                  tokens)]
            (ctob/group-by-type tokens)))

+        active-token-sets-names
+        (mf/with-memo [tokens-lib]
+          (some-> tokens-lib (ctob/get-active-themes-set-names)))

-
-
+        token-set-active?
+        (mf/use-fn
+         (mf/deps active-token-sets-names)
+         (fn [name]
+           (contains? active-token-sets-names name)))

        [empty-group filled-group]
        (mf/with-memo [tokens-by-type]
@@ -143,27 +118,34 @@

    [:*
     [:& token-context-menu]
-
-     [:& selected-set-info* {:tokens-lib tokens-lib
-                             :selected-token-set-id selected-token-set-id}]
+     [:div {:class (stl/css :sets-header-container)}
+      [:> text* {:as "span" :typography "headline-small" :class (stl/css :sets-header)} (tr "workspace.tokens.tokens-section-title" (ctob/get-name selected-token-set))]
+      [:div {:class (stl/css :sets-header-status) :title (tr "workspace.tokens.inactive-set-description")}
+       ;; NOTE: when no set in tokens-lib, the selected-token-set-id
+       ;; will be `nil`, so for properly hide the inactive message we
+       ;; check that at least `selected-token-set-id` has a value
+       (when (and (some? selected-token-set-id)
+                  (not (token-set-active? (ctob/get-name selected-token-set))))
+         [:*
+          [:> icon* {:class (stl/css :sets-header-status-icon) :icon-id i/eye-off}]
+          [:> text* {:as "span" :typography "body-small" :class (stl/css :sets-header-status-text)}
+           (tr "workspace.tokens.inactive-set")]])]]

     (for [type filled-group]
       (let [tokens (get tokens-by-type type)]
         [:> token-group* {:key (name type)
-                           :tokens tokens
-                           :is-expanded (get open-status type false)
+                           :is-open (get open-status type false)
                           :type type
                           :selected-ids selected
                           :selected-shapes selected-shapes
                           :is-selected-inside-layout is-selected-inside-layout
                           :active-theme-tokens resolved-active-tokens
-                           :tokens-lib tokens-lib
-                           :selected-token-set-id selected-token-set-id}]))
+                           :tokens tokens}]))

     (for [type empty-group]
       [:> token-group* {:key (name type)
-                         :tokens []
                         :type type
                         :selected-shapes selected-shapes
-                         :is-selected-inside-layout is-selected-inside-layout
-                         :active-theme-tokens resolved-active-tokens}])]))
+                         :is-selected-inside-layout :is-selected-inside-layout
+                         :active-theme-tokens resolved-active-tokens
+                         :tokens []}])]))
--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/controls/color_input.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/controls/color_input.cljs
@@ -43,8 +43,8 @@
 ;; 2) Indexed Color Input
 ;;    - Used when the token’s value stores an array of items (e.g. inside
 ;;      shadows, where each shadow layer has its own :color field).
-;;    - The input writes to a nested value-subfield:
-;;         [:value <value-subfield> <index> :color]
+;;    - The input writes to a nested subfield:
+;;         [:value <subfield> <index> :color]
 ;;    - Only that specific color entry is validated.
 ;;    - Other properties (offsets, blur, inset, etc.) remain untouched.
 ;;
@@ -436,21 +436,19 @@

                           (some? error)
                           (let [error' (:message error)]
-                             (do
-                               (swap! form assoc-in  [:extra-errors :value value-subfield index input-name] {:message error'})
-                               (swap! form assoc-in [:data :value value-subfield index :color-result] "")
-                               (reset! hint* {:message error' :type "error"})))
+                             (swap! form assoc-in  [:extra-errors :value value-subfield index input-name] {:message error'})
+                             (swap! form assoc-in [:data :value value-subfield index :color-result] "")
+                             (reset! hint* {:message error' :type "error"}))

                           :else
                           (let [message (tr "workspace.tokens.resolved-value" (dwtf/format-token-value value))
                                 input-value (get-in @form [:data :value value-subfield index input-name] "")]
-                             (do
-                               (swap! form update :errors dissoc :value)
-                               (swap! form update :extra-errors dissoc :value)
-                               (swap! form assoc-in [:data :value value-subfield index :color-result] (dwtf/format-token-value value))
-                               (if (= input-value (str value))
-                                 (reset! hint* {})
-                                 (reset! hint* {:message message :type "hint"}))))))))]
+                             (swap! form update :errors dissoc :value)
+                             (swap! form update :extra-errors dissoc :value)
+                             (swap! form assoc-in [:data :value value-subfield index :color-result] (dwtf/format-token-value value))
+                             (if (= input-value (str value))
+                               (reset! hint* {})
+                               (reset! hint* {:message message :type "hint"})))))))]
        (fn []
          (rx/dispose! subs))))

--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/controls/fonts_combobox.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/controls/fonts_combobox.cljs
@@ -41,7 +41,7 @@
 ;; 2) Composite Font Picker
 ;;    - Used inside typography tokens, where `:value` is a map (e.g. contains
 ;;      :font-family, :font-weight, :letter-spacing, etc.).
-;;    - The input writes to the specific value-subfield `[:value :font-family]`.
+;;    - The input writes to the specific subfield `[:value :font-family]`.
 ;;    - Only this field is validated and updated—other typography fields remain
 ;;      untouched.
 ;;
--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/controls/input.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/controls/input.cljs
@@ -48,7 +48,7 @@
 ;; 2) COMPOSITE INPUTS
 ;;    ----------------------------------------------------------
 ;;    Used when the token contains a set of *named fields* inside :value.
-;;    The UI must write into a specific value-subfield inside the :value map.
+;;    The UI must write into a specific subfield inside the :value map.
 ;;
 ;;    Example: typography tokens
 ;;      {:value {:font-family "Inter"
@@ -64,7 +64,7 @@
 ;;      * Validation rules apply per-field.
 ;;
 ;;    In practice:
-;;      - The component knows which value-subfield to update.
+;;      - The component knows which subfield to update.
 ;;      - The form accumulates multiple fields into a single map under :value.
 ;;
 ;;
--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/controls/select.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/controls/select.cljs
@@ -13,10 +13,10 @@
 ;; --- Select Input (Indexed) --------------------------------------------------
 ;;
 ;; This input type is part of the indexed system, used for fields that exist
-;; inside an array of maps stored in a value-subfield of :value.
+;; inside an array of maps stored in a subfield of :value.
 ;;
 ;; - Writes to a nested location:
-;;       [:value <value-subfield> <index> <field>]
+;;       [:value <subfield> <index> <field>]
 ;; - Each item in the array has its own select input, independent of others.
 ;; - Validation ensures the selected value is valid for that field.
 ;; - Changing one item does not affect the other items in the array.
--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/generic_form.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/generic_form.cljs
@@ -230,29 +230,16 @@
           {:level :warning :appearance :ghost} (tr "workspace.tokens.warning-name-change")]])]

      [:div {:class (stl/css :input-row)}
-       (case type
-         :indexed
-         [:> input-component
-          {:token          token
-           :tokens         tokens
-           :tab            active-tab
-           :value-subfield value-subfield
-           :handle-toggle  on-toggle-tab}]
-
-         :composite
-         [:> input-component
-          {:token         token
-           :tokens        tokens
-           :tab           active-tab
-           :handle-toggle on-toggle-tab}]
-
-         [:> input-component
-          {:placeholder (or input-value-placeholder
-                            (tr "workspace.tokens.token-value-enter"))
-           :label       (tr "workspace.tokens.token-value")
-           :name        :value
-           :token       token
-           :tokens      tokens}])]
+       [:> input-component
+        {:placeholder (or input-value-placeholder (tr "workspace.tokens.token-value-enter"))
+         :label (tr "workspace.tokens.token-value")
+         :name :value
+         :form form
+         :token token
+         :tokens tokens
+         :tab active-tab
+         :subfield value-subfield
+         :toggle on-toggle-tab}]]

      [:div {:class (stl/css :input-row)}
       [:> fc/form-input* {:id "token-description"
--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/shadow.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/shadow.cljs
@@ -208,20 +208,19 @@
     :tokens tokens}]])

 (mf/defc tabs-wrapper*
-  [{:keys [token tokens tab handle-toggle value-subfield] :rest props}]
-  (let [form (mf/use-ctx forms/context)
-        on-add-shadow-block
+  [{:keys [token tokens form tab toggle subfield] :rest props}]
+  (let [on-add-shadow-block
        (mf/use-fn
-         (mf/deps value-subfield)
+         (mf/deps subfield)
         (fn []
-           (swap! form  update-in [:data :value value-subfield] conj default-token-shadow)))
+           (swap! form  update-in [:data :value subfield] conj default-token-shadow)))

        remove-shadow-block
        (mf/use-fn
-         (mf/deps value-subfield)
+         (mf/deps subfield)
         (fn [index event]
           (dom/prevent-default event)
-           (swap! form update-in [:data :value value-subfield] #(d/remove-at-index % index))))]
+           (swap! form update-in [:data :value subfield] #(d/remove-at-index % index))))]

    [:*
     [:div {:class (stl/css :title-bar)}
@@ -233,7 +232,7 @@
                        :icon i/add}]
      [:& radio-buttons {:class (stl/css :listing-options)
                         :selected (d/name tab)
-                         :on-change handle-toggle
+                         :on-change toggle
                         :name "reference-composite-tab"}
       [:& radio-button {:icon i/layers
                         :value "composite"
@@ -248,7 +247,7 @@
       [:> composite-form* {:token token
                            :tokens tokens
                            :remove-shadow-block remove-shadow-block
-                            :value-subfield value-subfield}]
+                            :value-subfield subfield}]

       [:> reference-form* {:token token
                            :tokens tokens}])]))
--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/typography.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/typography.cljs
@@ -181,13 +181,13 @@
     :tokens tokens}]])

 (mf/defc tabs-wrapper*
-  [{:keys [token tokens tab handle-toggle] :rest props}]
+  [{:keys [token tokens tab toggle] :rest props}]
  [:*
   [:div {:class (stl/css :title-bar)}
    [:div {:class (stl/css :title)} (tr "labels.typography")]
    [:& radio-buttons {:class (stl/css :listing-options)
                       :selected (d/name tab)
-                       :on-change handle-toggle
+                       :on-change toggle
                       :name "reference-composite-tab"}
     [:& radio-button {:icon i/layers
                       :value "composite"
--- a/frontend/src/app/main/ui/workspace/tokens/management/group.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/group.cljs
@@ -8,9 +8,6 @@
 (ns app.main.ui.workspace.tokens.management.group
  (:require-macros [app.main.style :as stl])
  (:require
-   [app.common.data :as d]
-   [app.common.data.macros :as dm]
-   [app.common.types.tokens-lib :as ctob]
   [app.main.data.modal :as modal]
   [app.main.data.workspace.tokens.application :as dwta]
   [app.main.data.workspace.tokens.library-edit :as dwtl]
@@ -19,70 +16,51 @@
   [app.main.ui.context :as ctx]
   [app.main.ui.ds.buttons.icon-button :refer [icon-button*]]
   [app.main.ui.ds.foundations.assets.icon :as i]
-   [app.main.ui.ds.layers.layer-button :refer [layer-button*]]
-   [app.main.ui.workspace.tokens.management.token-tree :refer [token-tree*]]
+   [app.main.ui.workspace.sidebar.assets.common :as cmm]
+   [app.main.ui.workspace.tokens.management.token-pill :refer [token-pill*]]
   [app.util.dom :as dom]
   [app.util.i18n :refer [tr]]
   [rumext.v2 :as mf]))

-
 (defn token-section-icon
  [type]
  (case type
-    :border-radius i/corner-radius
-    :color i/drop
-    :boolean i/boolean-difference
-    :font-family i/text-font-family
-    :font-size i/text-font-size
-    :letter-spacing i/text-letterspacing
-    :text-case i/text-mixed
-    :text-decoration i/text-underlined
-    :font-weight i/text-font-weight
-    :typography i/text-typography
-    :opacity i/percentage
-    :number i/number
-    :rotation i/rotation
-    :spacing i/padding-extended
-    :string i/text-mixed
-    :stroke-width i/stroke-size
-    :dimensions i/expand
-    :sizing i/expand
-    :shadow i/drop-shadow
+    :border-radius "corner-radius"
+    :color "drop"
+    :boolean "boolean-difference"
+    :font-family "text-font-family"
+    :font-size "text-font-size"
+    :letter-spacing "text-letterspacing"
+    :text-case "text-mixed"
+    :text-decoration "text-underlined"
+    :font-weight "text-font-weight"
+    :typography "text-typography"
+    :opacity "percentage"
+    :number "number"
+    :rotation "rotation"
+    :spacing "padding-extended"
+    :string "text-mixed"
+    :stroke-width "stroke-size"
+    :dimensions "expand"
+    :sizing "expand"
+    :shadow "drop-shadow"
    "add"))

-(def ^:private schema:token-group
-  [:map
-   [:type :keyword]
-   [:tokens :any]
-   [:selected-shapes :any]
-   [:is-selected-inside-layout {:optional true} [:maybe :boolean]]
-   [:active-theme-tokens {:optional true} :any]
-   [:selected-token-set-id {:optional true} :any]
-   [:tokens-lib {:optional true} :any]
-   [:on-token-pill-click {:optional true} fn?]
-   [:on-context-menu {:optional true} fn?]])
-
 (mf/defc token-group*
-  {::mf/schema schema:token-group}
-  [{:keys [type tokens selected-shapes is-selected-inside-layout active-theme-tokens selected-token-set-id tokens-lib is-expanded selected-ids]}]
+  {::mf/private true}
+  [{:keys [type tokens selected-shapes is-selected-inside-layout active-theme-tokens is-open selected-ids]}]
  (let [{:keys [modal title]}
        (get dwta/token-properties type)
        editing-ref  (mf/deref refs/workspace-editor-state)
        not-editing? (empty? editing-ref)

-        is-expanded (d/nilv is-expanded false)
-
        can-edit?
        (mf/use-ctx ctx/can-edit?)

-        is-selected-inside-layout (d/nilv is-selected-inside-layout false)
-
        tokens
        (mf/with-memo [tokens]
          (vec (sort-by :name tokens)))

-        expandable? (d/nilv (seq tokens) false)
-
        on-context-menu
        (mf/use-fn
         (fn [event token]
@@ -95,8 +73,8 @@

        on-toggle-open-click
        (mf/use-fn
-         (mf/deps is-expanded type)
-         #(st/emit! (dwtl/set-token-type-section-open type (not is-expanded))))
+         (mf/deps is-open type)
+         #(st/emit! (dwtl/set-token-type-section-open type (not is-open))))

        on-popover-open-click
        (mf/use-fn
@@ -118,36 +96,33 @@
        (mf/use-fn
         (mf/deps not-editing? selected-ids)
         (fn [event token]
-           (let [token (ctob/get-token tokens-lib selected-token-set-id (:id token))]
-             (dom/stop-propagation event)
-             (when (and not-editing? (seq selected-shapes) (not= (:type token) :number))
-               (st/emit! (dwta/toggle-token {:token token
-                                             :shape-ids selected-ids}))))))]
+           (dom/stop-propagation event)
+           (when (and not-editing? (seq selected-shapes) (not= (:type token) :number))
+             (st/emit! (dwta/toggle-token {:token token
+                                           :shape-ids selected-ids})))))]

-    [:div {:class (stl/css :token-section-wrapper)
-           :data-testid (dm/str "section-" (name type))}
-     [:> layer-button* {:label title
-                        :expanded is-expanded
-                        :description (when expandable? (dm/str (count tokens)))
-                        :is-expandable expandable?
-                        :aria-expanded is-expanded
-                        :aria-controls (dm/str "token-tree-" (name type))
-                        :on-toggle-expand on-toggle-open-click
-                        :icon (token-section-icon type)}
-      (when can-edit?
-        [:> icon-button* {:id (str "add-token-button-" title)
-                          :icon "add"
-                          :aria-label (tr "workspace.tokens.add-token" title)
-                          :variant "ghost"
-                          :on-click on-popover-open-click
-                          :class (stl/css :token-section-icon)}])]
-     (when is-expanded
-       [:> token-tree* {:tokens tokens
-                        :id (dm/str "token-tree-" (name type))
-                        :tokens-lib tokens-lib
-                        :selected-shapes selected-shapes
-                        :active-theme-tokens active-theme-tokens
-                        :selected-token-set-id selected-token-set-id
-                        :is-selected-inside-layout is-selected-inside-layout
-                        :on-token-pill-click on-token-pill-click
-                        :on-context-menu on-context-menu}])]))
+    [:div {:on-click on-toggle-open-click :class (stl/css :token-section-wrapper)}
+     [:> cmm/asset-section* {:icon (token-section-icon type)
+                             :title title
+                             :section :tokens
+                             :assets-count (count tokens)
+                             :is-open is-open}
+      [:> cmm/asset-section-block* {:role :title-button}
+       (when can-edit?
+         [:> icon-button* {:on-click on-popover-open-click
+                           :variant "ghost"
+                           :icon i/add
+                           :id (str "add-token-button-" title)
+                           :aria-label (tr "workspace.tokens.add-token" title)}])]
+      (when is-open
+        [:> cmm/asset-section-block* {:role :content}
+         [:div {:class (stl/css :token-pills-wrapper)}
+          (for [token tokens]
+            [:> token-pill*
+             {:key (:name token)
+              :token token
+              :selected-shapes selected-shapes
+              :is-selected-inside-layout is-selected-inside-layout
+              :active-theme-tokens active-theme-tokens
+              :on-click on-token-pill-click
+              :on-context-menu on-context-menu}])]])]]))
--- a/frontend/src/app/main/ui/workspace/tokens/management/group.scss
+++ b/frontend/src/app/main/ui/workspace/tokens/management/group.scss
@@ -0,0 +1,11 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// Copyright (c) KALEIDOS INC
+
+.token-pills-wrapper {
+  display: flex;
+  gap: var(--sp-xs);
+  flex-wrap: wrap;
+}
--- a/frontend/src/app/main/ui/workspace/tokens/management/token_pill.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/token_pill.cljs
@@ -307,9 +307,10 @@
         :class (stl/css :token-pill-icon)}])

     (if contains-path?
-       (let [[_ last-part] (cpn/split-by-last-period name)]
+       (let [[first-part last-part] (cpn/split-by-last-period name)]
         [:span {:class (stl/css :divided-name-wrapper)
                 :aria-label name}
+          [:span {:class (stl/css :first-name-wrapper)} first-part]
          [:span {:class (stl/css :last-name-wrapper)} last-part]])
       [:span {:class (stl/css :name-wrapper)
               :aria-label name}
--- a/frontend/src/app/main/ui/workspace/tokens/management/token_tree.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/token_tree.cljs
@@ -1,110 +0,0 @@
-;; This Source Code Form is subject to the terms of the Mozilla Public
-;; License, v. 2.0. If a copy of the MPL was not distributed with this
-;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
-;;
-;; Copyright (c) KALEIDOS INC
-
-(ns app.main.ui.workspace.tokens.management.token-tree
-  (:require-macros [app.main.style :as stl])
-  (:require
-   [app.common.path-names :as cpn]
-   [app.common.types.tokens-lib :as ctob]
-   [app.main.ui.ds.layers.layer-button :refer [layer-button*]]
-   [app.main.ui.workspace.tokens.management.token-pill :refer [token-pill*]]
-   [rumext.v2 :as mf]))
-
-(def ^:private schema:folder-node
-  [:map
-   [:node :any]
-   [:selected-shapes :any]
-   [:is-selected-inside-layout {:optional true} :boolean]
-   [:active-theme-tokens {:optional true} :any]
-   [:selected-token-set-id {:optional true} :any]
-   [:tokens-lib {:optional true} :any]
-   [:on-token-pill-click {:optional true} fn?]
-   [:on-context-menu {:optional true} fn?]])
-
-(mf/defc folder-node*
-  {::mf/schema schema:folder-node}
-  [{:keys [node selected-shapes is-selected-inside-layout active-theme-tokens selected-token-set-id tokens-lib on-token-pill-click on-context-menu]}]
-  (let [expanded* (mf/use-state false)
-        expanded (deref expanded*)
-        swap-folder-expanded #(swap! expanded* not)]
-    [:li {:class (stl/css :folder-node)}
-     [:> layer-button* {:label (:name node)
-                        :expanded expanded
-                        :aria-expanded expanded
-                        :aria-controls (str "folder-children-" (:path node))
-                        :is-expandable (not (:leaf node))
-                        :on-toggle-expand swap-folder-expanded}]
-     (when expanded
-       (let [children-fn (:children-fn node)]
-         [:div {:class (stl/css :folder-children-wrapper)
-                :id (str "folder-children-" (:path node))}
-          (when children-fn
-            (let [children (children-fn)]
-              (for [child children]
-                (if (not (:leaf child))
-                  [:ul {:class (stl/css :node-parent)}
-                   [:> folder-node* {:key (:path child)
-                                     :node child
-                                     :selected-shapes selected-shapes
-                                     :is-selected-inside-layout is-selected-inside-layout
-                                     :active-theme-tokens active-theme-tokens
-                                     :on-token-pill-click on-token-pill-click
-                                     :on-context-menu on-context-menu
-                                     :tokens-lib tokens-lib
-                                     :selected-token-set-id selected-token-set-id}]]
-                  (let [id (:id (:leaf child))
-                        token (ctob/get-token tokens-lib selected-token-set-id id)]
-                    [:> token-pill*
-                     {:key id
-                      :token token
-                      :selected-shapes selected-shapes
-                      :is-selected-inside-layout is-selected-inside-layout
-                      :active-theme-tokens active-theme-tokens
-                      :on-click on-token-pill-click
-                      :on-context-menu on-context-menu}])))))]))]))
-
-(def ^:private schema:token-tree
-  [:map
-   [:tokens :any]
-   [:selected-shapes :any]
-   [:is-selected-inside-layout {:optional true} :boolean]
-   [:active-theme-tokens {:optional true} :any]
-   [:selected-token-set-id {:optional true} :any]
-   [:tokens-lib {:optional true} :any]
-   [:on-token-pill-click {:optional true} fn?]
-   [:on-context-menu {:optional true} fn?]])
-
-(mf/defc token-tree*
-  {::mf/schema schema:token-tree}
-  [{:keys [tokens selected-shapes is-selected-inside-layout active-theme-tokens tokens-lib selected-token-set-id on-token-pill-click on-context-menu]}]
-  (let [separator "."
-        tree (mf/use-memo
-              (mf/deps tokens)
-              (fn []
-                (cpn/build-tree-root tokens separator)))]
-    [:div {:class (stl/css :token-tree-wrapper)}
-     (for [node tree]
-       [:ul {:class (stl/css :node-parent)
-             :key (:path node)
-             :style {:--node-depth (inc (:depth node))}}
-        (if (:leaf node)
-          (let [token (ctob/get-token tokens-lib selected-token-set-id (get-in node [:leaf :id]))]
-            [:> token-pill*
-             {:token token
-              :selected-shapes selected-shapes
-              :is-selected-inside-layout is-selected-inside-layout
-              :active-theme-tokens active-theme-tokens
-              :on-click on-token-pill-click
-              :on-context-menu on-context-menu}])
-          ;; Render segment folder
-          [:> folder-node* {:node node
-                            :selected-shapes selected-shapes
-                            :is-selected-inside-layout is-selected-inside-layout
-                            :active-theme-tokens active-theme-tokens
-                            :on-token-pill-click on-token-pill-click
-                            :on-context-menu on-context-menu
-                            :tokens-lib tokens-lib
-                            :selected-token-set-id selected-token-set-id}])])]))
--- a/frontend/src/app/main/ui/workspace/tokens/management/token_tree.scss
+++ b/frontend/src/app/main/ui/workspace/tokens/management/token_tree.scss
@@ -1,39 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-//
-// Copyright (c) KALEIDOS INC
-
-@use "ds/_borders.scss" as *;
-
-.token-tree-wrapper {
-  padding-block-end: var(--sp-s);
-}
-
-.node-parent {
-  --node-spacing: var(--sp-l);
-  --node-depth: 0;
-
-  margin-block-end: 0;
-  padding-inline-start: calc(var(--node-spacing) * var(--node-depth));
-}
-
-.folder-children-wrapper:has(> button) {
-  margin-inline-start: var(--sp-s);
-  padding-inline-start: var(--sp-s);
-  border-inline-start: $b-2 solid var(--color-background-quaternary);
-  display: flex;
-  flex-wrap: wrap;
-  column-gap: var(--sp-xs);
-
-  & .node-parent {
-    flex: 1 0 100%;
-
-    &:last-of-type {
-      margin-block-end: var(--sp-s);
-    }
-  }
-  & .token-pill {
-    flex: 0 0 auto;
-  }
-}
--- a/frontend/src/app/main/ui/workspace/top_toolbar.scss
+++ b/frontend/src/app/main/ui/workspace/top_toolbar.scss
@@ -18,7 +18,7 @@
  padding: deprecated.$s-8 deprecated.$s-16;
  border-radius: deprecated.$s-8;
  border: deprecated.$s-2 solid var(--panel-border-color);
-  z-index: deprecated.$z-index-1;
+  z-index: deprecated.$z-index-3;
  background-color: var(--color-background-primary);
  transition:
    top 0.3s,
--- a/frontend/src/app/main/ui/workspace/viewport/debug.cljs
+++ b/frontend/src/app/main/ui/workspace/viewport/debug.cljs
@@ -16,7 +16,6 @@
   [app.common.geom.shapes.points :as gpo]
   [app.common.types.shape.layout :as ctl]
   [app.common.uuid :as uuid]
-   [app.render-wasm.api :as wasm.api]
   [cuerdas.core :as str]
   [rumext.v2 :as mf]))

@@ -276,26 +275,3 @@
                     :y2 (:y end-p)
                     :style {:stroke "red"
                             :stroke-width (/ 1 zoom)}}]))]))))
-
-(mf/defc debug-text-wasm-position-data
-  {::mf/wrap-props false}
-  [props]
-  (let [zoom               (unchecked-get props "zoom")
-        selected-shapes    (unchecked-get props "selected-shapes")
-
-        selected-text
-        (when (and (= (count selected-shapes) 1) (= :text (-> selected-shapes first :type)))
-          (first selected-shapes))
-
-        position-data
-        (when selected-text
-          (wasm.api/calculate-position-data selected-text))]
-
-    (for [{:keys [x y width height]} position-data]
-      [:rect {:x x
-              :y (- y height)
-              :width width
-              :height height
-              :fill "none"
-              :strokeWidth (/ 1 zoom)
-              :stroke "red"}])))
--- a/frontend/src/app/main/ui/workspace/viewport/grid_layout_editor.cljs
+++ b/frontend/src/app/main/ui/workspace/viewport/grid_layout_editor.cljs
@@ -23,7 +23,6 @@
   [app.main.data.workspace.grid-layout.editor :as dwge]
   [app.main.data.workspace.modifiers :as dwm]
   [app.main.data.workspace.shape-layout :as dwsl]
-   [app.main.data.workspace.transforms :as dwt]
   [app.main.features :as features]
   [app.main.refs :as refs]
   [app.main.store :as st]
@@ -258,8 +257,7 @@
             (let [modifiers (calculate-drag-modifiers position)
                   modif-tree (dwm/create-modif-tree [(:id shape)] modifiers)]
               (when on-clear-modifiers (on-clear-modifiers modifiers))
-               (st/emit! (dwm/apply-wasm-modifiers modif-tree)
-                         (dwt/finish-transform)))
+               (st/emit! (dwm/apply-wasm-modifiers modif-tree)))
             (st/emit! (dwm/apply-modifiers)))))

        {:keys [handle-pointer-down handle-lost-pointer-capture handle-pointer-move]}
@@ -508,8 +506,7 @@
             (let [modifiers (calculate-modifiers position)
                   modif-tree (dwm/create-modif-tree [(:id shape)] modifiers)]
               (when on-clear-modifiers (on-clear-modifiers))
-               (st/emit! (dwm/apply-wasm-modifiers modif-tree)
-                         (dwt/finish-transform)))
+               (st/emit! (dwm/apply-wasm-modifiers modif-tree)))
             (st/emit! (dwm/apply-modifiers)))
           (reset! start-size-before nil)
           (reset! start-size-after nil)))]
--- a/frontend/src/app/main/ui/workspace/viewport_wasm.cljs
+++ b/frontend/src/app/main/ui/workspace/viewport_wasm.cljs
@@ -12,12 +12,10 @@
   [app.common.files.helpers :as cfh]
   [app.common.geom.shapes :as gsh]
   [app.common.types.color :as clr]
-   [app.common.types.component :as ctk]
   [app.common.types.path :as path]
   [app.common.types.shape :as cts]
   [app.common.types.shape.layout :as ctl]
   [app.main.data.workspace.transforms :as dwt]
-   [app.main.data.workspace.variants :as dwv]
   [app.main.features :as features]
   [app.main.refs :as refs]
   [app.main.store :as st]
@@ -56,11 +54,15 @@
   [app.util.debug :as dbg]
   [app.util.text-editor :as ted]
   [beicon.v2.core :as rx]
+   [okulary.core :as l]
   [promesa.core :as p]
   [rumext.v2 :as mf]))

 ;; --- Viewport

+(def workspace-wasm-modifiers
+  (l/derived :workspace-wasm-modifiers st/state))
+
 (defn apply-modifiers-to-selected
  [selected objects modifiers]
  (->> modifiers
@@ -96,7 +98,7 @@
        ;; DEREFS
        drawing           (mf/deref refs/workspace-drawing)
        focus             (mf/deref refs/workspace-focus-selected)
-        wasm-modifiers    (mf/deref refs/workspace-wasm-modifiers)
+        wasm-modifiers    (mf/deref workspace-wasm-modifiers)

        workspace-editor-state (mf/deref refs/workspace-editor-state)

@@ -259,16 +261,6 @@

        first-shape (first selected-shapes)

-        show-add-variant?        (and single-select?
-                                      (or (ctk/is-variant-container? first-shape)
-                                          (ctk/is-variant? first-shape)))
-
-        add-variant
-        (mf/use-fn
-         (mf/deps first-shape)
-         #(st/emit!
-           (dwv/add-new-variant (:id first-shape))))
-
        show-padding?
        (and (nil? transform)
             single-select?
@@ -647,12 +639,6 @@
                                    :hover-top-frame-id @hover-top-frame-id
                                    :zoom zoom}])

-       (when (dbg/enabled? :text-outline)
-         [:& wvd/debug-text-wasm-position-data
-          {:selected-shapes selected-shapes
-           :objects base-objects
-           :zoom zoom}])
-
       (when show-selection-handlers?
         [:g.selection-handlers {:clipPath "url(#clip-handlers)"}
          (when-not text-editing?
@@ -681,11 +667,6 @@
          {:id (first selected)
           :zoom zoom}])

-       (when show-add-variant?
-         [:> widgets/button-add* {:shape first-shape
-                                  :zoom zoom
-                                  :on-click add-variant}])
-
       [:g.grid-layout-editor {:clipPath "url(#clip-handlers)"}
        (when show-grid-editor?
          [:& grid-layout/editor
--- a/frontend/src/app/render.cljs
+++ b/frontend/src/app/render.cljs
@@ -18,7 +18,6 @@
   [app.main.render :as render]
   [app.main.repo :as repo]
   [app.main.store :as st]
-   [app.main.ui.context :as ctx]
   [app.util.dom :as dom]
   [app.util.globals :as glob]
   [beicon.v2.core :as rx]
@@ -77,12 +76,11 @@
                   (mth/ceil height) "px")}))))

    (when objects
-      [:& (mf/provider ctx/is-render?) {:value true}
-       [:& render/object-svg
-        {:objects objects
-         :object-id object-id
-         :embed embed
-         :skip-children skip-children}]])))
+      [:& render/object-svg
+       {:objects objects
+        :object-id object-id
+        :embed embed
+        :skip-children skip-children}])))

 (mf/defc objects-svg
  {::mf/wrap-props false}
@@ -90,13 +88,12 @@
  (when-let [objects (mf/deref ref:objects)]
    (for [object-id object-ids]
      (let [objects (render/adapt-objects-for-shape objects object-id)]
-        [:& (mf/provider ctx/is-render?) {:value true}
-         [:& render/object-svg
-          {:objects objects
-           :key (str object-id)
-           :object-id object-id
-           :embed embed
-           :skip-children skip-children}]]))))
+        [:& render/object-svg
+         {:objects objects
+          :key (str object-id)
+          :object-id object-id
+          :embed embed
+          :skip-children skip-children}]))))

 (defn- fetch-objects-bundle
  [& {:keys [file-id page-id share-id object-id] :as options}]
--- a/frontend/src/app/render_wasm/api.cljs
+++ b/frontend/src/app/render_wasm/api.cljs
@@ -20,10 +20,10 @@
   [app.common.types.shape.layout :as ctl]
   [app.common.uuid :as uuid]
   [app.config :as cf]
+   [app.main.fonts :as fonts]
   [app.main.refs :as refs]
   [app.main.render :as render]
   [app.main.store :as st]
-   [app.main.ui.shapes.text]
   [app.main.worker :as mw]
   [app.render-wasm.api.fonts :as f]
   [app.render-wasm.api.texts :as t]
@@ -34,7 +34,7 @@
   [app.render-wasm.performance :as perf]
   [app.render-wasm.serializers :as sr]
   [app.render-wasm.serializers.color :as sr-clr]
-   [app.render-wasm.svg-filters :as svg-filters]
+   [app.render-wasm.svg-fills :as svg-fills]
   ;; FIXME: rename; confunsing name
   [app.render-wasm.wasm :as wasm]
   [app.util.debug :as dbg]
@@ -43,7 +43,6 @@
   [app.util.modules :as mod]
   [app.util.text.content :as tc]
   [beicon.v2.core :as rx]
-   [cuerdas.core :as str]
   [promesa.core :as p]
   [rumext.v2 :as mf]))

@@ -62,9 +61,6 @@

 (def ^:const MAX_BUFFER_CHUNK_SIZE (* 256 1024))

-(def ^:const DEBOUNCE_DELAY_MS 100)
-(def ^:const THROTTLE_DELAY_MS 10)
-
 (def dpr
  (if use-dpr? (if (exists? js/window) js/window.devicePixelRatio 1.0) 1.0))

@@ -705,7 +701,7 @@
  (set-grid-layout-columns (get shape :layout-grid-columns))
  (set-grid-layout-cells (get shape :layout-grid-cells)))

-(defn set-layout-data
+(defn set-layout-child
  [shape]
  (let [margins       (get shape :layout-item-margin)
        margin-top    (get margins :m1 0)
@@ -728,7 +724,7 @@
        is-absolute   (boolean (get shape :layout-item-absolute))
        z-index       (get shape :layout-item-z-index)]
    (h/call wasm/internal-module
-            "_set_layout_data"
+            "_set_layout_child_data"
            margin-top
            margin-right
            margin-bottom
@@ -748,11 +744,6 @@
            is-absolute
            (d/nilv z-index 0))))

-(defn has-any-layout-prop? [shape]
-  (some #(and (keyword? %)
-              (str/starts-with? (name %) "layout-"))
-        (keys shape)))
-
 (defn clear-layout
  []
  (h/call wasm/internal-module "_clear_shape_layout"))
@@ -760,10 +751,10 @@
 (defn- set-shape-layout
  [shape objects]
  (clear-layout)
+
  (when (or (ctl/any-layout? shape)
-            (ctl/any-layout-immediate-child? objects shape)
-            (has-any-layout-prop? shape))
-    (set-layout-data shape))
+            (ctl/any-layout-immediate-child? objects shape))
+    (set-layout-child shape))

  (when (ctl/flex-layout? shape)
    (set-flex-layout shape))
@@ -838,7 +829,7 @@

  (set-shape-vertical-align (get content :vertical-align))

-  (let [fonts         (f/get-content-fonts content)
+  (let [fonts         (fonts/get-content-fonts content)
        fallback-fonts (fonts-from-text-content content true)
        all-fonts (concat fonts fallback-fonts)
        result (f/store-fonts shape-id all-fonts)]
@@ -882,43 +873,27 @@

 (def render-finish
  (letfn [(do-render [ts]
-            (perf/begin-measure "render-finish")
            (h/call wasm/internal-module "_set_view_end")
-            (render ts)
-            (perf/end-measure "render-finish"))]
-    (fns/debounce do-render DEBOUNCE_DELAY_MS)))
+            (render ts))]
+    (fns/debounce do-render 100)))

 (def render-pan
-  (letfn [(do-render-pan [ts]
-            (perf/begin-measure "render-pan")
-            (render ts)
-            (perf/end-measure "render-pan"))]
-    (fns/throttle do-render-pan THROTTLE_DELAY_MS)))
+  (fns/throttle render 10))

 (defn set-view-box
  [prev-zoom zoom vbox]
-  (let [is-pan (mth/close? prev-zoom zoom)]
-    (perf/begin-measure "set-view-box")
-    (h/call wasm/internal-module "_set_view_start")
-    (h/call wasm/internal-module "_set_view" zoom (- (:x vbox)) (- (:y vbox)))
+  (h/call wasm/internal-module "_set_view" zoom (- (:x vbox)) (- (:y vbox)))

-    (if is-pan
-      (do (perf/end-measure "set-view-box")
-          (perf/begin-measure "set-view-box::pan")
-          (render-pan)
-          (render-finish)
-          (perf/end-measure "set-view-box::pan"))
-      (do (perf/end-measure "set-view-box")
-          (perf/begin-measure "set-view-box::zoom")
-          (h/call wasm/internal-module "_render_from_cache" 0)
-          (render-finish)
-          (perf/end-measure "set-view-box::zoom")))))
+  (if (mth/close? prev-zoom zoom)
+    (do (render-pan)
+        (render-finish))
+    (do (h/call wasm/internal-module "_render_from_cache" 0)
+        (render-finish))))

 (defn set-object
  [objects shape]
  (perf/begin-measure "set-object")
-  (let [shape        (svg-filters/apply-svg-derived shape)
-        id           (dm/get-prop shape :id)
+  (let [id           (dm/get-prop shape :id)
        type         (dm/get-prop shape :type)

        parent-id    (get shape :parent-id)
@@ -932,7 +907,14 @@
        rotation     (get shape :rotation)
        transform    (get shape :transform)

-        fills        (get shape :fills)
+        ;; If the shape comes from an imported SVG (we know this because
+        ;; it has the :svg-attrs attribute) and it does not have its
+        ;; own fill, we set a default black fill. This fill will be
+        ;; inherited by child nodes and emulates the behavior of
+        ;; standard SVG, where a node without an explicit fill
+        ;; defaults to black.
+        fills        (svg-fills/resolve-shape-fills shape)
+
        strokes      (if (= type :group)
                       [] (get shape :strokes))
        children     (get shape :shapes)
@@ -976,11 +958,12 @@
      (set-shape-svg-attrs svg-attrs))
    (when (and (some? content) (= type :svg-raw))
      (set-shape-svg-raw-content (get-static-markup shape)))
-    (set-shape-shadows shadows)
+    (when (some? shadows) (set-shape-shadows shadows))
    (when (= type :text)
      (set-shape-grow-type grow-type))

    (set-shape-layout shape objects)
+
    (set-shape-selrect selrect)

    (let [pending_thumbnails (into [] (concat
@@ -1004,7 +987,10 @@
       (run!
        (fn [id]
          (f/update-text-layout id)
-          (update-text-rect! id)))))
+          (mw/emit! {:cmd :index/update-text-rect
+                     :page-id (:current-page-id @st/state)
+                     :shape-id id
+                     :dimensions (get-text-dimensions id)})))))

 (defn process-pending
  ([shapes thumbnails full on-complete]
@@ -1058,7 +1044,6 @@
     (process-pending shapes thumbnails full noop-fn
                      (fn []
                        (when render-callback (render-callback))
-                        (render-finish)
                        (ug/dispatch! (ug/event "penpot:wasm:set-objects")))))))

 (defn clear-focus-mode
@@ -1245,8 +1230,6 @@
    (when-not (nil? context)
      (let [handle (.registerContext ^js gl context #js {"majorVersion" 2})]
        (.makeContextCurrent ^js gl handle)
-        (set! wasm/gl-context-handle handle)
-        (set! wasm/gl-context context)

        ;; Force the WEBGL_debug_renderer_info extension as emscripten does not enable it
        (.getExtension context "WEBGL_debug_renderer_info")
@@ -1264,29 +1247,9 @@

 (defn clear-canvas
  []
-  (try
-    ;; TODO: perform corresponding cleaning
-    (set! wasm/context-initialized? false)
-    (h/call wasm/internal-module "_clean_up")
-
-    ;; Ensure the WebGL context is properly disposed so browsers do not keep
-    ;; accumulating active contexts between page switches.
-    (when-let [gl (unchecked-get wasm/internal-module "GL")]
-      (when-let [handle wasm/gl-context-handle]
-        (try
-          ;; Ask the browser to release resources explicitly if available.
-          (when-let [ctx wasm/gl-context]
-            (when-let [lose-ext (.getExtension ^js ctx "WEBGL_lose_context")]
-              (.loseContext ^js lose-ext)))
-          (.deleteContext ^js gl handle)
-          (finally
-            (set! wasm/gl-context-handle nil)
-            (set! wasm/gl-context nil)))))
-
-    ;; If this calls panics we don't want to crash. This happens sometimes
-    ;; with hot-reload in develop
-    (catch :default error
-      (.error js/console error))))
+  ;; TODO: perform corresponding cleaning
+  (set! wasm/context-initialized? false)
+  (h/call wasm/internal-module "_clean_up"))

 (defn show-grid
  [id]
@@ -1329,7 +1292,12 @@
    (mem/free)
    content))

-(defn calculate-bool*
+(defn- calculate-bool*
+  [bool-type]
+  (-> (h/call wasm/internal-module "_calculate_bool" (sr/translate-bool-type bool-type))
+      (mem/->offset-32)))
+
+(defn calculate-bool
  [bool-type ids]
  (let [size   (mem/get-alloc-size ids UUID-U8-SIZE)
        heap   (mem/get-heap-u32)
@@ -1340,10 +1308,7 @@
            offset
            (rseq ids))

-    (let [offset
-          (-> (h/call wasm/internal-module "_calculate_bool" (sr/translate-bool-type bool-type))
-              (mem/->offset-32))
-
+    (let [offset  (calculate-bool* bool-type)
          length  (aget heap offset)
          data    (mem/slice heap
                             (+ offset 1)
@@ -1352,83 +1317,6 @@
      (mem/free)
      content)))

-(defn calculate-bool
-  [shape objects]
-
-  ;; We need to be able to calculate the boolean data but we cannot
-  ;; depend on the serialization flow.
-  ;; start_temp_object / end_temp_object create a new shapes_pool
-  ;; temporary and then we serialize the objects needed to calculate the
-  ;; boolean object.
-  ;; After the content is returned we discard that temporary context
-  (h/call wasm/internal-module "_start_temp_objects")
-
-  (let [bool-type (get shape :bool-type)
-        ids (get shape :shapes)
-        all-children
-        (->> ids
-             (mapcat #(cfh/get-children-with-self objects %)))]
-    (h/call wasm/internal-module "_init_shapes_pool" (count all-children))
-    (run! (partial set-object objects) all-children)
-
-    (let [content (-> (calculate-bool* bool-type ids)
-                      (path.impl/path-data))]
-      (h/call wasm/internal-module "_end_temp_objects")
-      content)))
-
-(def POSITION-DATA-U8-SIZE 36)
-(def POSITION-DATA-U32-SIZE (/ POSITION-DATA-U8-SIZE 4))
-
-(defn calculate-position-data
-  [shape]
-  (when wasm/context-initialized?
-    (use-shape (:id shape))
-    (let [heapf32 (mem/get-heap-f32)
-          heapu32 (mem/get-heap-u32)
-          offset (-> (h/call wasm/internal-module "_calculate_position_data")
-                     (mem/->offset-32))
-          length (aget heapu32 offset)
-
-          max-offset (+ offset 1 (* length POSITION-DATA-U32-SIZE))
-
-          result
-          (loop [result (transient [])
-                 offset (inc offset)]
-            (if (< offset max-offset)
-              (let [entry (dr/read-position-data-entry heapu32 heapf32 offset)]
-                (recur (conj! result entry)
-                       (+ offset POSITION-DATA-U32-SIZE)))
-              (persistent! result)))
-
-          result
-          (->> result
-               (mapv
-                (fn [{:keys [paragraph span start-pos end-pos direction x y width height]}]
-                  (let [content (:content shape)
-                        element (-> content :children
-                                    (get 0) :children ;; paragraph-set
-                                    (get paragraph) :children ;; paragraph
-                                    (get span))
-                        text (subs (:text element) start-pos end-pos)]
-
-                    {:x x
-                     :y (+ y height)
-                     :width width
-                     :height height
-                     :direction       (dr/translate-direction direction)
-                     :font-family     (get element :font-family)
-                     :font-size       (get element :font-size)
-                     :font-weight     (get element :font-weight)
-                     :text-transform  (get element :text-transform)
-                     :text-decoration (get element :text-decoration)
-                     :letter-spacing  (get element :letter-spacing)
-                     :font-style      (get element :font-style)
-                     :fills           (get element :fills)
-                     :text            text}))))]
-      (mem/free)
-
-      result)))
-
 (defn init-wasm-module
  [module]
  (let [default-fn (unchecked-get module "default")
--- a/frontend/src/app/render_wasm/api/fonts.cljs
+++ b/frontend/src/app/render_wasm/api/fonts.cljs
@@ -9,7 +9,6 @@
   [app.common.data :as d]
   [app.common.data.macros :as dm]
   [app.common.logging :as log]
-   [app.common.types.text :as txt]
   [app.common.uuid :as uuid]
   [app.config :as cf]
   [app.main.fonts :as fonts]
@@ -50,13 +49,10 @@
    :builtin))

 (defn- font-db-data
-  [font-id font-variant-id font-weight-fallback font-style-fallback]
+  [font-id font-variant-id]
  (let [font (fonts/get-font-data font-id)
-        closest-variant (fonts/find-closest-variant font font-weight-fallback font-style-fallback)
        variant (fonts/get-variant font font-variant-id)]
-    (if (or (nil? closest-variant) (= closest-variant variant))
-      variant
-      closest-variant)))
+    variant))

 (defn- font-id->uuid [font-id]
  (case (font-backend font-id)
@@ -67,22 +63,22 @@
    :builtin
    uuid/zero))

-
-(defn ^:private font-id->asset-id [font-id font-variant-id font-weight font-style]
+(defn ^:private font-id->asset-id [font-id font-variant-id]
  (case (font-backend font-id)
    :google
    font-id
    :custom
    (let [font-uuid (custom-font-id->uuid font-id)
-          matching-font (some (fn [[_ font]]
-                                (and (= (:font-id font) font-uuid)
-                                     (= (str (:font-weight font)) (str font-weight))
-                                     font))
-                              (seq @fonts))]
+          matching-font (d/seek (fn [[_ font]]
+                                  (let [variant-id (or (:font-variant-id font) (dm/str (:font-style font) "-" (:font-weight font)))]
+                                    (and (= (:font-id font) font-uuid)
+                                         (or (nil? font-variant-id)
+                                             (= variant-id font-variant-id)))))
+                                (seq @fonts))]
      (when matching-font
-        (:ttf-file-id matching-font)))
+        (:ttf-file-id (second matching-font))))
    :builtin
-    (let [variant (font-db-data font-id font-variant-id font-weight font-style)]
+    (let [variant (font-db-data font-id font-variant-id)]
      (:ttf-url variant))))

 (defn update-text-layout
@@ -104,7 +100,6 @@
        ptr  (h/call wasm/internal-module "_alloc_bytes" size)
        heap (gobj/get ^js wasm/internal-module "HEAPU8")
        mem  (js/Uint8Array. (.-buffer heap) ptr size)]
-
    (.set mem (js/Uint8Array. font-array-buffer))
    (h/call wasm/internal-module "_store_font"
            (aget shape-id-buffer 0)
@@ -139,17 +134,17 @@
                               (rx/empty))))})

 (defn- google-font-ttf-url
-  [font-id font-variant-id font-weight font-style]
-  (let [variant (font-db-data font-id font-variant-id font-weight font-style)]
+  [font-id font-variant-id]
+  (let [variant (font-db-data font-id font-variant-id)]
    (if-let [ttf-url (:ttf-url variant)]
      (str/replace ttf-url "https://fonts.gstatic.com/s/" (u/join cf/public-uri "/internal/gfonts/font/"))
      nil)))

 (defn- font-id->ttf-url
-  [font-id asset-id font-variant-id font-weight font-style]
+  [font-id asset-id font-variant-id]
  (case (font-backend font-id)
    :google
-    (google-font-ttf-url font-id font-variant-id font-weight font-style)
+    (google-font-ttf-url font-id font-variant-id)
    :custom
    (dm/str (u/join cf/public-uri "assets/by-id/" asset-id))
    :builtin
@@ -158,7 +153,7 @@
 (defn- store-font-id
  [shape-id font-data asset-id emoji? fallback?]
  (when asset-id
-    (let [uri (font-id->ttf-url (:font-id font-data) asset-id (:font-variant-id font-data) (:weight font-data) (:style-name font-data))
+    (let [uri (font-id->ttf-url (:font-id font-data) asset-id (:font-variant-id font-data))
          id-buffer (uuid/get-u32 (:wasm-id font-data))
          font-data (assoc font-data :family-id-buffer id-buffer)
          font-stored? (not= 0 (h/call wasm/internal-module "_is_font_uploaded"
@@ -192,30 +187,6 @@
    (catch :default _e
      uuid/zero)))

-(defn normalize-span-font
-  [span paragraph]
-  (let [font-id (:font-id span)
-        font-variant-id (:font-variant-id span)
-        font-weight-fallback (or (:font-weight span) (:font-weight paragraph))
-        font-style-fallback (or (:font-style span) (:font-style paragraph))
-        font-data (font-db-data font-id font-variant-id font-weight-fallback font-style-fallback)]
-    (-> span
-        (assoc :font-variant-id (or (:id font-data) (:id font-data) font-variant-id)
-               :font-weight (or (:weight font-data) font-weight-fallback)
-               :font-style (or (:style font-data) font-style-fallback)))))
-
-(defn normalize-paragraph-font
-  [paragraph]
-  (let [font-id (:font-id paragraph)
-        font-variant-id (:font-variant-id paragraph)
-        font-weight-fallback (:font-weight paragraph)
-        font-style-fallback (:font-style paragraph)
-        font-data (font-db-data font-id font-variant-id font-weight-fallback font-style-fallback)]
-    (-> paragraph
-        (assoc :font-variant-id (or (:id font-data) (:id font-data) font-variant-id)
-               :font-weight (or (:weight font-data) font-weight-fallback)
-               :font-style (or (:style font-data) font-style-fallback)))))
-
 (defn serialize-font-size
  [font-size]
  (cond
@@ -273,41 +244,26 @@
    (string? letter-spacing)
    (or (d/parse-double letter-spacing) default-letter-spacing)))

-
-(defn normalize-font-variant
-  [font-variant-id]
-  (if (or (nil? font-variant-id) (str/blank? font-variant-id))
-    "regular"
-    font-variant-id))
-
 (defn store-font
  [shape-id font]
  (let [font-id (get font :font-id)
        font-variant-id (get font :font-variant-id)
-        normalized-variant-id (when font-variant-id
-                                (-> font-variant-id
-                                    (str/lower)
-                                    (str/replace #"\s+" "")))
-        font-weight-fallback (or (get font :font-weight) 400)
-        font-style-fallback (or (get font :font-style) "normal")
        emoji? (get font :is-emoji false)
        fallback? (get font :is-fallback false)
-        font-data (font-db-data font-id normalized-variant-id font-weight-fallback font-style-fallback)
        wasm-id (font-id->uuid font-id)
-        raw-weight (or (:weight font-data) font-weight-fallback)
+        raw-weight (or (:weight (font-db-data font-id font-variant-id)) 400)
        weight (serialize-font-weight raw-weight)
-        style (cond
-                (str/includes? (or normalized-variant-id "") "italic") "italic"
-                (str/includes? raw-weight "italic") "italic"
-                :else font-style-fallback)
-        variant-id (or (:id font-data) normalized-variant-id)
-        asset-id (font-id->asset-id font-id variant-id raw-weight style)
+        style (serialize-font-style (cond
+                                      (str/includes? font-variant-id "italic") "italic"
+                                      (str/includes? raw-weight "italic") "italic"
+                                      :else "normal"))
+        asset-id (font-id->asset-id font-id font-variant-id)
        font-data {:wasm-id wasm-id
                   :font-id font-id
-                   :font-variant-id variant-id
-                   :style (serialize-font-style style)
-                   :style-name style
+                   :font-variant-id font-variant-id
+                   :style style
                   :weight weight}]
+
    (store-font-id shape-id font-data asset-id emoji? fallback?)))

 ;; FIXME: This is a temporary function to load the fallback fonts for the editor.
@@ -317,29 +273,6 @@
  (doseq [font fonts]
    (fonts/ensure-loaded! (:font-id font) (:font-variant-id font))))

-
-(defn get-content-fonts
-  "Extends from app.main.fonts/get-content-fonts. Extracts the fonts used by the content of a text shape, resolving the correct font variant info."
-  [content]
-  (let [paragraph-set (first (get content :children))
-        paragraphs (get paragraph-set :children)]
-    (->> paragraphs
-         (mapcat #(get % :children))
-         (filter txt/is-text-node?)
-         (reduce
-          (fn [result {:keys [font-id font-variant-id font-weight font-style] :as node}]
-            (let [resolved-font-id (or font-id (:font-id txt/default-typography))
-                  resolved-variant-id (or font-variant-id (:font-variant-id txt/default-typography))
-                  font-weight-fallback (or font-weight (:font-weight txt/default-typography) 400)
-                  font-style-fallback (or font-style (:font-style txt/default-typography) "normal")
-                  font-data (font-db-data resolved-font-id resolved-variant-id font-weight-fallback font-style-fallback)
-                  font-ref {:font-id resolved-font-id
-                            :font-variant-id (or (:id font-data) (:name font-data) resolved-variant-id)
-                            :font-weight (or (:weight font-data) font-weight-fallback)
-                            :font-style (or (:style font-data) font-style-fallback)}]
-              (conj result font-ref)))
-          #{}))))
-
 (defn store-fonts
  [shape-id fonts]
  (keep (fn [font] (store-font shape-id font)) fonts))
--- a/frontend/src/app/render_wasm/api/texts.cljs
+++ b/frontend/src/app/render_wasm/api/texts.cljs
@@ -80,7 +80,7 @@
                    font-size   (f/serialize-font-size font-size)

                    line-height     (f/serialize-line-height (get span :line-height) paragraph-line-height)
-                    letter-spacing  (f/serialize-letter-spacing (get span :letter-spacing))
+                    letter-spacing  (f/serialize-letter-spacing (get paragraph :letter-spacing))

                    font-weight (get span :font-weight paragraph-font-weight)
                    font-weight (f/serialize-font-weight font-weight)
@@ -142,9 +142,7 @@
  ;; buffer has the following format:
  ;; [<num-spans> <paragraph_attributes> <spans_attributes> <text>]
  [spans paragraph text]
-  (let [normalized-paragraph (f/normalize-paragraph-font paragraph)
-        normalized-spans (map #(f/normalize-span-font % normalized-paragraph) spans)
-        num-spans    (count normalized-spans)
+  (let [num-spans    (count spans)
        fills-size    (* types.fills.impl/FILL-U8-SIZE MAX-TEXT-FILLS)
        metadata-size (+ PARAGRAPH-ATTR-U8-SIZE
                         (* num-spans (+ SPAN-ATTR-U8-SIZE fills-size)))
@@ -159,8 +157,8 @@

    (-> offset
        (mem/write-u32 dview num-spans)
-        (write-paragraph dview normalized-paragraph)
-        (write-spans dview normalized-spans normalized-paragraph)
+        (write-paragraph dview paragraph)
+        (write-spans dview spans paragraph)
        (mem/write-buffer heapu8 text-buffer))

    (h/call wasm/internal-module "_set_shape_text_content")))
--- a/frontend/src/app/render_wasm/deserializers.cljs
+++ b/frontend/src/app/render_wasm/deserializers.cljs
@@ -45,29 +45,4 @@
     :center (gpt/point cx cy)
     :transform (gmt/matrix a b c d e f)}))

-(defn read-position-data-entry
-  [heapu32 heapf32 offset]
-  (let [paragraph (aget heapu32 (+ offset 0))
-        span      (aget heapu32 (+ offset 1))
-        start-pos (aget heapu32 (+ offset 2))
-        end-pos   (aget heapu32 (+ offset 3))
-        x         (aget heapf32 (+ offset 4))
-        y         (aget heapf32 (+ offset 5))
-        width     (aget heapf32 (+ offset 6))
-        height    (aget heapf32 (+ offset 7))
-        direction (aget heapu32 (+ offset 8))]
-    {:paragraph paragraph
-     :span      span
-     :start-pos start-pos
-     :end-pos   end-pos
-     :x         x
-     :y         y
-     :width     width
-     :height    height
-     :direction direction}))

-(defn translate-direction
-  [direction]
-  (case direction
-    0 "rtl"
-    "ltr"))
--- a/Show More
+++ b/Show More