🎉 Enable IPv6 support for docker images

2026-02-11 07:03:53 -05:00 · 2026-02-10 15:44:13 +01:00
279 changed files with 22884 additions and 15864 deletions
--- a/.github/workflows/build-docker.yml
+++ b/.github/workflows/build-docker.yml
@@ -59,7 +59,6 @@ jobs:
          mv penpot/frontend bundle-frontend
          mv penpot/exporter bundle-exporter
          mv penpot/storybook bundle-storybook
-          mv penpot/mcp bundle-mcp
          popd

      - name: Set up Docker Buildx
@@ -90,7 +89,6 @@ jobs:
            backend
            exporter
            storybook
-            mcp
          labels: |
            bundle_version=${{ steps.bundles.outputs.bundle_version }}

@@ -154,21 +152,6 @@ jobs:
          cache-from: type=registry,ref=${{ secrets.DOCKER_REGISTRY }}/${{ env.DOCKER_IMAGE }}:buildcache
          cache-to: type=registry,ref=${{ secrets.DOCKER_REGISTRY }}/${{ env.DOCKER_IMAGE }}:buildcache,mode=max

-      - name: Build and push MCP Docker image
-        uses: docker/build-push-action@v6
-        env:
-          DOCKER_IMAGE: 'mcp'
-          BUNDLE_PATH: './bundle-mcp'
-        with:
-          context: ./docker/images/
-          file: ./docker/images/Dockerfile.mcp
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: ${{ secrets.DOCKER_REGISTRY }}/${{ env.DOCKER_IMAGE }}:${{ steps.vars.outputs.gh_ref }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=registry,ref=${{ secrets.DOCKER_REGISTRY }}/${{ env.DOCKER_IMAGE }}:buildcache
-          cache-to: type=registry,ref=${{ secrets.DOCKER_REGISTRY }}/${{ env.DOCKER_IMAGE }}:buildcache,mode=max
-
      - name: Notify Mattermost
        if: failure()
        uses: mattermost/action-mattermost-notify@master
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -87,11 +87,7 @@ jobs:

      - name: Build runtime
        working-directory: ./plugins
-        run: pnpm run build:runtime
-
-      - name: Build doc
-        working-directory: ./plugins
-        run: pnpm run build:doc
+        run: pnpm run build

      - name: Build plugins
        working-directory: ./plugins
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -10,7 +10,6 @@

 ### :sparkles: New features & Enhancements

- Access to design tokens in Penpot Plugins [Taiga #8990](https://tree.taiga.io/project/penpot/us/8990)
 - Remap references when renaming tokens [Taiga #10202](https://tree.taiga.io/project/penpot/us/10202)
 - Tokens panel nested path view [Taiga #9966](https://tree.taiga.io/project/penpot/us/9966)
 - Improve usability of lock and hide buttons in the layer panel. [Taiga #12916](https://tree.taiga.io/project/penpot/issue/12916)
@@ -35,19 +34,6 @@
 - Fix viewer can update library [Taiga #13186](https://tree.taiga.io/project/penpot/issue/13186)
 - Fix remove fill affects different element than selected [Taiga #13128](https://tree.taiga.io/project/penpot/issue/13128)

-## 2.13.2
-
-### :bug: Bugs fixed
-
- Fix security issue (Path Traversal Vulnerability) on fonts related RPC method
-
-
-## 2.13.1
-
-### :bug: Bugs fixed
-
- Fix PDF Exporter outputs empty page when board has A4 format [Taiga #13181](https://tree.taiga.io/project/penpot/issue/13181)
-
 ## 2.13.0

 ### :heart: Community contributions (Thank you!)
--- a/backend/scripts/_env
+++ b/backend/scripts/_env
@@ -29,8 +29,6 @@ export PENPOT_FLAGS="\
       enable-user-feedback \
       disable-secure-session-cookies \
       enable-smtp \
-       enable-cors \
-       disable-secure-session-cookies \
       enable-prepl-server \
       enable-urepl-server \
       enable-rpc-climit \
--- a/backend/src/app/http/middleware.clj
+++ b/backend/src/app/http/middleware.clj
@@ -213,14 +213,14 @@
      (assoc "access-control-allow-origin" origin)
      (assoc "access-control-allow-methods" "GET,POST,DELETE,OPTIONS,PUT,HEAD,PATCH")
      (assoc "access-control-allow-credentials" "true")
-      (assoc "access-control-expose-headers" "content-type, set-cookie")
-      (assoc "access-control-allow-headers" "x-frontend-version, x-client, x-requested-width, content-type, accept, cookie")))
+      (assoc "access-control-expose-headers" "x-requested-with, content-type, cookie")
+      (assoc "access-control-allow-headers" "x-frontend-version, content-type, accept, x-requested-width")))

 (defn wrap-cors
  [handler]
  (fn [request]
    (let [response (if (= (yreq/method request) :options)
-                     {::yres/status 204}
+                     {::yres/status 200}
                     (handler request))
          origin   (yreq/get-header request "origin")]
      (update response ::yres/headers with-cors-headers origin))))
--- a/backend/src/app/main.clj
+++ b/backend/src/app/main.clj
@@ -275,8 +275,7 @@
    ::email/whitelist    (ig/ref ::email/whitelist)}

   ::mgmt/routes
-   {::db/pool            (ig/ref ::db/pool)
-    ::setup/props        (ig/ref ::setup/props)}
+   {::db/pool (ig/ref ::db/pool)}

   :app.http/router
   {::session/manager    (ig/ref ::session/manager)
--- a/backend/src/app/media.clj
+++ b/backend/src/app/media.clj
@@ -35,7 +35,8 @@
   javax.xml.parsers.SAXParserFactory
   org.apache.commons.io.IOUtils
   org.im4java.core.ConvertCmd
-   org.im4java.core.IMOperation))
+   org.im4java.core.IMOperation
+   org.im4java.core.Info))

 (def default-max-file-size
  (* 1024 1024 10)) ; 10 MiB
@@ -223,18 +224,17 @@
  ;; If we are processing an animated gif we use the first frame with -scene 0
  (let [dim-result (sh/sh "identify" "-format" "%w %h\n" path)
        orient-result (sh/sh "identify" "-format" "%[EXIF:Orientation]\n" path)]
-    (when (= 0 (:exit dim-result))
+    (if (and (= 0 (:exit dim-result))
+             (= 0 (:exit orient-result)))
      (let [[w h] (-> (:out dim-result)
                      str/trim
                      (clojure.string/split #"\s+")
                      (->> (mapv #(Integer/parseInt %))))
-            orientation-exit (:exit orient-result)
-            orientation      (-> orient-result :out str/trim)]
-        (if (= 0 orientation-exit)
-          (case orientation
-            ("6" "8") {:width h :height w} ; Rotated 90 or 270 degrees
-            {:width w :height h})          ; Normal or unknown orientation
-          {:width w :height h})))))        ; If orientation can't be read, use dimensions as-is
+            orientation (-> orient-result :out str/trim)]
+        (case orientation
+          ("6" "8") {:width h :height w} ; Rotated 90 or 270 degrees
+          {:width w :height h}))         ; Normal or unknown orientation
+      nil)))

 (defmethod process :info
  [{:keys [input] :as params}]
@@ -247,37 +247,26 @@
                    :hint "uploaded svg does not provides dimensions"))
        (merge input info {:ts (ct/now) :size (fs/size path)}))

-      (let [path-str      (str path)
-            identify-res  (sh/sh "identify" "-format" "image/%[magick]\n" path-str)
-            ;; identify prints one line per frame (animated GIFs, etc.); we take the first one
-            mtype'        (if (zero? (:exit identify-res))
-                            (-> identify-res
-                                :out
-                                str/trim
-                                (str/split #"\s+" 2)
-                                first
-                                str/lower)
-                            (ex/raise :type :validation
-                                      :code :invalid-image
-                                      :hint "invalid image"))
-            {:keys [width height]}
-            (or (get-dimensions-with-orientation path-str)
-                (do
-                  (l/warn "Failed to read image dimensions with orientation" {:path path})
-                  (ex/raise :type :validation
-                            :code :invalid-image
-                            :hint "invalid image")))]
+      (let [instance (Info. (str path))
+            mtype'   (.getProperty instance "Mime type")]
        (when (and (string? mtype)
-                   (not= (str/lower mtype) mtype'))
+                   (not= mtype mtype'))
          (ex/raise :type :validation
                    :code :media-type-mismatch
                    :hint (str "Seems like you are uploading a file whose content does not match the extension."
                               "Expected: " mtype ". Got: " mtype')))
-        (assoc input
-               :width  width
-               :height height
-               :size (fs/size path)
-               :ts (ct/now))))))
+        (let [{:keys [width height]}
+              (or (get-dimensions-with-orientation (str path))
+                  (do
+                    (l/warn "Failed to read image dimensions with orientation; falling back to im4java"
+                            {:path path})
+                    {:width  (.getPageWidth instance)
+                     :height (.getPageHeight instance)}))]
+          (assoc input
+                 :width  width
+                 :height height
+                 :size (fs/size path)
+                 :ts (ct/now)))))))

 (defmethod process-error org.im4java.core.InfoException
  [error]
--- a/backend/src/app/migrations.clj
+++ b/backend/src/app/migrations.clj
@@ -10,7 +10,6 @@
   [app.common.logging :as l]
   [app.db :as db]
   [app.migrations.clj.migration-0023 :as mg0023]
-   [app.migrations.clj.migration-0145 :as mg0145]
   [app.util.migrations :as mg]
   [integrant.core :as ig]))

@@ -460,11 +459,7 @@
    :fn (mg/resource "app/migrations/sql/0143-add-http-session-v2-table.sql")}

   {:name "0144-mod-server-error-report-table"
-    :fn (mg/resource "app/migrations/sql/0144-mod-server-error-report-table.sql")}
-
-   {:name "0145-fix-plugins-uri-on-profile"
-    :fn mg0145/migrate}])
-
+    :fn (mg/resource "app/migrations/sql/0144-mod-server-error-report-table.sql")}])

 (defn apply-migrations!
  [pool name migrations]
--- a/backend/src/app/migrations/clj/migration_0145.clj
+++ b/backend/src/app/migrations/clj/migration_0145.clj
@@ -1,83 +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.migrations.clj.migration-0145
-  "Migrate plugins references on profiles"
-  (:require
-   [app.common.data :as d]
-   [app.common.logging :as l]
-   [app.db :as db]
-   [cuerdas.core :as str]))
-
-(def ^:private replacements
-  {"https://colors-to-tokens-plugin.pages.dev"
-   "https://colors-to-tokens.plugins.penpot.app"
-
-   "https://contrast-penpot-plugin.pages.dev"
-   "https://contrast.plugins.penpot.app"
-
-   "https://create-palette-penpot-plugin.pages.dev"
-   "https://create-palette.plugins.penpot.app"
-
-   "https://icons-penpot-plugin.pages.dev"
-   "https://icons.plugins.penpot.app"
-
-   "https://lorem-ipsum-penpot-plugin.pages.dev"
-   "https://lorem-ipsum.plugins.penpot.app"
-
-   "https://rename-layers-penpot-plugin.pages.dev"
-   "https://rename-layers.plugins.penpot.app"
-
-   "https://table-penpot-plugin.pages.dev"
-   "https://table.plugins.penpot.app"})
-
-(defn- fix-url
-  [url]
-  (reduce-kv (fn [url prefix replacement]
-               (if (str/starts-with? url prefix)
-                 (reduced (str replacement (subs url (count prefix))))
-                 url))
-             url
-             replacements))
-
-
-(defn- fix-manifest
-  [manifest]
-  (-> manifest
-      (d/update-when :url fix-url)
-      (d/update-when :host fix-url)))
-
-(defn- fix-plugins-data
-  [props]
-  (d/update-in-when props [:plugins :data]
-                    (fn [data]
-                      (reduce-kv (fn [data id manifest]
-                                   (let [manifest' (fix-manifest manifest)]
-                                     (if (= manifest manifest')
-                                       data
-                                       (assoc data id manifest'))))
-                                 data
-                                 data))))
-
-(def ^:private sql:get-profiles
-  "SELECT id, props FROM profile
-    WHERE props ?? '~:plugins'
-    ORDER BY created_at
-      FOR UPDATE")
-
-(defn migrate
-  [conn]
-  (->> (db/plan conn [sql:get-profiles])
-       (run! (fn [{:keys [id props]}]
-               (when-let [props (some-> props db/decode-transit-pgobject)]
-                 (let [props' (fix-plugins-data props)]
-                   (when (not= props props')
-                     (l/inf :hint "fixing plugins data on profile props" :profile-id (str id))
-                     (db/update! conn :profile
-                                 {:props (db/tjson props')}
-                                 {:id id}
-                                 {::db/return-keys false}))))))))
-
--- a/backend/src/app/rpc/commands/fonts.clj
+++ b/backend/src/app/rpc/commands/fonts.clj
@@ -89,8 +89,7 @@
 (def ^:private schema:create-font-variant
  [:map {:title "create-font-variant"}
   [:team-id ::sm/uuid]
-   [:data [:map-of ::sm/text [:or ::sm/bytes
-                              [::sm/vec ::sm/bytes]]]]
+   [:data [:map-of ::sm/text ::sm/any]]
   [:font-id ::sm/uuid]
   [:font-family ::sm/text]
   [:font-weight [::sm/one-of {:format "number"} valid-weight]]
--- a/backend/src/app/rpc/management/nitrate.clj
+++ b/backend/src/app/rpc/management/nitrate.clj
@@ -9,7 +9,7 @@
  organization management and token validation endpoints."
  (:require
   [app.common.schema :as sm]
-   [app.common.types.profile :refer [schema:profile, schema:basic-profile]]
+   [app.common.types.profile :refer [schema:profile]]
   [app.common.types.team :refer [schema:team]]
   [app.common.uuid :as uuid]
   [app.db :as db]
@@ -80,35 +80,3 @@
                         :team-id id
                         :organization-id organization-id
                         :organization-name organization-name})))
-
-
-;; ---- API: get-managed-profiles
-
-(def ^:private sql:get-managed-profiles
-  "SELECT DISTINCT p.id, p.fullname as name, p.email
-     FROM profile p
-     JOIN team_profile_rel tpr_member
-       ON tpr_member.profile_id = p.id
-    WHERE p.id <> ?
-      AND EXISTS (
-        SELECT 1
-          FROM team_profile_rel tpr_owner
-          JOIN team t
-            ON t.id = tpr_owner.team_id
-         WHERE tpr_owner.profile_id = ?
-           AND tpr_owner.team_id = tpr_member.team_id
-           AND tpr_owner.is_owner IS TRUE
-           AND t.is_default IS FALSE
-           AND t.deleted_at IS NULL);")
-
-(def schema:managed-profile-result
-  [:vector schema:basic-profile])
-
-(sv/defmethod ::get-managed-profiles
-  "List profiles that belong to teams for which current user is owner"
-  {::doc/added "2.14"
-   ::sm/params [:map]
-   ::sm/result schema:managed-profile-result}
-  [cfg {:keys [::rpc/profile-id]}]
-  (let [current-user-id (-> (profile/get-profile cfg profile-id) :id)]
-    (db/exec! cfg [sql:get-managed-profiles current-user-id current-user-id])))
--- a/backend/test/backend_tests/rpc_font_test.clj
+++ b/backend/test/backend_tests/rpc_font_test.clj
@@ -274,30 +274,3 @@
      (let [res (th/run-task! :storage-gc-touched {})]
        (t/is (= 0 (:freeze res)))
        (t/is (= 3 (:delete res)))))))
-
-(t/deftest input-sanitization-1
-  (with-mocks [mock {:target 'app.rpc.quotes/check! :return nil}]
-    (let [prof    (th/create-profile* 1 {:is-active true})
-          team-id (:default-team-id prof)
-          proj-id (:default-project-id prof)
-          font-id (uuid/custom 10 1)
-
-          ttfdata (-> (io/resource "backend_tests/test_files/font-1.ttf")
-                      (io/read*))
-
-          params  {::th/type :create-font-variant
-                   ::rpc/profile-id (:id prof)
-                   :team-id team-id
-                   :font-id font-id
-                   :font-family "somefont"
-                   :font-weight 400
-                   :font-style "normal"
-                   :data {"font/ttf" "/etc/passwd"}}
-          out     (th/command! params)]
-
-      (t/is (= 0 (:call-count @mock)))
-      ;; (th/print-result! out)
-
-      (let [error      (:error out)
-            error-data (ex-data error)]
-        (t/is (th/ex-info? error))))))
--- a/common/src/app/common/files/changes.cljc
+++ b/common/src/app/common/files/changes.cljc
@@ -27,7 +27,6 @@
   [app.common.types.path :as path]
   [app.common.types.shape :as cts]
   [app.common.types.shape-tree :as ctst]
-   [app.common.types.token :as cto]
   [app.common.types.tokens-lib :as ctob]
   [app.common.types.typographies-list :as ctyl]
   [app.common.types.typography :as ctt]
@@ -379,7 +378,7 @@
     [:type [:= :set-token]]
     [:set-id ::sm/uuid]
     [:token-id ::sm/uuid]
-     [:attrs [:maybe cto/schema:token-attrs]]]]
+     [:attrs [:maybe ctob/schema:token-attrs]]]]

   [:set-token-set
    [:map {:title "SetTokenSetChange"}
--- a/common/src/app/common/files/tokens.cljc
+++ b/common/src/app/common/files/tokens.cljc
@@ -8,228 +8,8 @@
  (:require
   [app.common.data :as d]
   [app.common.data.macros :as dm]
-   [app.common.i18n :refer [tr]]
-   [app.common.schema :as sm]
-   [app.common.types.token :as cto]
-   [app.common.types.tokens-lib :as ctob]
   [clojure.set :as set]
-   [cuerdas.core :as str]
-   [malli.core :as m]))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; HIGH LEVEL SCHEMAS
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; Token value
-
-(defn- token-value-empty-fn
-  [{:keys [value]}]
-  (when (or (str/empty? value)
-            (str/blank? value))
-    (tr "workspace.tokens.empty-input")))
-
-(def schema:token-value-generic
-  [::sm/text {:error/fn token-value-empty-fn}])
-
-(def schema:token-value-composite-ref
-  [::sm/text {:error/fn token-value-empty-fn}])
-
-(def schema:token-value-font-family
-  [:vector :string])
-
-(def schema:token-value-typography-map
-  [:map
-   [:font-family {:optional true} schema:token-value-font-family]
-   [:font-weight {:optional true} schema:token-value-generic]
-   [:font-size {:optional true} schema:token-value-generic]
-   [:line-height {:optional true} schema:token-value-generic]
-   [:letter-spacing {:optional true} schema:token-value-generic]
-   [:paragraph-spacing {:optional true} schema:token-value-generic]
-   [:text-decoration {:optional true} schema:token-value-generic]
-   [:text-case {:optional true} schema:token-value-generic]])
-
-(def schema:token-value-typography
-  [:or
-   schema:token-value-typography-map
-   schema:token-value-composite-ref])
-
-(def schema:token-value-shadow-vector
-  [:vector
-   [:map
-    [:offset-x :string]
-    [:offset-y :string]
-    [:blur
-     [:and
-      :string
-      [:fn {:error/fn #(tr "workspace.tokens.shadow-token-blur-value-error")}
-       (fn [blur]
-         (let [n (d/parse-double blur)]
-           (or (nil? n) (not (< n 0)))))]]]
-    [:spread
-     [:and
-      :string
-      [:fn {:error/fn #(tr "workspace.tokens.shadow-token-spread-value-error")}
-       (fn [spread]
-         (let [n (d/parse-double spread)]
-           (or (nil? n) (not (< n 0)))))]]]
-    [:color :string]
-    [:inset {:optional true} :boolean]]])
-
-(def schema:token-value-shadow
-  [:or
-   schema:token-value-shadow-vector
-   schema:token-value-composite-ref])
-
-(defn make-token-value-schema
-  [token-type]
-  [:multi {:dispatch (constantly token-type)
-           :title "Token Value"}
-   [:font-family schema:token-value-font-family]
-   [:typography schema:token-value-typography]
-   [:shadow schema:token-value-shadow]
-   [::m/default schema:token-value-generic]])
-
-;; Token
-
-(defn make-token-name-schema
-  "Dynamically generates a schema to check a token name, adding translated error messages
-   and two additional validations:
-    - Min and max length.
-    - Checks if other token with a path derived from the name already exists at `tokens-tree`.
-      e.g. it's not allowed to create a token `foo.bar` if a token `foo` already exists."
-  [tokens-tree]
-  [:and
-   [:string {:min 1 :max 255 :error/fn #(str (:value %) (tr "workspace.tokens.token-name-length-validation-error"))}]
-   (-> cto/schema:token-name
-       (sm/update-properties assoc :error/fn #(str (:value %) (tr "workspace.tokens.token-name-validation-error"))))
-   [:fn {:error/fn #(tr "workspace.tokens.token-name-duplication-validation-error" (:value %))}
-    #(and (some? tokens-tree)
-          (not (ctob/token-name-path-exists? % tokens-tree)))]])
-
-(def schema:token-description
-  [:string {:max 2048 :error/fn #(tr "errors.field-max-length" 2048)}])
-
-(defn make-token-schema
-  [tokens-tree token-type]
-  [:and
-   (sm/merge
-    cto/schema:token-attrs
-    [:map
-     [:name (make-token-name-schema tokens-tree)]
-     [:value (make-token-value-schema token-type)]
-     [:description {:optional true} schema:token-description]])
-   [:fn {:error/field :value
-         :error/fn #(tr "workspace.tokens.self-reference")}
-    (fn [{:keys [name value]}]
-      (when (and name value)
-        (not (cto/token-value-self-reference? name value))))]])
-
-(defn convert-dtcg-token
-  "Convert token attributes as they come from a decoded json, with DTCG types, to internal types.
-   Eg. From this:
-
-     {'name' 'body-text'
-      'type' 'typography'
-      'value' {
-        'fontFamilies' ['Arial' 'Helvetica' 'sans-serif']
-        'fontSize' '16px'
-        'fontWeights' 'normal'}}
-
-   to this
-     {:name 'body-text'
-      :type :typography
-      :value {
-        :font-family ['Arial' 'Helvetica' 'sans-serif']
-        :font-size '16px'
-        :font-weight 'normal'}}"
-  [token-attrs]
-  (let [name        (get token-attrs "name")
-        type        (get token-attrs "type")
-        value       (get token-attrs "value")
-        description (get token-attrs "description")
-
-        type  (cto/dtcg-token-type->token-type type)
-        value (case type
-                :font-family (ctob/convert-dtcg-font-family value)
-                :typography  (ctob/convert-dtcg-typography-composite value)
-                :shadow      (ctob/convert-dtcg-shadow-composite value)
-                value)]
-
-    (d/without-nils {:name name
-                     :type type
-                     :value value
-                     :description description})))
-
-;; Token set
-
-(defn make-token-set-name-schema
-  "Generates a dynamic schema to check a token set name:
-    - Validate name length.
-    - Checks if other token set with a path derived from the name already exists in the tokens lib."
-  [tokens-lib set-id]
-  [:and
-   [:string {:min 1 :max 255 :error/fn #(str (:value %) (tr "workspace.tokens.token-name-length-validation-error"))}]
-   [:fn {:error/fn #(tr "errors.token-set-already-exists" (:value %))}
-    (fn [name]
-      (or (nil? tokens-lib)
-          (let [set (ctob/get-set-by-name tokens-lib name)]
-            (or (nil? set) (= (ctob/get-id set) set-id)))))]])
-
-(def schema:token-set-description
-  [:string {:max 2048 :error/fn #(tr "errors.field-max-length" 2048)}])
-
-(defn make-token-set-schema
-  [tokens-lib set-id]
-  (sm/merge
-   ctob/schema:token-set-attrs
-   [:map
-    [:name [:and (make-token-set-name-schema tokens-lib set-id)
-            [:fn #(ctob/normalized-set-name? %)]]]
-    [:description {:optional true} schema:token-set-description]]))
-
-;; Token theme
-
-(defn make-token-theme-group-schema
-  "Generates a dynamic schema to check a token theme group:
-    - Validate group length.
-    - Checks if other token theme with the same name already exists in the new group in the tokens lib."
-  [tokens-lib name theme-id]
-  [:and
-   [:string {:min 0 :max 255 :error/fn #(str (:value %) (tr "workspace.tokens.token-name-length-validation-error"))}]
-   [:fn {:error/fn #(tr "errors.token-theme-already-exists" (:value %))}
-    (fn [group]
-      (or (nil? tokens-lib)
-          (let [theme (ctob/get-theme-by-name tokens-lib group name)]
-            (or (nil? theme) (= (:id theme) theme-id)))))]])
-
-(defn make-token-theme-name-schema
-  "Generates a dynamic schema to check a token theme name:
-    - Validate name length.
-    - Checks if other token theme with the same name already exists in the same group in the tokens lib."
-  [tokens-lib group theme-id]
-  [:and
-   [:string {:min 1 :max 255 :error/fn #(str (:value %) (tr "workspace.tokens.token-name-length-validation-error"))}]
-   [:fn {:error/fn #(tr "errors.token-theme-already-exists" (str group "/" (:value %)))}
-    (fn [name]
-      (or (nil? tokens-lib)
-          (let [theme (ctob/get-theme-by-name tokens-lib group name)]
-            (or (nil? theme) (= (:id theme) theme-id)))))]])
-
-(def schema:token-theme-description
-  [:string {:max 2048 :error/fn #(tr "errors.field-max-length" 2048)}])
-
-(defn make-token-theme-schema
-  [tokens-lib group name theme-id]
-  (sm/merge
-   ctob/schema:token-theme-attrs
-   [:map
-    [:group (make-token-theme-group-schema tokens-lib name theme-id)] ;; TODO how to keep error-fn from here?
-    [:name (make-token-theme-name-schema tokens-lib group theme-id)]
-    [:description {:optional true} schema:token-theme-description]]))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; HELPERS
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+   [cuerdas.core :as str]))

 (def parseable-token-value-regexp
  "Regexp that can be used to parse a number value out of resolved token value.
@@ -300,6 +80,56 @@
 (defn shapes-applied-all? [ids-by-attributes shape-ids attributes]
  (every? #(set/superset? (get ids-by-attributes %) shape-ids) attributes))

+(defn token-name->path
+  "Splits token-name into a path vector split by `.` characters.
+
+  Will concatenate multiple `.` characters into one."
+  [token-name]
+  (str/split token-name #"\.+"))
+
+(defn token-name->path-selector
+  "Splits token-name into map with `:path` and `:selector` using `token-name->path`.
+
+  `:selector` is the last item of the names path
+  `:path` is everything leading up the the `:selector`."
+  [token-name]
+  (let [path-segments (token-name->path token-name)
+        last-idx (dec (count path-segments))
+        [path [selector]] (split-at last-idx path-segments)]
+    {:path (seq path)
+     :selector selector}))
+
+(defn token-name-path-exists?
+  "Traverses the path from `token-name` down a `token-tree` and checks if a token at that path exists.
+
+  It's not allowed to create a token inside a token. E.g.:
+  Creating a token with
+
+    {:name \"foo.bar\"}
+
+  in the tokens tree:
+
+    {\"foo\" {:name \"other\"}}"
+  [token-name token-names-tree]
+  (let [{:keys [path selector]} (token-name->path-selector token-name)
+        path-target (reduce
+                     (fn [acc cur]
+                       (let [target (get acc cur)]
+                         (cond
+                           ;; Path segment doesn't exist yet
+                           (nil? target) (reduced false)
+                           ;; A token exists at this path
+                           (:name target) (reduced true)
+                           ;; Continue traversing the true
+                           :else target)))
+                     token-names-tree path)]
+    (cond
+      (boolean? path-target) path-target
+      (get path-target :name) true
+      :else (-> (get path-target selector)
+                (seq)
+                (boolean)))))
+
 (defn color-token? [token]
  (= (:type token) :color))

--- a/common/src/app/common/i18n.cljc
+++ b/common/src/app/common/i18n.cljc
@@ -1,15 +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.common.i18n
-  "Dummy i18n functions, to be used by code in common that needs translations.")
-
-(defn tr
-  "This function will be monkeypatched at runtime with the real function in frontend i18n.
-   Here it just returns the key passed as argument. This way the result can be used in
-   unit tests or backend code for logs or error messages."
-  [key & _args]
-  key)
--- a/common/src/app/common/logic/shapes.cljc
+++ b/common/src/app/common/logic/shapes.cljc
@@ -58,7 +58,7 @@
                              (cto/shape-attr->token-attrs attr changed-sub-attr))]

            (if (some #(contains? tokens %) token-attrs)
-              (pcb/update-shapes changes [shape-id] #(cto/unapply-tokens-from-shape % token-attrs))
+              (pcb/update-shapes changes [shape-id] #(cto/unapply-token-id % token-attrs))
              changes)))

        check-shape
--- a/common/src/app/common/schema.cljc
+++ b/common/src/app/common/schema.cljc
@@ -11,7 +11,6 @@
   #?(:clj [malli.dev.pretty :as mdp])
   #?(:clj [malli.dev.virhe :as v])
   [app.common.data :as d]
-   [app.common.json :as json]
   [app.common.math :as mth]
   [app.common.pprint :as pp]
   [app.common.schema.generators :as sg]
@@ -93,31 +92,6 @@
  [& items]
  (apply mu/merge (map schema items)))

-(defn assoc-key
-  "Add a key & value to a schema of type [:map]. If the first level node of the schema
-   is not a map, will do a depth search to find the first map node and add the key there."
-  ([s k v]
-   (assoc-key s k {} v))
-  ([s k opts v]  ;; change order of opts and v to match static schema defintions (e.g. [:something {:optional true} ::sm/integer])
-   (let [s (schema s)
-         v (schema v)]
-     (if (= (m/type s) :map)
-       (mu/assoc s k v opts)
-       (if-let [path (mu/find-first s (fn [s' path _] (when (= (m/type s') :map) path)))]
-         (mu/assoc-in s (conj path k) v opts)
-         s)))))
-
-(defn dissoc-key
-  "Remove a key from a schema of type [:map]. If the first level node of the schema
-   is not a map, will do a depth search to find the first map node and remove the key there."
-  [s k]
-  (let [s (schema s)]
-    (if (= (m/type s) :map)
-      (mu/dissoc s k)
-      (if-let [path (mu/find-first s (fn [s' path _] (when (= (m/type s') :map) path)))]
-        (mu/update-in s path mu/dissoc k)
-        s))))
-
 (defn ref?
  [s]
  (m/-ref-schema? s))
@@ -296,13 +270,6 @@
     (let [explain (fn [] (me/with-error-messages explain))]
       ((mdp/prettifier variant message explain default-options)))))

-(defn validation-errors
-  "Checks a value against a schema. If valid, returns nil. If not, returns a list
-   of english error messages."
-  [value schema]
-  (let [explainer (explainer schema)]
-    (-> value explainer simplify not-empty)))
-
 (defmacro ignoring
  [expr]
  (if (:ns &env)
@@ -883,32 +850,6 @@
   :encode/string str
   ::oapi/type "boolean"}})

-(defn parse-keyword
-  [v]
-  (if (string? v)
-    (-> v (json/read-kebab-key) (keyword))
-    v))
-
-(defn format-keyword
-  [v]
-  (if (keyword? v)
-    (-> v (name) (json/write-camel-key))
-    v))
-
-(register!
- {:type ::keyword
-  :pred keyword?
-  :type-properties
-  {:title "keyword"
-   :description "keyword"
-   :error/message "expected keyword"
-   :error/code "errors.invalid-keyword"
-   :gen/gen sg/keyword
-   :decode/string parse-keyword
-   :decode/json parse-keyword
-   :encode/string format-keyword
-   ::oapi/type "string"}})
-
 (register!
 {:type ::contains-any
  :min 1
@@ -1068,15 +1009,6 @@
     {:title "agent"
      :description "instance of clojure agent"}}))

-#?(:clj
-   (register!
-    {:type ::bytes
-     :pred bytes?
-     :type-properties
-     {:title "bytes"
-      :description "bytes array"}}))
-
-
 (register! ::any (mu/update-properties :any assoc :gen/gen sg/any))

 ;; ---- PREDICATES
--- a/common/src/app/common/types/profile.cljc
+++ b/common/src/app/common/types/profile.cljc
@@ -21,10 +21,3 @@
   ;; Only present on resolved profile objects, the resolve process
   ;; takes the photo-id or geneates an image from the name
   [:photo-url {:optional true} :string]])
-
-
-(def schema:basic-profile
-  [:map {:title "Basic profile"}
-   [:id ::sm/uuid]
-   [:name {:optional true} :string]
-   [:email {:optional true} :string]])
--- a/common/src/app/common/types/text.cljc
+++ b/common/src/app/common/types/text.cljc
@@ -407,19 +407,17 @@
 (defn change-text
  "Changes the content of the text shape to use the text as argument. Will use the styles of the
   first paragraph and text that is present in the shape (and override the rest)"
-  [content text & {:as styles}]
+  [content text]
  (let [root-styles (select-keys content root-attrs)

        paragraph-style
        (merge
         default-text-attrs
-         styles
         (select-keys (->> content (node-seq is-paragraph-node?) first) text-all-attrs))

        text-style
        (merge
         default-text-attrs
-         styles
         (select-keys (->> content (node-seq is-text-node?) first) text-all-attrs))

        paragraph-texts
--- a/common/src/app/common/types/token.cljc
+++ b/common/src/app/common/types/token.cljc
@@ -9,13 +9,13 @@
   [app.common.data :as d]
   [app.common.schema :as sm]
   [app.common.schema.generators :as sg]
-   [app.common.time :as ct]
+   [clojure.data :as data]
   [clojure.set :as set]
   [cuerdas.core :as str]
   [malli.util :as mu]))

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; GENERAL HELPERS
+;; HELPERS
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 (defn- schema-keys
@@ -45,7 +45,7 @@
  [token-name token-value]
  (let [token-references (find-token-value-references token-value)
        self-reference? (get token-references token-name)]
-    (boolean self-reference?)))
+    self-reference?))

 (defn references-token?
  "Recursively check if a value references the token name. Handles strings, maps, and sequences."
@@ -59,33 +59,14 @@
    (some true? (map #(references-token? % token-name) value))
    :else false))

-(defn composite-token-reference?
-  "Predicate if a composite token is a reference value - a string pointing to another token."
-  [token-value]
-  (string? token-value))
-
-(defn update-token-value-references
-  "Recursively update token references within a token value, supporting complex token values (maps, sequences, strings)."
-  [value old-name new-name]
-  (cond
-    (string? value)
-    (str/replace value
-                 (re-pattern (str "\\{" (str/replace old-name "." "\\.") "\\}"))
-                 (str "{" new-name "}"))
-    (map? value)
-    (d/update-vals value #(update-token-value-references % old-name new-name))
-    (sequential? value)
-    (mapv #(update-token-value-references % old-name new-name) value)
-    :else
-    value))
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; SCHEMA: Token types
+;; SCHEMA
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 (def token-type->dtcg-token-type
  {:boolean         "boolean"
   :border-radius   "borderRadius"
+   :shadow          "shadow"
   :color           "color"
   :dimensions      "dimension"
   :font-family     "fontFamilies"
@@ -96,7 +77,6 @@
   :opacity         "opacity"
   :other           "other"
   :rotation        "rotation"
-   :shadow          "shadow"
   :sizing          "sizing"
   :spacing         "spacing"
   :string          "string"
@@ -114,13 +94,14 @@
             "boxShadow" :shadow)))

 (def composite-token-type->dtcg-token-type
-  "When converting the type of one element inside a composite token, an additional type
-   :line-height is available, that is not allowed for a standalone token."
+  "Custom set of conversion keys for composite typography token with `:line-height` available.
+  (Penpot doesn't support `:line-height` token)"
  (assoc token-type->dtcg-token-type
         :line-height "lineHeights"))

 (def composite-dtcg-token-type->token-type
-  "Same as above, in the opposite direction."
+  "Custom set of conversion keys for composite typography token with `:line-height` available.
+  (Penpot doesn't support `:line-height` token)"
  (assoc dtcg-token-type->token-type
         "lineHeights" :line-height
         "lineHeight"  :line-height))
@@ -128,114 +109,86 @@
 (def token-types
  (into #{} (keys token-type->dtcg-token-type)))

-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; SCHEMA: Token
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
 (def token-name-validation-regex
  #"^[a-zA-Z0-9_-][a-zA-Z0-9$_-]*(\.[a-zA-Z0-9$_-]+)*$")

-(def schema:token-name
-  "A token name can contains letters, numbers, underscores the character $ and dots, but
-   not start with $ or end with a dot. The $ character does not have any special meaning,
-   but dots separate token groups (e.g. color.primary.background)."
-  [:re {:title "TokenName"
-        :gen/gen sg/text}
+(def token-name-ref
+  [:re {:title "TokenNameRef" :gen/gen sg/text}
   token-name-validation-regex])

-(def schema:token-type
-  [::sm/one-of {:decode/json (fn [type]
-                               (if (string? type)
-                                 (dtcg-token-type->token-type type)
-                                 type))}
-
-   token-types])
-
-(def schema:token-attrs
-  [:map {:title "Token"}
-   [:id ::sm/uuid]
-   [:name schema:token-name]
-   [:type schema:token-type]
-   [:value ::sm/any]
-   [:description {:optional true} :string]
-   [:modified-at {:optional true} ::ct/inst]])
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; SCHEMA: Token application to shape
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; All the following schemas define the `:applied-tokens` attribute of a shape.
-;; This attribute is a map <token-attribute> -> <token-name>.
-;; Token attributes approximately match shape attributes, but not always.
-;; For each schema there is a `*keys` set including all the possible token attributes
-;; to which a token of the corresponding type can be applied.
-;; Some token types can be applied to some attributes only if the shape has a
-;; particular condition (i.e. has a layout itself or is a layout item).
-
-(def ^:private schema:border-radius
-  [:map {:title "BorderRadiusTokenAttrs"}
-   [:r1 {:optional true} schema:token-name]
-   [:r2 {:optional true} schema:token-name]
-   [:r3 {:optional true} schema:token-name]
-   [:r4 {:optional true} schema:token-name]])
-
-(def border-radius-keys (schema-keys schema:border-radius))
-
 (def ^:private schema:color
  [:map
-   [:fill {:optional true} schema:token-name]
-   [:stroke-color {:optional true} schema:token-name]])
+   [:fill {:optional true} token-name-ref]
+   [:stroke-color {:optional true} token-name-ref]])

 (def color-keys (schema-keys schema:color))

+(def ^:private schema:border-radius
+  [:map {:title "BorderRadiusTokenAttrs"}
+   [:r1 {:optional true} token-name-ref]
+   [:r2 {:optional true} token-name-ref]
+   [:r3 {:optional true} token-name-ref]
+   [:r4 {:optional true} token-name-ref]])
+
+(def border-radius-keys (schema-keys schema:border-radius))
+
+(def ^:private schema:shadow
+  [:map {:title "ShadowTokenAttrs"}
+   [:shadow {:optional true} token-name-ref]])
+
+(def shadow-keys (schema-keys schema:shadow))
+
+(def ^:private schema:stroke-width
+  [:map
+   [:stroke-width {:optional true} token-name-ref]])
+
+(def stroke-width-keys (schema-keys schema:stroke-width))
+
 (def ^:private schema:sizing-base
  [:map {:title "SizingBaseTokenAttrs"}
-   [:width {:optional true} schema:token-name]
-   [:height {:optional true} schema:token-name]])
+   [:width {:optional true} token-name-ref]
+   [:height {:optional true} token-name-ref]])

 (def ^:private schema:sizing-layout-item
  [:map {:title "SizingLayoutItemTokenAttrs"}
-   [:layout-item-min-w {:optional true} schema:token-name]
-   [:layout-item-max-w {:optional true} schema:token-name]
-   [:layout-item-min-h {:optional true} schema:token-name]
-   [:layout-item-max-h {:optional true} schema:token-name]])
-
-(def sizing-layout-item-keys (schema-keys schema:sizing-layout-item))
+   [:layout-item-min-w {:optional true} token-name-ref]
+   [:layout-item-max-w {:optional true} token-name-ref]
+   [:layout-item-min-h {:optional true} token-name-ref]
+   [:layout-item-max-h {:optional true} token-name-ref]])

 (def ^:private schema:sizing
  (-> (reduce mu/union [schema:sizing-base
                        schema:sizing-layout-item])
      (mu/update-properties assoc :title "SizingTokenAttrs")))

+(def sizing-layout-item-keys (schema-keys schema:sizing-layout-item))
+
 (def sizing-keys (schema-keys schema:sizing))

+(def ^:private schema:opacity
+  [:map {:title "OpacityTokenAttrs"}
+   [:opacity {:optional true} token-name-ref]])
+
+(def opacity-keys (schema-keys schema:opacity))
+
 (def ^:private schema:spacing-gap
  [:map {:title "SpacingGapTokenAttrs"}
-   [:row-gap {:optional true} schema:token-name]
-   [:column-gap {:optional true} schema:token-name]])
+   [:row-gap {:optional true} token-name-ref]
+   [:column-gap {:optional true} token-name-ref]])

 (def ^:private schema:spacing-padding
  [:map {:title "SpacingPaddingTokenAttrs"}
-   [:p1 {:optional true} schema:token-name]
-   [:p2 {:optional true} schema:token-name]
-   [:p3 {:optional true} schema:token-name]
-   [:p4 {:optional true} schema:token-name]])
-
-(def ^:private schema:spacing-gap-padding
-  (-> (reduce mu/union [schema:spacing-gap
-                        schema:spacing-padding])
-      (mu/update-properties assoc :title "SpacingGapPaddingTokenAttrs")))
-
-(def spacing-gap-padding-keys (schema-keys schema:spacing-gap-padding))
+   [:p1 {:optional true} token-name-ref]
+   [:p2 {:optional true} token-name-ref]
+   [:p3 {:optional true} token-name-ref]
+   [:p4 {:optional true} token-name-ref]])

 (def ^:private schema:spacing-margin
  [:map {:title "SpacingMarginTokenAttrs"}
-   [:m1 {:optional true} schema:token-name]
-   [:m2 {:optional true} schema:token-name]
-   [:m3 {:optional true} schema:token-name]
-   [:m4 {:optional true} schema:token-name]])
-
-(def spacing-margin-keys (schema-keys schema:spacing-margin))
+   [:m1 {:optional true} token-name-ref]
+   [:m2 {:optional true} token-name-ref]
+   [:m3 {:optional true} token-name-ref]
+   [:m4 {:optional true} token-name-ref]])

 (def ^:private schema:spacing
  (-> (reduce mu/union [schema:spacing-gap
@@ -243,13 +196,16 @@
                        schema:spacing-margin])
      (mu/update-properties assoc :title "SpacingTokenAttrs")))

+(def spacing-margin-keys (schema-keys schema:spacing-margin))
+
 (def spacing-keys (schema-keys schema:spacing))

-(def ^:private schema:stroke-width
-  [:map
-   [:stroke-width {:optional true} schema:token-name]])
+(def ^:private schema:spacing-gap-padding
+  (-> (reduce mu/union [schema:spacing-gap
+                        schema:spacing-padding])
+      (mu/update-properties assoc :title "SpacingGapPaddingTokenAttrs")))

-(def stroke-width-keys (schema-keys schema:stroke-width))
+(def spacing-gap-padding-keys (schema-keys schema:spacing-gap-padding))

 (def ^:private schema:dimensions
  (-> (reduce mu/union [schema:sizing
@@ -260,109 +216,91 @@

 (def dimensions-keys (schema-keys schema:dimensions))

-(def ^:private schema:font-family
+(def ^:private schema:axis
  [:map
-   [:font-family {:optional true} schema:token-name]])
+   [:x {:optional true} token-name-ref]
+   [:y {:optional true} token-name-ref]])

-(def font-family-keys (schema-keys schema:font-family))
-
-(def ^:private schema:font-size
-  [:map {:title "FontSizeTokenAttrs"}
-   [:font-size {:optional true} schema:token-name]])
-
-(def font-size-keys (schema-keys schema:font-size))
-
-(def ^:private schema:font-weight
-  [:map
-   [:font-weight {:optional true} schema:token-name]])
-
-(def font-weight-keys (schema-keys schema:font-weight))
-
-(def ^:private schema:letter-spacing
-  [:map {:title "LetterSpacingTokenAttrs"}
-   [:letter-spacing {:optional true} schema:token-name]])
-
-(def letter-spacing-keys (schema-keys schema:letter-spacing))
-
-(def ^:private schema:line-height        ;; This is not available for standalone tokens, only typography
-  [:map {:title "LineHeightTokenAttrs"}
-   [:line-height {:optional true} schema:token-name]])
-
-(def line-height-keys (schema-keys schema:line-height))
+(def axis-keys (schema-keys schema:axis))

 (def ^:private schema:rotation
  [:map {:title "RotationTokenAttrs"}
-   [:rotation {:optional true} schema:token-name]])
+   [:rotation {:optional true} token-name-ref]])

 (def rotation-keys (schema-keys schema:rotation))

+(def ^:private schema:font-size
+  [:map {:title "FontSizeTokenAttrs"}
+   [:font-size {:optional true} token-name-ref]])
+
+(def font-size-keys (schema-keys schema:font-size))
+
+(def ^:private schema:letter-spacing
+  [:map {:title "LetterSpacingTokenAttrs"}
+   [:letter-spacing {:optional true} token-name-ref]])
+
+(def letter-spacing-keys (schema-keys schema:letter-spacing))
+
+(def ^:private schema:font-family
+  [:map
+   [:font-family {:optional true} token-name-ref]])
+
+(def font-family-keys (schema-keys schema:font-family))
+
+(def ^:private schema:text-case
+  [:map
+   [:text-case {:optional true} token-name-ref]])
+
+(def text-case-keys (schema-keys schema:text-case))
+
+(def ^:private schema:font-weight
+  [:map
+   [:font-weight {:optional true} token-name-ref]])
+
+(def font-weight-keys (schema-keys schema:font-weight))
+
+(def ^:private schema:typography
+  [:map
+   [:typography {:optional true} token-name-ref]])
+
+(def typography-token-keys (schema-keys schema:typography))
+
+(def ^:private schema:text-decoration
+  [:map
+   [:text-decoration {:optional true} token-name-ref]])
+
+(def text-decoration-keys (schema-keys schema:text-decoration))
+
+(def typography-keys (set/union font-size-keys
+                                letter-spacing-keys
+                                font-family-keys
+                                font-weight-keys
+                                text-case-keys
+                                text-decoration-keys
+                                font-weight-keys
+                                typography-token-keys
+                                #{:line-height}))
+
 (def ^:private schema:number
-  (-> (reduce mu/union [schema:line-height
+  (-> (reduce mu/union [[:map [:line-height {:optional true} token-name-ref]]
                        schema:rotation])
      (mu/update-properties assoc :title "NumberTokenAttrs")))

 (def number-keys (schema-keys schema:number))

-(def ^:private schema:opacity
-  [:map {:title "OpacityTokenAttrs"}
-   [:opacity {:optional true} schema:token-name]])
-
-(def opacity-keys (schema-keys schema:opacity))
-
-(def ^:private schema:shadow
-  [:map {:title "ShadowTokenAttrs"}
-   [:shadow {:optional true} schema:token-name]])
-
-(def shadow-keys (schema-keys schema:shadow))
-
-(def ^:private schema:text-case
-  [:map
-   [:text-case {:optional true} schema:token-name]])
-
-(def text-case-keys (schema-keys schema:text-case))
-
-(def ^:private schema:text-decoration
-  [:map
-   [:text-decoration {:optional true} schema:token-name]])
-
-(def text-decoration-keys (schema-keys schema:text-decoration))
-
-(def ^:private schema:typography
-  [:map
-   [:typography {:optional true} schema:token-name]])
-
-(def typography-token-keys (schema-keys schema:typography))
-
-(def typography-keys (set/union font-family-keys
-                                font-size-keys
-                                font-weight-keys
-                                font-weight-keys
-                                letter-spacing-keys
-                                line-height-keys
-                                text-case-keys
-                                text-decoration-keys
-                                typography-token-keys))
-
-(def ^:private schema:axis
-  [:map
-   [:x {:optional true} schema:token-name]
-   [:y {:optional true} schema:token-name]])
-
-(def axis-keys (schema-keys schema:axis))
-
-(def all-keys (set/union axis-keys
+(def all-keys (set/union color-keys
                         border-radius-keys
-                         color-keys
-                         dimensions-keys
-                         number-keys
-                         opacity-keys
-                         rotation-keys
                         shadow-keys
-                         sizing-keys
-                         spacing-keys
                         stroke-width-keys
+                         sizing-keys
+                         opacity-keys
+                         spacing-keys
+                         dimensions-keys
+                         axis-keys
+                         rotation-keys
                         typography-keys
-                         typography-token-keys))
+                         typography-token-keys
+                         number-keys))

 (def ^:private schema:tokens
  [:map {:title "GenericTokenAttrs"}])
@@ -383,28 +321,11 @@
   schema:text-decoration
   schema:dimensions])

-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; HELPERS for conversion between token attrs and shape attrs
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
 (defn token-attr?
  [attr]
  (contains? all-keys attr))

-(defn token-attr->shape-attr
-  "Returns the actual shape attribute affected when a token have been applied
-   to a given `token-attr`."
-  [token-attr]
-  (case token-attr
-    :fill :fills
-    :stroke-color :strokes
-    :stroke-width :strokes
-    token-attr))
-
 (defn shape-attr->token-attrs
-  "Returns the token-attr affected when a given attribute in a shape is changed.
-   The sub-attr is for attributes that may have multiple values, like strokes
-   (may be width or color) and layout padding & margin (may have 4 edges)."
  ([shape-attr] (shape-attr->token-attrs shape-attr nil))
  ([shape-attr changed-sub-attr]
   (cond
@@ -446,13 +367,21 @@
     (number-keys shape-attr) #{shape-attr}
     (axis-keys shape-attr) #{shape-attr})))

+(defn token-attr->shape-attr
+  [token-attr]
+  (case token-attr
+    :fill :fills
+    :stroke-color :strokes
+    :stroke-width :strokes
+    token-attr))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; HELPERS for token attributes by shape type
+;; TOKEN SHAPE ATTRIBUTES
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

-(def ^:private position-attributes #{:x :y})
+(def position-attributes #{:x :y})

-(def ^:private generic-attributes
+(def generic-attributes
  (set/union color-keys
             stroke-width-keys
             rotation-keys
@@ -461,22 +390,20 @@
             shadow-keys
             position-attributes))

-(def ^:private rect-attributes
+(def rect-attributes
  (set/union generic-attributes
             border-radius-keys))

-(def ^:private frame-with-layout-attributes
+(def frame-with-layout-attributes
  (set/union rect-attributes
             spacing-gap-padding-keys))

-(def ^:private text-attributes
+(def text-attributes
  (set/union generic-attributes
             typography-keys
             number-keys))

 (defn shape-type->attributes
-  "Returns what token attributes may be applied to a shape depending on its type
-   and if it is a frame with a layout."
  [type is-layout]
  (case type
    :bool    generic-attributes
@@ -492,14 +419,12 @@
    nil))

 (defn appliable-attrs-for-shape
-  "Returns which ones of the given `attributes` can be applied to a shape
-   of type `shape-type` and `is-layout`."
+  "Returns intersection of shape `attributes` for `shape-type`."
  [attributes shape-type is-layout]
  (set/intersection attributes (shape-type->attributes shape-type is-layout)))

 (defn any-appliable-attr-for-shape?
-  "Returns if any of the given `attributes` can be applied to a shape
-   of type `shape-type` and `is-layout`."
+  "Checks if `token-type` supports given shape `attributes`."
  [attributes token-type is-layout]
  (d/not-empty? (appliable-attrs-for-shape attributes token-type is-layout)))

@@ -510,6 +435,42 @@
   typography-keys
   #{:fill}))

+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; TOKENS IN SHAPES
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- toggle-or-apply-token
+  "Remove any shape attributes from token if they exists.
+  Othewise apply token attributes."
+  [shape token]
+  (let [[shape-leftover token-leftover _matching] (data/diff (:applied-tokens shape) token)]
+    (merge {} shape-leftover token-leftover)))
+
+(defn- token-from-attributes [token attributes]
+  (->> (map (fn [attr] [attr (:name token)]) attributes)
+       (into {})))
+
+(defn- apply-token-to-attributes [{:keys [shape token attributes]}]
+  (let [token (token-from-attributes token attributes)]
+    (toggle-or-apply-token shape token)))
+
+(defn apply-token-to-shape
+  [{:keys [shape token attributes] :as _props}]
+  (let [applied-tokens (apply-token-to-attributes {:shape shape
+                                                   :token token
+                                                   :attributes attributes})]
+    (update shape :applied-tokens #(merge % applied-tokens))))
+
+(defn unapply-token-id [shape attributes]
+  (update shape :applied-tokens d/without-keys attributes))
+
+(defn unapply-layout-item-tokens
+  "Unapplies all layout item related tokens from shape."
+  [shape]
+  (let [layout-item-attrs (set/union sizing-layout-item-keys
+                                     spacing-margin-keys)]
+    (unapply-token-id shape layout-item-attrs)))
+
 (def tokens-by-input
  "A map from input name to applicable token for that input."
  {:width #{:sizing :dimensions}
@@ -539,33 +500,7 @@
   :stroke-color #{:color}})

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; HELPERS for tokens application
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defn- generate-attr-map [token attributes]
-  (->> (map (fn [attr] [attr (:name token)]) attributes)
-       (into {})))
-
-(defn apply-token-to-shape
-  "Applies the token to the given attributes in the shape."
-  [{:keys [shape token attributes] :as _props}]
-  (let [map-to-apply (generate-attr-map token attributes)]
-    (update shape :applied-tokens #(merge % map-to-apply))))
-
-(defn unapply-tokens-from-shape
-  "Removes any token applied to the given attributes in the shape."
-  [shape attributes]
-  (update shape :applied-tokens d/without-keys attributes))
-
-(defn unapply-layout-item-tokens
-  "Unapplies all layout item related tokens from shape."
-  [shape]
-  (let [layout-item-attrs (set/union sizing-layout-item-keys
-                                     spacing-margin-keys)]
-    (unapply-tokens-from-shape shape layout-item-attrs)))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; HELPERS for typography tokens
+;; TYPOGRAPHY
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 (defn split-font-family
@@ -628,3 +563,32 @@
    (when (font-weight-values weight)
      (cond-> {:weight weight}
        italic? (assoc :style "italic")))))
+
+(defn typography-composite-token-reference?
+  "Predicate if a typography composite token is a reference value - a string pointing to another reference token."
+  [token-value]
+  (string? token-value))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; SHADOW
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn shadow-composite-token-reference?
+  "Predicate if a shadow composite token is a reference value - a string pointing to another reference token."
+  [token-value]
+  (string? token-value))
+
+(defn update-token-value-references
+  "Recursively update token references within a token value, supporting complex token values (maps, sequences, strings)."
+  [value old-name new-name]
+  (cond
+    (string? value)
+    (str/replace value
+                 (re-pattern (str "\\{" (str/replace old-name "." "\\.") "\\}"))
+                 (str "{" new-name "}"))
+    (map? value)
+    (d/update-vals value #(update-token-value-references % old-name new-name))
+    (sequential? value)
+    (mapv #(update-token-value-references % old-name new-name) value)
+    :else
+    value))
--- a/common/src/app/common/types/tokens_lib.cljc
+++ b/common/src/app/common/types/tokens_lib.cljc
@@ -114,19 +114,25 @@
  [o]
  (instance? Token o))

+(def schema:token-attrs
+  [:map {:title "Token"}
+   [:id ::sm/uuid]
+   [:name cto/token-name-ref]
+   [:type [::sm/one-of cto/token-types]]
+   [:value ::sm/any]
+   [:description {:optional true} :string]
+   [:modified-at {:optional true} ::ct/inst]])
+
 (declare make-token)

 (def schema:token
-  [:and {:gen/gen (->> (sg/generator cto/schema:token-attrs)
+  [:and {:gen/gen (->> (sg/generator schema:token-attrs)
                       (sg/fmap #(make-token %)))}
-   (sm/required-keys cto/schema:token-attrs)
+   (sm/required-keys schema:token-attrs)
   [:fn token?]])

 (def ^:private check-token-attrs
-  (sm/check-fn cto/schema:token-attrs :hint "expected valid params for token"))
-
-(def decode-token-attrs
-  (sm/lazy-decoder cto/schema:token-attrs sm/json-transformer))
+  (sm/check-fn schema:token-attrs :hint "expected valid params for token"))

 (def check-token
  (sm/check-fn schema:token :hint "expected valid token"))
@@ -311,18 +317,10 @@
  [o]
  (instance? TokenSetLegacy o))

-(declare make-token-set)
-(declare normalized-set-name?)
-
-(def schema:token-set-name
-  [:and
-   :string
-   [:fn #(normalized-set-name? %)]]) ;; The #() is necessary because the function is only declared, not defined
-
 (def schema:token-set-attrs
  [:map {:title "TokenSet"}
   [:id ::sm/uuid]
-   [:name schema:token-set-name]
+   [:name :string]
   [:description {:optional true} :string]
   [:modified-at {:optional true} ::ct/inst]
   [:tokens {:optional true
@@ -344,6 +342,8 @@
      :string schema:token]
     [:fn d/ordered-map?]]]])

+(declare make-token-set)
+
 (def schema:token-set
  [:schema {:gen/gen (->> (sg/generator schema:token-set-attrs)
                          (sg/fmap #(make-token-set %)))}
@@ -404,25 +404,12 @@
               (split-set-name name))
       (cpn/join-path :separator set-separator :with-spaces? false))))

-(defn normalized-set-name?
-  "Check if a set name is normalized (no extra spaces)."
-  [name]
-  (= name (normalize-set-name name)))
-
 (defn replace-last-path-name
  "Replaces the last element in a `path` vector with `name`."
  [path name]
  (-> (into [] (drop-last path))
      (conj name)))

-(defn make-child-name
-  "Generate the name of a set child of `parent-set` adding the name `name`."
-  [parent-set name]
-  (if-let [parent-path (get-set-path parent-set)]
-    (->> (concat parent-path (split-set-name name))
-         (join-set-path))
-    (normalize-set-name name)))
-
 ;; The following functions will be removed after refactoring the internal structure of TokensLib,
 ;; since we'll no longer need group prefixes to differentiate between sets and set-groups.

@@ -1383,13 +1370,10 @@ Will return a value that matches this schema:
 (def ^:private check-tokens-lib-map
  (sm/check-fn schema:tokens-lib-map :hint "invalid tokens-lib internal data structure"))

-(defn tokens-lib?
-  [o]
-  (instance? TokensLib o))
-
 (defn valid-tokens-lib?
  [o]
-  (and (tokens-lib? o) (valid? o)))
+  (and (instance? TokensLib o)
+       (valid? o)))

 (defn- ensure-hidden-theme
  "A helper that is responsible to ensure that the hidden theme always
@@ -1451,50 +1435,6 @@ Will return a value that matches this schema:
          (rename copy-name)
          (reid (uuid/next))))))

-(defn- token-name->path-selector
-  "Splits token-name into map with `:path` and `:selector` using `token-name->path`.
-
-  `:selector` is the last item of the names path
-  `:path` is everything leading up the the `:selector`."
-  [token-name]
-  (let [path-segments (get-token-path {:name token-name})
-        last-idx (dec (count path-segments))
-        [path [selector]] (split-at last-idx path-segments)]
-    {:path (seq path)
-     :selector selector}))
-
-(defn token-name-path-exists?
-  "Traverses the path from `token-name` down a `tokens-tree` and checks if a token at that path exists.
-
-  It's not allowed to create a token inside a token. E.g.:
-  Creating a token with
-
-    {:name \"foo.bar\"}
-
-  in the tokens tree:
-
-    {\"foo\" {:name \"other\"}}"
-  [token-name tokens-tree]
-  (let [{:keys [path selector]} (token-name->path-selector token-name)
-        path-target (reduce
-                     (fn [acc cur]
-                       (let [target (get acc cur)]
-                         (cond
-                           ;; Path segment doesn't exist yet
-                           (nil? target) (reduced false)
-                           ;; A token exists at this path
-                           (:name target) (reduced true)
-                           ;; Continue traversing the true
-                           :else target)))
-                     tokens-tree
-                     path)]
-    (cond
-      (boolean? path-target) path-target
-      (get path-target :name) true
-      :else (-> (get path-target selector)
-                (seq)
-                (boolean)))))
-
 ;; === Import / Export from JSON format

 ;; Supported formats:
--- a/common/test/common_tests/files/tokens_test.cljc
+++ b/common/test/common_tests/files/tokens_test.cljc
@@ -6,34 +6,34 @@

 (ns common-tests.files.tokens-test
  (:require
-   [app.common.files.tokens :as cfo]
+   [app.common.files.tokens :as cft]
   [clojure.test :as t]))

 (t/deftest test-parse-token-value
  (t/testing "parses double from a token value"
-    (t/is (= {:value 100.1 :unit nil} (cfo/parse-token-value "100.1")))
-    (t/is (= {:value -9.0 :unit nil} (cfo/parse-token-value "-9"))))
+    (t/is (= {:value 100.1 :unit nil} (cft/parse-token-value "100.1")))
+    (t/is (= {:value -9.0 :unit nil} (cft/parse-token-value "-9"))))
  (t/testing "trims white-space"
-    (t/is (= {:value -1.3 :unit nil} (cfo/parse-token-value "     -1.3   "))))
+    (t/is (= {:value -1.3 :unit nil} (cft/parse-token-value "     -1.3   "))))
  (t/testing "parses unit: px"
-    (t/is (= {:value 70.3 :unit "px"} (cfo/parse-token-value "     70.3px   "))))
+    (t/is (= {:value 70.3 :unit "px"} (cft/parse-token-value "     70.3px   "))))
  (t/testing "parses unit: %"
-    (t/is (= {:value -10.0 :unit "%"} (cfo/parse-token-value "-10%"))))
+    (t/is (= {:value -10.0 :unit "%"} (cft/parse-token-value "-10%"))))
  (t/testing "parses unit: px")
  (t/testing "returns nil for any invalid characters"
-    (t/is (nil? (cfo/parse-token-value "     -1.3a   "))))
+    (t/is (nil? (cft/parse-token-value "     -1.3a   "))))
  (t/testing "doesnt accept invalid double"
-    (t/is (nil? (cfo/parse-token-value ".3")))))
+    (t/is (nil? (cft/parse-token-value ".3")))))

 (t/deftest token-applied-test
  (t/testing "matches passed token with `:token-attributes`"
-    (t/is (true? (cfo/token-applied? {:name "a"} {:applied-tokens {:x "a"}} #{:x}))))
+    (t/is (true? (cft/token-applied? {:name "a"} {:applied-tokens {:x "a"}} #{:x}))))
  (t/testing "doesn't match empty token"
-    (t/is (nil? (cfo/token-applied? {} {:applied-tokens {:x "a"}} #{:x}))))
+    (t/is (nil? (cft/token-applied? {} {:applied-tokens {:x "a"}} #{:x}))))
  (t/testing "does't match passed token `:id`"
-    (t/is (nil? (cfo/token-applied? {:name "b"} {:applied-tokens {:x "a"}} #{:x}))))
+    (t/is (nil? (cft/token-applied? {:name "b"} {:applied-tokens {:x "a"}} #{:x}))))
  (t/testing "doesn't match passed `:token-attributes`"
-    (t/is (nil? (cfo/token-applied? {:name "a"} {:applied-tokens {:x "a"}} #{:y})))))
+    (t/is (nil? (cft/token-applied? {:name "a"} {:applied-tokens {:x "a"}} #{:y})))))

 (t/deftest shapes-ids-by-applied-attributes
  (t/testing "Returns set of matched attributes that fit the applied token"
@@ -54,7 +54,7 @@
                  shape-applied-x-y
                  shape-applied-all
                  shape-applied-none]
-          expected (cfo/shapes-ids-by-applied-attributes {:name "1"} shapes attributes)]
+          expected (cft/shapes-ids-by-applied-attributes {:name "1"} shapes attributes)]
      (t/is (= (:x expected) (shape-ids shape-applied-x
                                        shape-applied-x-y
                                        shape-applied-all)))
@@ -62,21 +62,34 @@
                                        shape-applied-x-y
                                        shape-applied-all)))
      (t/is (= (:z expected) (shape-ids shape-applied-all)))
-      (t/is (true? (cfo/shapes-applied-all? expected (shape-ids shape-applied-all) attributes)))
-      (t/is (false? (cfo/shapes-applied-all? expected (apply shape-ids shapes) attributes)))
+      (t/is (true? (cft/shapes-applied-all? expected (shape-ids shape-applied-all) attributes)))
+      (t/is (false? (cft/shapes-applied-all? expected (apply shape-ids shapes) attributes)))
      (shape-ids shape-applied-x
                 shape-applied-x-y
                 shape-applied-all))))

 (t/deftest tokens-applied-test
  (t/testing "is true when single shape matches the token and attributes"
-    (t/is (true? (cfo/shapes-token-applied? {:name "a"} [{:applied-tokens {:x "a"}}
+    (t/is (true? (cft/shapes-token-applied? {:name "a"} [{:applied-tokens {:x "a"}}
                                                         {:applied-tokens {:x "b"}}]
                                            #{:x}))))
  (t/testing "is false when no shape matches the token or attributes"
-    (t/is (nil? (cfo/shapes-token-applied? {:name "a"} [{:applied-tokens {:x "b"}}
+    (t/is (nil? (cft/shapes-token-applied? {:name "a"} [{:applied-tokens {:x "b"}}
                                                        {:applied-tokens {:x "b"}}]
                                           #{:x})))
-    (t/is (nil? (cfo/shapes-token-applied? {:name "a"} [{:applied-tokens {:x "a"}}
+    (t/is (nil? (cft/shapes-token-applied? {:name "a"} [{:applied-tokens {:x "a"}}
                                                        {:applied-tokens {:x "a"}}]
                                           #{:y})))))
+
+(t/deftest name->path-test
+  (t/is (= ["foo" "bar" "baz"] (cft/token-name->path "foo.bar.baz")))
+  (t/is (= ["foo" "bar" "baz"] (cft/token-name->path "foo..bar.baz")))
+  (t/is (= ["foo" "bar" "baz"] (cft/token-name->path "foo..bar.baz...."))))
+
+(t/deftest token-name-path-exists?-test
+  (t/is (true? (cft/token-name-path-exists? "border-radius" {"border-radius" {"sm" {:name "sm"}}})))
+  (t/is (true? (cft/token-name-path-exists? "border-radius" {"border-radius" {:name "sm"}})))
+  (t/is (true? (cft/token-name-path-exists? "border-radius.sm" {"border-radius" {:name "sm"}})))
+  (t/is (true? (cft/token-name-path-exists? "border-radius.sm.x" {"border-radius" {:name "sm"}})))
+  (t/is (false? (cft/token-name-path-exists? "other" {"border-radius" {:name "sm"}})))
+  (t/is (false? (cft/token-name-path-exists? "dark.border-radius.md" {"dark" {"border-radius" {"sm" {:name "sm"}}}}))))
--- a/common/test/common_tests/logic/token_apply_test.cljc
+++ b/common/test/common_tests/logic/token_apply_test.cljc
@@ -255,28 +255,28 @@
                    (cls/generate-update-shapes [(:id frame1)]
                                                (fn [shape]
                                                  (-> shape
-                                                      (cto/unapply-tokens-from-shape [:r1 :r2 :r3 :r4])
-                                                      (cto/unapply-tokens-from-shape [:rotation])
-                                                      (cto/unapply-tokens-from-shape [:opacity])
-                                                      (cto/unapply-tokens-from-shape [:stroke-width])
-                                                      (cto/unapply-tokens-from-shape [:stroke-color])
-                                                      (cto/unapply-tokens-from-shape [:fill])
-                                                      (cto/unapply-tokens-from-shape [:width :height])))
+                                                      (cto/unapply-token-id [:r1 :r2 :r3 :r4])
+                                                      (cto/unapply-token-id [:rotation])
+                                                      (cto/unapply-token-id [:opacity])
+                                                      (cto/unapply-token-id [:stroke-width])
+                                                      (cto/unapply-token-id [:stroke-color])
+                                                      (cto/unapply-token-id [:fill])
+                                                      (cto/unapply-token-id [:width :height])))
                                                (:objects page)
                                                {})
                    (cls/generate-update-shapes [(:id text1)]
                                                (fn [shape]
                                                  (-> shape
-                                                      (cto/unapply-tokens-from-shape [:font-size])
-                                                      (cto/unapply-tokens-from-shape [:letter-spacing])
-                                                      (cto/unapply-tokens-from-shape [:font-family])))
+                                                      (cto/unapply-token-id [:font-size])
+                                                      (cto/unapply-token-id [:letter-spacing])
+                                                      (cto/unapply-token-id [:font-family])))
                                                (:objects page)
                                                {})
                    (cls/generate-update-shapes [(:id circle1)]
                                                (fn [shape]
                                                  (-> shape
-                                                      (cto/unapply-tokens-from-shape [:layout-item-max-h :layout-item-min-h :layout-item-max-w :layout-item-min-w])
-                                                      (cto/unapply-tokens-from-shape [:m1 :m2 :m3 :m4])))
+                                                      (cto/unapply-token-id [:layout-item-max-h :layout-item-min-h :layout-item-max-w :layout-item-min-w])
+                                                      (cto/unapply-token-id [:m1 :m2 :m3 :m4])))
                                                (:objects page)
                                                {}))

--- a/common/test/common_tests/types/token_test.cljc
+++ b/common/test/common_tests/types/token_test.cljc
@@ -8,19 +8,20 @@
  (:require
   [app.common.schema :as sm]
   [app.common.types.token :as cto]
+   [app.common.uuid :as uuid]
   [clojure.test :as t]))

 (t/deftest test-valid-token-name-schema
  ;; Allow regular namespace token names
-  (t/is (true? (sm/validate cto/schema:token-name "Foo")))
-  (t/is (true? (sm/validate cto/schema:token-name "foo")))
-  (t/is (true? (sm/validate cto/schema:token-name "FOO")))
-  (t/is (true? (sm/validate cto/schema:token-name "Foo.Bar.Baz")))
+  (t/is (true? (sm/validate cto/token-name-ref "Foo")))
+  (t/is (true? (sm/validate cto/token-name-ref "foo")))
+  (t/is (true? (sm/validate cto/token-name-ref "FOO")))
+  (t/is (true? (sm/validate cto/token-name-ref "Foo.Bar.Baz")))
  ;; Disallow trailing tokens
-  (t/is (false? (sm/validate cto/schema:token-name "Foo.Bar.Baz....")))
+  (t/is (false? (sm/validate cto/token-name-ref "Foo.Bar.Baz....")))
  ;; Disallow multiple separator dots
-  (t/is (false? (sm/validate cto/schema:token-name "Foo..Bar.Baz")))
+  (t/is (false? (sm/validate cto/token-name-ref "Foo..Bar.Baz")))
  ;; Disallow any special characters
-  (t/is (false? (sm/validate cto/schema:token-name "Hey Foo.Bar")))
-  (t/is (false? (sm/validate cto/schema:token-name "Hey😈Foo.Bar")))
-  (t/is (false? (sm/validate cto/schema:token-name "Hey%Foo.Bar"))))
+  (t/is (false? (sm/validate cto/token-name-ref "Hey Foo.Bar")))
+  (t/is (false? (sm/validate cto/token-name-ref "Hey😈Foo.Bar")))
+  (t/is (false? (sm/validate cto/token-name-ref "Hey%Foo.Bar"))))
--- a/common/test/common_tests/types/tokens_lib_test.cljc
+++ b/common/test/common_tests/types/tokens_lib_test.cljc
@@ -678,35 +678,35 @@

 (t/deftest list-active-themes-tokens-bug-taiga-10617
  (let [tokens-lib (-> (ctob/make-tokens-lib)
-                       (ctob/add-set (ctob/make-token-set :name "Mode/Dark"
+                       (ctob/add-set (ctob/make-token-set :name "Mode / Dark"
                                                          :tokens {"red"
                                                                   (ctob/make-token :name "red"
                                                                                    :type :color
                                                                                    :value "#700000")}))
-                       (ctob/add-set (ctob/make-token-set :name "Mode/Light"
+                       (ctob/add-set (ctob/make-token-set :name "Mode / Light"
                                                          :tokens {"red"
                                                                   (ctob/make-token :name "red"
                                                                                    :type :color
                                                                                    :value "#ff0000")}))
-                       (ctob/add-set (ctob/make-token-set :name "Device/Desktop"
+                       (ctob/add-set (ctob/make-token-set :name "Device / Desktop"
                                                          :tokens {"border1"
                                                                   (ctob/make-token :name "border1"
                                                                                    :type :border-radius
                                                                                    :value 30)}))
-                       (ctob/add-set (ctob/make-token-set :name "Device/Mobile"
+                       (ctob/add-set (ctob/make-token-set :name "Device / Mobile"
                                                          :tokens {"border1"
                                                                   (ctob/make-token :name "border1"
                                                                                    :type :border-radius
                                                                                    :value 50)}))
                       (ctob/add-theme (ctob/make-token-theme :group "App"
                                                              :name "Mobile"
-                                                              :sets #{"Mode/Dark" "Device/Mobile"}))
+                                                              :sets #{"Mode / Dark" "Device / Mobile"}))
                       (ctob/add-theme (ctob/make-token-theme :group "App"
                                                              :name "Web"
-                                                              :sets #{"Mode/Dark" "Mode/Light" "Device/Desktop"}))
+                                                              :sets #{"Mode / Dark" "Mode / Light" "Device / Desktop"}))
                       (ctob/add-theme (ctob/make-token-theme :group "Brand"
                                                              :name "Brand A"
-                                                              :sets #{"Mode/Dark" "Mode/Light" "Device/Desktop" "Device/Mobile"}))
+                                                              :sets #{"Mode / Dark" "Mode / Light" "Device / Desktop" "Device / Mobile"}))
                       (ctob/add-theme (ctob/make-token-theme :group "Brand"
                                                              :name "Brand B"
                                                              :sets #{}))
@@ -2013,11 +2013,3 @@
           (t/is (some? imported-ref))
           (t/is (= (:type original-ref) (:type imported-ref)))
           (t/is (= (:value imported-ref) (:value original-ref))))))))
-
-(t/deftest token-name-path-exists?-test
-  (t/is (true? (ctob/token-name-path-exists? "border-radius" {"border-radius" {"sm" {:name "sm"}}})))
-  (t/is (true? (ctob/token-name-path-exists? "border-radius" {"border-radius" {:name "sm"}})))
-  (t/is (true? (ctob/token-name-path-exists? "border-radius.sm" {"border-radius" {:name "sm"}})))
-  (t/is (true? (ctob/token-name-path-exists? "border-radius.sm.x" {"border-radius" {:name "sm"}})))
-  (t/is (false? (ctob/token-name-path-exists? "other" {"border-radius" {:name "sm"}})))
-  (t/is (false? (ctob/token-name-path-exists? "dark.border-radius.md" {"dark" {"border-radius" {"sm" {:name "sm"}}}}))))
--- a/docker/devenv/docker-compose.yaml
+++ b/docker/devenv/docker-compose.yaml
@@ -51,11 +51,6 @@ services:
      - 4401:4401
      - 4402:4402

-      # Plugins
-      - 4200:4200
-      - 4201:4201
-      - 4202:4202
-
    environment:
      - EXTERNAL_UID=${CURRENT_USER_ID}
      # SMTP setup
--- a/docker/devenv/files/nginx.conf
+++ b/docker/devenv/files/nginx.conf
@@ -121,7 +121,7 @@ http {
            proxy_http_version 1.1;
        }

-        location /plugins/mcp {
+        location /mcp {
            alias /home/penpot/penpot/mcp/packages/plugin/dist;
            proxy_http_version 1.1;
        }
@@ -133,11 +133,6 @@ http {
            proxy_http_version 1.1;
        }

-        location /management {
-            proxy_pass http://127.0.0.1:6060/management;
-            proxy_http_version 1.1;
-        }
-
        location /mcp/stream {
            proxy_pass http://127.0.0.1:4401/mcp;
            proxy_http_version 1.1;
--- a/docker/imagemagick/Dockerfile
+++ b/docker/imagemagick/Dockerfile
@@ -24,7 +24,6 @@ RUN set -e; \
        libltdl-dev \
        liblzma-dev \
        libopenexr-dev \
-        libxml2-dev \
        libpng-dev \
        librsvg2-dev \
        libtiff-dev \
@@ -53,7 +52,6 @@ RUN set -e; \
        libfftw3-dev \
        libheif-dev \
        libjpeg-dev \
-        libxml2-dev \
        liblcms2-dev \
        libltdl-dev \
        liblzma-dev \
@@ -79,7 +77,6 @@ RUN set -e; \
        libopenjp2-7 \
        libpng16-16 \
        librsvg2-2 \
-        libxml2 \
        libtiff6 \
        libwebp7 \
        libwebpdemux2 \
--- a/docker/images/Dockerfile.backend
+++ b/docker/images/Dockerfile.backend
@@ -125,7 +125,7 @@ RUN set -ex; \

 COPY --from=build /opt/jre /opt/jre
 COPY --from=build /opt/node /opt/node
-COPY --from=penpotapp/imagemagick:7.1.2-13 /opt/imagick /opt/imagick
+COPY --from=penpotapp/imagemagick:7.1.2-0 /opt/imagick /opt/imagick

 ARG BUNDLE_PATH="./bundle-backend/"
 COPY --chown=penpot:penpot $BUNDLE_PATH /opt/penpot/backend/
--- a/docker/images/Dockerfile.exporter
+++ b/docker/images/Dockerfile.exporter
@@ -107,7 +107,7 @@ RUN set -eux; \

 ARG BUNDLE_PATH="./bundle-exporter/"
 COPY --chown=penpot:penpot $BUNDLE_PATH /opt/penpot/exporter/
-COPY --from=penpotapp/imagemagick:7.1.2-13 /opt/imagick /opt/imagick
+COPY --from=penpotapp/imagemagick:7.1.2-0 /opt/imagick /opt/imagick

 WORKDIR /opt/penpot/exporter
 USER penpot:penpot
--- a/docker/images/files/nginx.conf.template
+++ b/docker/images/files/nginx.conf.template
@@ -130,11 +130,6 @@ http {
            proxy_buffering off;
        }

-        location /plugins {
-            alias /var/www/app/plugins;
-            proxy_http_version 1.1;
-        }
-
        location /readyz {
            access_log off;
            proxy_pass $PENPOT_BACKEND_URI$request_uri;
--- a/exporter/src/app/renderer/pdf.cljs
+++ b/exporter/src/app/renderer/pdf.cljs
@@ -38,24 +38,6 @@
                  (assoc :path "/render.html")
                  (assoc :query (u/map->query-string params)))))

-          (sync-page-size! [dom]
-            (bw/eval! dom
-                      (fn [elem]
-                        ;; IMPORTANT: No CLJS runtime allowed. Use only JS
-                        ;; primitives.  This runs in a context without access to
-                        ;; cljs.core. Avoid any functions that transpile to
-                        ;; cljs.core/* calls, as they will break in the browser
-                        ;; runtime.
-
-                        (let [width (.getAttribute ^js elem "width")
-                              height (.getAttribute ^js elem "height")
-                              style-node (let [node (.createElement js/document "style")]
-                                           (.appendChild (.-head js/document) node)
-                                           node)]
-                          (set! (.-textContent style-node)
-                                (dm/str "@page { size: " width "px " height "px; margin: 0; }\n"
-                                        "html, body, #app { margin: 0; padding: 0; width: " width "px; height: " height "px; overflow: visible; }"))))))
-
          (render-object [page base-uri {:keys [id] :as object}]
            (p/let [uri  (prepare-uri base-uri id)
                    path (sh/tempfile :prefix "penpot.tmp.pdf." :suffix (mime/get-extension type))]
@@ -63,7 +45,6 @@
              (bw/nav! page uri)
              (p/let [dom (bw/select page (dm/str "#screenshot-" id))]
                (bw/wait-for dom)
-                (sync-page-size! dom)
                (bw/screenshot dom {:full-page? true})
                (bw/sleep page 2000) ; the good old fix with sleep
                (bw/pdf page {:path path})
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -4,7 +4,7 @@
  "license": "MPL-2.0",
  "author": "Kaleidos INC",
  "private": true,
-  "packageManager": "pnpm@10.29.2+sha512.bef43fa759d91fd2da4b319a5a0d13ef7a45bb985a3d7342058470f9d2051a3ba8674e629672654686ef9443ad13a82da2beb9eeb3e0221c87b8154fff9d74b8",
+  "packageManager": "pnpm@10.28.2+sha512.41872f037ad22f7348e3b1debbaf7e867cfd448f2726d9cf74c08f19507c31d2c8e7a11525b983febc2df640b5438dee6023ebb1f84ed43cc2d654d2bc326264",
  "browserslist": [
    "defaults"
  ],
@@ -47,11 +47,10 @@
  "devDependencies": {
    "@penpot/draft-js": "workspace:./packages/draft-js",
    "@penpot/mousetrap": "workspace:./packages/mousetrap",
+    "@penpot/tokenscript": "workspace:./packages/tokenscript",
    "@penpot/plugins-runtime": "1.4.2",
    "@penpot/svgo": "penpot/svgo#v3.2",
    "@penpot/text-editor": "workspace:./text-editor",
-    "@penpot/tokenscript": "workspace:./packages/tokenscript",
-    "@penpot/ui": "workspace:./packages/ui",
    "@playwright/test": "1.58.0",
    "@storybook/addon-docs": "10.1.11",
    "@storybook/addon-themes": "10.1.11",
@@ -103,7 +102,6 @@
    "sass": "^1.89.0",
    "sass-embedded": "^1.89.0",
    "sax": "^1.4.1",
-    "scheduler": "^0.27.0",
    "source-map-support": "^0.5.21",
    "storybook": "10.1.11",
    "style-dictionary": "5.0.0-rc.1",
--- a/frontend/packages/ui/.babelrc
+++ b/frontend/packages/ui/.babelrc
@@ -1,4 +0,0 @@
-{
-  "presets": [],
-  "plugins": []
-}
--- a/frontend/packages/ui/.gitignore
+++ b/frontend/packages/ui/.gitignore
@@ -1 +0,0 @@
-dist/
--- a/frontend/packages/ui/.storybook/main.ts
+++ b/frontend/packages/ui/.storybook/main.ts
@@ -1,23 +0,0 @@
-import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
-
-import type { StorybookConfig } from '@storybook/react-vite';
-
-const config: StorybookConfig = {
-  stories: ['../src/lib/**/*.@(mdx|stories.@(js|jsx|ts|tsx))'],
-  addons: [],
-  framework: {
-    name: getAbsolutePath('@storybook/react-vite'),
-    options: {
-      builder: {
-        viteConfigPath: 'vite.config.mts',
-      },
-    },
-  },
-};
-
-function getAbsolutePath(value: string): any {
-  return dirname(fileURLToPath(import.meta.resolve(`${value}/package.json`)));
-}
-
-export default config;
--- a/frontend/packages/ui/.storybook/preview.ts
+++ b/frontend/packages/ui/.storybook/preview.ts
--- a/frontend/packages/ui/README.md
+++ b/frontend/packages/ui/README.md
@@ -1,11 +0,0 @@
-# UI
-
-A React component library with TypeScript for the Penpot ecosystem.
-
-## Commands
-
-Run from workspace root:
-
- **`pnpm storybook:ui`** - Start Storybook for component development
- **`pnpm build:ui`** - Build the library for production
- **`pnpm start:ui`** - Build in watch mode for development
--- a/frontend/packages/ui/package.json
+++ b/frontend/packages/ui/package.json
@@ -1,39 +0,0 @@
-{
-  "name": "@penpot/ui",
-  "version": "0.0.1",
-  "types": "./dist/index.d.ts",
-  "type": "module",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js"
-    },
-    "./style.css": "./dist/style.css"
-  },
-  "scripts": {
-    "watch": "vite build --watch",
-    "build": "vite build"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.14.5",
-    "@babel/preset-react": "^7.14.5",
-    "@storybook/react": "10.2.0",
-    "@storybook/react-vite": "10.2.0",
-    "@testing-library/dom": "10.4.0",
-    "@testing-library/react": "16.3.0",
-    "@types/react": "^19.0.0",
-    "@types/react-dom": "^19.0.0",
-    "@vitejs/plugin-react": "^4.2.0",
-    "babel-plugin-react-compiler": "^1.0.0",
-    "eslint-plugin-import": "2.31.0",
-    "eslint-plugin-jsx-a11y": "6.10.1",
-    "eslint-plugin-react": "7.35.0",
-    "eslint-plugin-react-hooks": "7.0.1",
-    "react-compiler-runtime": "^1.0.0",
-    "storybook": "10.2.0",
-    "vite-plugin-dts": "^4.5.4"
-  },
-  "peerDependencies": {
-    "react": ">=19.2",
-    "react-dom": ">=19.2"
-  }
-}
--- a/frontend/packages/ui/src/index.ts
+++ b/frontend/packages/ui/src/index.ts
@@ -1 +0,0 @@
-export * from './lib/example/Example';
--- a/frontend/packages/ui/src/lib/example/Example.module.css
+++ b/frontend/packages/ui/src/lib/example/Example.module.css
@@ -1,5 +0,0 @@
-.container {
-  background-color: #f0f0f0;
-  padding: 16px;
-  border: 2px solid #000;
-}
--- a/frontend/packages/ui/src/lib/example/Example.spec.tsx
+++ b/frontend/packages/ui/src/lib/example/Example.spec.tsx
@@ -1,10 +0,0 @@
-import { render } from '@testing-library/react';
-
-import Example from './Example';
-
-describe('Example', () => {
-  it('should render successfully', () => {
-    const { baseElement } = render(<Example />);
-    expect(baseElement).toBeTruthy();
-  });
-});
--- a/frontend/packages/ui/src/lib/example/Example.stories.ts
+++ b/frontend/packages/ui/src/lib/example/Example.stories.ts
@@ -1,12 +0,0 @@
-import { Example } from './Example';
-import type { Meta, StoryObj } from '@storybook/react-vite';
-
-const meta = {
-  title: 'UI/Example',
-  component: Example,
-} satisfies Meta<typeof Example>;
-
-export default meta;
-type Story = StoryObj<typeof meta>;
-
-export const Primary: Story = {};
--- a/frontend/packages/ui/src/lib/example/Example.tsx
+++ b/frontend/packages/ui/src/lib/example/Example.tsx
@@ -1,21 +0,0 @@
-import { useState } from 'react';
-import styles from './Example.module.css';
-
-export function Example() {
-  const [count, setCount] = useState(0);
-
-  return (
-    <div className={styles.container}>
-      <h1>Example!</h1>
-      <div>
-        <h2>Counter: {count}</h2>
-        <button onClick={() => setCount(count + 1)}>Increment</button>
-        <button onClick={() => setCount(count - 1)}>Decrement</button>
-        <button onClick={() => setCount(0)}>Reset</button>
-      </div>
-    </div>
-
-  );
-}
-
-export default Example;
--- a/frontend/packages/ui/tsconfig.json
+++ b/frontend/packages/ui/tsconfig.json
@@ -1,33 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": false,
-    "noEmit": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true,
-    "jsx": "react-jsx",
-    "types": ["vite/client", "vitest"],
-    "baseUrl": "."
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    },
-    {
-      "path": "./tsconfig.storybook.json"
-    }
-  ]
-}
--- a/frontend/packages/ui/tsconfig.lib.json
+++ b/frontend/packages/ui/tsconfig.lib.json
@@ -1,37 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "types": [
-      "node",
-      "vite/client"
-    ]
-  },
-  "exclude": [
-    "**/*.spec.ts",
-    "**/*.test.ts",
-    "**/*.spec.tsx",
-    "**/*.test.tsx",
-    "**/*.spec.js",
-    "**/*.test.js",
-    "**/*.spec.jsx",
-    "**/*.test.jsx",
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx",
-    "**/*.stories.ts",
-    "**/*.stories.js",
-    "**/*.stories.jsx",
-    "**/*.stories.tsx"
-  ],
-  "include": ["src/**/*.js", "src/**/*.jsx", "src/**/*.ts", "src/**/*.tsx"]
-}
--- a/frontend/packages/ui/tsconfig.spec.json
+++ b/frontend/packages/ui/tsconfig.spec.json
@@ -1,28 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "types": [
-      "vitest/globals",
-      "vitest/importMeta",
-      "vite/client",
-      "node",
-      "vitest"
-    ]
-  },
-  "include": [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx",
-    "src/**/*.d.ts"
-  ]
-}
--- a/frontend/packages/ui/tsconfig.storybook.json
+++ b/frontend/packages/ui/tsconfig.storybook.json
@@ -1,28 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "emitDecoratorMetadata": true,
-    "outDir": "",
-    "module": "esnext",
-    "moduleResolution": "bundler"
-  },
-  "exclude": [
-    "src/**/*.spec.ts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.js",
-    "src/**/*.test.js",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.jsx",
-    "src/**/*.test.js"
-  ],
-  "include": [
-    "src/**/*.stories.ts",
-    "src/**/*.stories.js",
-    "src/**/*.stories.jsx",
-    "src/**/*.stories.tsx",
-    "src/**/*.stories.mdx",
-    ".storybook/*.js",
-    ".storybook/*.ts"
-  ]
-}
--- a/frontend/packages/ui/vite.config.mts
+++ b/frontend/packages/ui/vite.config.mts
@@ -1,66 +0,0 @@
-/// <reference types='vitest' />
-import { defineConfig } from 'vite';
-import react from '@vitejs/plugin-react';
-import dts from 'vite-plugin-dts';
-import * as path from 'path';
-import { copyFileSync } from 'node:fs';
-
-const copyCssPlugin = () => ({
-  name: 'copy-css',
-  closeBundle: () => {
-    try {
-      copyFileSync(
-        'dist/index.css',
-        '../../resources/public/css/ui.css',
-      );
-    } catch (e) {
-      console.log('Error copying css file', e);
-    }
-  },
-});
-
-export default defineConfig(() => ({
-  root: import.meta.dirname,
-  plugins: [
-    react({
-      babel: {
-        plugins: ['babel-plugin-react-compiler'],
-      },
-    }),
-    dts({
-      entryRoot: 'src',
-      tsconfigPath: path.join(import.meta.dirname, 'tsconfig.lib.json'),
-      pathsToAliases: false,
-    }),
-    copyCssPlugin(),
-  ],
-  build: {
-    outDir: 'dist/',
-    emptyOutDir: true,
-    reportCompressedSize: true,
-    commonjsOptions: {
-      transformMixedEsModules: true,
-    },
-    lib: {
-      entry: 'src/index.ts',
-      name: 'ui',
-      fileName: 'index',
-      formats: ['es' as const],
-    },
-    rollupOptions: {
-      external: ['react', 'react-dom', 'react/jsx-runtime'],
-    },
-  },
-  test: {
-    name: 'ui',
-    watch: false,
-    globals: true,
-    environment: 'jsdom',
-    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
-    reporters: ['default'],
-    coverage: {
-      reportsDirectory: '../../coverage/libs/ui',
-      provider: 'v8' as const,
-    },
-  },
-}));
--- a/frontend/playwright/data/components/get-file-13267.json
+++ b/frontend/playwright/data/components/get-file-13267.json
@@ -1,146 +0,0 @@
-{
-  "~:features": {
-    "~#set": [
-      "fdata/path-data",
-      "plugins/runtime",
-      "design-tokens/v1",
-      "variants/v1",
-      "layout/grid",
-      "styles/v2",
-      "fdata/objects-map",
-      "render-wasm/v1",
-      "components/v2",
-      "fdata/shape-data-type"
-    ]
-  },
-  "~:team-id": "~u99e49e93-362f-80ef-8007-3450ea52c9a4",
-  "~: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 13267",
-  "~:revn": 3,
-  "~:modified-at": "~m1770302832804",
-  "~:vern": 0,
-  "~:id": "~ue9c84e12-dd29-80fc-8007-86d559dced7f",
-  "~: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",
-      "0005-deprecate-image-type",
-      "0006-fix-old-texts-fills",
-      "0008-fix-library-colors-v4",
-      "0009-clean-library-colors",
-      "0009-add-partial-text-touched-flags",
-      "0010-fix-swap-slots-pointing-non-existent-shapes",
-      "0011-fix-invalid-text-touched-flags",
-      "0012-fix-position-data",
-      "0013-fix-component-path",
-      "0013-clear-invalid-strokes-and-fills",
-      "0014-fix-tokens-lib-duplicate-ids",
-      "0014-clear-components-nil-objects",
-      "0015-fix-text-attrs-blank-strings",
-      "0015-clean-shadow-color",
-      "0016-copy-fills-from-position-data-to-text-node"
-    ]
-  },
-  "~:version": 67,
-  "~:project-id": "~ufc576d2f-8d02-8101-8007-70ec5793bd81",
-  "~:created-at": "~m1770302800755",
-  "~:backend": "legacy-db",
-  "~:data": {
-    "~:pages": [
-      "~ue9c84e12-dd29-80fc-8007-86d559dced80"
-    ],
-    "~:pages-index": {
-      "~ue9c84e12-dd29-80fc-8007-86d559dced80": {
-        "~:objects": {
-          "~#penpot/objects-map/v2": {
-            "~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]],[\"^:\",[\"^ \",\"~:x\",0.01,\"~:y\",0.0]],[\"^:\",[\"^ \",\"~:x\",0.01,\"~:y\",0.01]],[\"^:\",[\"^ \",\"~:x\",0.0,\"~:y\",0.01]]],\"~:r2\",0,\"~:proportion-lock\",false,\"~:transform-inverse\",[\"^3\",[\"^ \",\"~: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,\"^6\",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,\"^H\",0.01,\"~:flip-y\",null,\"~:shapes\",[\"~udc075bef-4a1f-8056-8007-86d562cf43b7\"]]]",
-            "~udc075bef-4a1f-8056-8007-86d55e028ccb": "[\"~#shape\",[\"^ \",\"~:y\",234,\"~:transform\",[\"~#matrix\",[\"^ \",\"~:a\",1.0,\"~:b\",0.0,\"~:c\",0.0,\"~:d\",1.0,\"~:e\",0.0,\"~:f\",0.0]],\"~:rotation\",0,\"~:grow-type\",\"~:fixed\",\"~:hide-in-viewer\",false,\"~:name\",\"Rectangle\",\"~:width\",117,\"~:type\",\"~:rect\",\"~:points\",[[\"~#point\",[\"^ \",\"~:x\",574,\"~:y\",234]],[\"^<\",[\"^ \",\"~:x\",691,\"~:y\",234]],[\"^<\",[\"^ \",\"~:x\",691,\"~:y\",316]],[\"^<\",[\"^ \",\"~:x\",574,\"~:y\",316]]],\"~:r2\",0,\"~:proportion-lock\",false,\"~:transform-inverse\",[\"^2\",[\"^ \",\"~:a\",1.0,\"~:b\",0.0,\"~:c\",0.0,\"~:d\",1.0,\"~:e\",0.0,\"~:f\",0.0]],\"~:r3\",0,\"~:constraints-v\",\"~:scale\",\"~:constraints-h\",\"^B\",\"~:r1\",0,\"~:id\",\"~udc075bef-4a1f-8056-8007-86d55e028ccb\",\"~:parent-id\",\"~udc075bef-4a1f-8056-8007-86d562cf43b7\",\"~:frame-id\",\"~udc075bef-4a1f-8056-8007-86d562cf43b7\",\"~:strokes\",[],\"~:x\",574,\"~:proportion\",1,\"~:r4\",0,\"~:selrect\",[\"~#rect\",[\"^ \",\"~:x\",574,\"~:y\",234,\"^8\",117,\"~:height\",82,\"~:x1\",574,\"~:y1\",234,\"~:x2\",691,\"~:y2\",316]],\"~:fills\",[[\"^ \",\"~:fill-color\",\"#B1B2B5\",\"~:fill-opacity\",1]],\"~:flip-x\",null,\"^M\",82,\"~:flip-y\",null]]",
-            "~udc075bef-4a1f-8056-8007-86d562cf43b7": "[\"~#shape\",[\"^ \",\"~:y\",234,\"~: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,\"~:hide-in-viewer\",true,\"~:name\",\"A Component\",\"~:width\",117,\"~:type\",\"~:frame\",\"~:points\",[[\"~#point\",[\"^ \",\"~:x\",574,\"~:y\",234]],[\"^;\",[\"^ \",\"~:x\",691,\"~:y\",234]],[\"^;\",[\"^ \",\"~:x\",691,\"~:y\",316]],[\"^;\",[\"^ \",\"~:x\",574,\"~:y\",316]]],\"~:r2\",0,\"~:component-root\",true,\"~:show-content\",true,\"~:proportion-lock\",false,\"~:transform-inverse\",[\"^3\",[\"^ \",\"~:a\",1.0,\"~:b\",0.0,\"~:c\",0.0,\"~:d\",1.0,\"~:e\",0.0,\"~:f\",0.0]],\"~:r3\",0,\"~:r1\",0,\"~:id\",\"~udc075bef-4a1f-8056-8007-86d562cf43b7\",\"~:parent-id\",\"~u00000000-0000-0000-0000-000000000000\",\"~:component-id\",\"~udc075bef-4a1f-8056-8007-86d562d06904\",\"~:frame-id\",\"~u00000000-0000-0000-0000-000000000000\",\"~:strokes\",[],\"~:x\",574,\"~:main-instance\",true,\"~:proportion\",1,\"~:r4\",0,\"~:selrect\",[\"~#rect\",[\"^ \",\"~:x\",574,\"~:y\",234,\"^7\",117,\"~:height\",82,\"~:x1\",574,\"~:y1\",234,\"~:x2\",691,\"~:y2\",316]],\"~:fills\",[],\"~:flip-x\",null,\"^M\",82,\"~:component-file\",\"~ue9c84e12-dd29-80fc-8007-86d559dced7f\",\"~:flip-y\",null,\"~:shapes\",[\"~udc075bef-4a1f-8056-8007-86d55e028ccb\"]]]"
-          }
-        },
-        "~:id": "~ue9c84e12-dd29-80fc-8007-86d559dced80",
-        "~:name": "Page 1"
-      }
-    },
-    "~:id": "~ue9c84e12-dd29-80fc-8007-86d559dced7f",
-    "~:options": {
-      "~:components-v2": true,
-      "~:base-font-size": "16px"
-    },
-    "~:components": {
-      "~udc075bef-4a1f-8056-8007-86d562d06904": {
-        "~:id": "~udc075bef-4a1f-8056-8007-86d562d06904",
-        "~:name": "A Component",
-        "~:path": "",
-        "~:modified-at": "~m1770302824566",
-        "~:main-instance-id": "~udc075bef-4a1f-8056-8007-86d562cf43b7",
-        "~:main-instance-page": "~ue9c84e12-dd29-80fc-8007-86d559dced80"
-      }
-    }
-  }
-}
--- a/frontend/playwright/ui/pages/WorkspacePage.js
+++ b/frontend/playwright/ui/pages/WorkspacePage.js
@@ -459,8 +459,8 @@ export class WorkspacePage extends BaseWebSocketPage {
    await this.page.mouse.up();
  }

-  async clickLeafLayer(name, clickOptions = {}, index = 0) {
-    const layer = this.layers.getByText(name).nth(index);
+  async clickLeafLayer(name, clickOptions = {}) {
+    const layer = this.layers.getByText(name).first();
    await layer.waitFor();
    await layer.click(clickOptions);
    await this.page.waitForTimeout(500);
@@ -471,11 +471,10 @@ export class WorkspacePage extends BaseWebSocketPage {
    await this.clickLeafLayer(name, clickOptions);
  }

-  async clickToggableLayer(name, clickOptions = {}, index = 0) {
+  async clickToggableLayer(name, clickOptions = {}) {
    const layer = this.layers
      .getByTestId("layer-row")
-      .filter({ hasText: name })
-      .nth(index);
+      .filter({ hasText: name });
    const button = layer.getByTestId("toggle-content");

    await expect(button).toBeVisible();
--- a/frontend/playwright/ui/specs/components.spec.js
+++ b/frontend/playwright/ui/specs/components.spec.js
@@ -1,33 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { WasmWorkspacePage } from "../pages/WasmWorkspacePage";
-
-test.beforeEach(async ({ page }) => {
-  await WasmWorkspacePage.init(page);
-});
-
-test("BUG 13267 - Component instance is not synced with parent for geometry changes", async ({ page }) => {
-  const workspacePage = new WasmWorkspacePage(page);
-  await workspacePage.setupEmptyFile(page);
-  await workspacePage.mockGetFile("components/get-file-13267.json");
-
-  await workspacePage.goToWorkspace({
-    fileId: "e9c84e12-dd29-80fc-8007-86d559dced7f",
-    pageId: "e9c84e12-dd29-80fc-8007-86d559dced80",
-  });
-
-  // Create a component instance
-  await workspacePage.clickLeafLayer("A Component");
-  await workspacePage.page.keyboard.press("ControlOrMeta+d");
-
-  // Select the main component
-  await workspacePage.clickLeafLayer("A Component", {}, 1);
-  const rotationInput = workspacePage.rightSidebar.getByTestId("rotation").getByRole("textbox");
-  await rotationInput.fill("45");
-  await rotationInput.press("Enter");
-
-  // Select the instance rect
-  await workspacePage.clickToggableLayer("A Component", {}, 0);
-  await workspacePage.clickLeafLayer("Rectangle");
-
-  await expect(rotationInput).toHaveValue("45");
-});
--- a/frontend/pnpm-lock.yaml
+++ b/frontend/pnpm-lock.yaml
--- a/frontend/pnpm-workspace.yaml
+++ b/frontend/pnpm-workspace.yaml
@@ -8,4 +8,3 @@ packages:
  - "packages/mousetrap"
  - "packages/tokenscript"
  - "text-editor"
-  - "packages/ui"
--- a/frontend/resources/templates/index.mustache
+++ b/frontend/resources/templates/index.mustache
@@ -18,7 +18,6 @@
    <meta name="twitter:creator" content="@penpotapp">
    <meta name="theme-color" content="#FFFFFF" media="(prefers-color-scheme: light)">
    <link id="theme" href="css/main.css?version={{& version_tag}}" rel="stylesheet" type="text/css" />
-     <link href="css/ui.css?ts={{& ts}}" rel="stylesheet" type="text/css" />
    {{#isDebug}}
    <link href="css/debug.css?version={{& version_tag}}" rel="stylesheet" type="text/css" />
    {{/isDebug}}
--- a/frontend/scripts/build
+++ b/frontend/scripts/build
@@ -4,6 +4,8 @@

 set -ex

+export INCLUDE_STORYBOOK=${BUILD_STORYBOOK:-no};
+export INCLUDE_WASM=${BUILD_WASM:-yes};
 export EXTRA_PARAMS=$SHADOWCLJS_EXTRA_PARAMS;

 export BUILD_DATE=$(date -R);
@@ -16,8 +18,6 @@ export VERSION_TAG="${VERSION}-${BUILD_TS}";
 # performant code on macros (example: rumext)
 export NODE_ENV=production;

-rm -rf node_modules;
-
 corepack enable;
 corepack install;
 pnpm install;
@@ -28,17 +28,10 @@ rm -rf resources/public;
 mkdir -p resources/public;
 mkdir -p target/dist;

-# Build render wasm binary
 pushd ../render-wasm;
 ./build
 popd

-pushd ../mcp;
-rm -rf node_modules;
-./scripts/setup
-WS_URI="/mcp/ws" pnpm run --filter "mcp-plugin" build:multi-user
-popd;
-
 pnpm run build:app:main $EXTRA_PARAMS;
 pnpm run build:app:libs;
 pnpm run build:app:assets;
@@ -47,6 +40,8 @@ sed -i "s/\.\/render.js/.\/render.js?version=$VERSION_TAG/g" resources/public/js

 rsync -avr resources/public/ target/dist/

-# Include the MCP plugin on the bundle
-mkdir -p target/dist/plugins/mcp/;
-rsync -avr ../mcp/packages/plugin/dist/ target/dist/plugins/mcp/
+if [ "$INCLUDE_STORYBOOK" = "yes" ];  then
+    # build storybook
+    pnpm run build:storybook || exit 1;
+    rsync -avr storybook-static/ target/dist/storybook-static;
+fi
--- a/frontend/scripts/build-libs.js
+++ b/frontend/scripts/build-libs.js
@@ -1,20 +1,6 @@
 import * as esbuild from "esbuild";
 import { readFile } from "node:fs/promises";

-/**
- * esbuild plugin to watch a directory recursively
- */
-const watchExtraDirPlugin = {
-  name: 'watch-extra-dir',
-  setup(build) {
-    build.onLoad({ filter: /target\/index.js/, namespace: 'file' }, async (args) => {
-      return {
-        watchDirs: ["packages/ui/dist"],
-      };
-    });
-  }
-};
-
 const filter =
  /react-virtualized[/\\]dist[/\\]es[/\\]WindowScroller[/\\]utils[/\\]onScroll\.js$/;

@@ -50,7 +36,7 @@ const config = {
    js: '"use strict";\nvar global = globalThis;',
  },
  outfile: "resources/public/js/libs.js",
-  plugins: [fixReactVirtualized, rebuildNotify, watchExtraDirPlugin],
+  plugins: [fixReactVirtualized, rebuildNotify],
 };

 async function watch() {
--- a/frontend/scripts/build-storybook
+++ b/frontend/scripts/build-storybook
@@ -13,7 +13,7 @@ export VERSION_TAG="${VERSION}-${BUILD_TS}";
 export NODE_ENV=production;

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

-pnpm run build:storybook;
+pnpm run build:storybook || exit 1;
--- a/frontend/src/app/main/data/style_dictionary.cljs
+++ b/frontend/src/app/main/data/style_dictionary.cljs
@@ -8,7 +8,7 @@
  (:require
   ["@tokens-studio/sd-transforms" :as sd-transforms]
   ["style-dictionary$default" :as sd]
-   [app.common.files.tokens :as cfo]
+   [app.common.files.tokens :as cft]
   [app.common.logging :as l]
   [app.common.schema :as sm]
   [app.common.time :as ct]
@@ -85,7 +85,7 @@
  [value]
  (let [number? (or (number? value)
                    (numeric-string? value))
-        parsed-value  (cfo/parse-token-value value)
+        parsed-value  (cft/parse-token-value value)
        out-of-bounds (or (>= (:value parsed-value) sm/max-safe-int)
                          (<= (:value parsed-value) sm/min-safe-int))]

@@ -111,7 +111,7 @@
  "Parses `value` of a number `sd-token` into a map like `{:value 1 :unit \"px\"}`.
  If the `value` is not parseable and/or has missing references returns a map with `:errors`."
  [value]
-  (let [parsed-value  (cfo/parse-token-value value)
+  (let [parsed-value  (cft/parse-token-value value)
        out-of-bounds (or (>= (:value parsed-value) sm/max-safe-int)
                          (<= (:value parsed-value) sm/min-safe-int))]
    (if (and parsed-value (not out-of-bounds))
@@ -129,7 +129,7 @@
  If the `value` is parseable but is out of range returns a map with `warnings`."
  [value]
  (let [missing-references? (seq (cto/find-token-value-references value))
-        parsed-value (cfo/parse-token-value value)
+        parsed-value (cft/parse-token-value value)
        out-of-scope (not (<= 0 (:value parsed-value) 1))
        references (seq (cto/find-token-value-references value))]
    (cond (and parsed-value (not out-of-scope))
@@ -153,7 +153,7 @@
  If the `value` is parseable but is out of range returns a map with `warnings`."
  [value]
  (let [missing-references? (seq (cto/find-token-value-references value))
-        parsed-value (cfo/parse-token-value value)
+        parsed-value (cft/parse-token-value value)
        out-of-scope (< (:value parsed-value) 0)]
    (cond
      (and parsed-value (not out-of-scope))
@@ -251,7 +251,7 @@
           :font-size-value font-size-value})]
    (or error
        (try
-          (when-let [{:keys [unit value]} (cfo/parse-token-value line-height-value)]
+          (when-let [{:keys [unit value]} (cft/parse-token-value line-height-value)]
            (case unit
              "%" (/ value 100)
              "px" (/ value font-size-value)
--- a/frontend/src/app/main/data/workspace/modifiers.cljs
+++ b/frontend/src/app/main/data/workspace/modifiers.cljs
@@ -179,56 +179,6 @@
         (map #(get objects %))
         (reduce get-ignore-tree nil))))

-(defn calculate-ignore-tree-wasm
-  "Retrieves a map with the flag `ignore-geometry?` given a tree of modifiers"
-  [transforms objects]
-
-  (letfn [(get-ignore-tree
-            ([ignore-tree shape]
-             (let [shape-id (dm/get-prop shape :id)
-                   transformed-shape (gsh/apply-transform shape (get transforms shape-id))
-
-                   root
-                   (if (:component-root shape)
-                     shape
-                     (ctn/get-component-shape objects shape {:allow-main? true}))
-
-                   transformed-root
-                   (if (:component-root shape)
-                     transformed-shape
-                     (gsh/apply-transform root (get transforms (:id root))))]
-
-               (get-ignore-tree ignore-tree shape transformed-shape root transformed-root)))
-
-            ([ignore-tree shape root transformed-root]
-             (let [shape-id (dm/get-prop shape :id)
-                   transformed-shape (gsh/apply-transform shape (get transforms shape-id))]
-               (get-ignore-tree ignore-tree shape transformed-shape root transformed-root)))
-
-            ([ignore-tree shape transformed-shape root transformed-root]
-             (let [shape-id (dm/get-prop shape :id)
-
-                   ignore-tree
-                   (cond-> ignore-tree
-                     (and (some? root) (ctk/in-component-copy? shape))
-                     (assoc
-                      shape-id
-                      (check-delta shape root transformed-shape transformed-root)))
-
-                   set-child
-                   (fn [ignore-tree child]
-                     (get-ignore-tree ignore-tree child root transformed-root))]
-
-               (->> (:shapes shape)
-                    (map (d/getf objects))
-                    (reduce set-child ignore-tree)))))]
-
-    ;; we check twice because we want only to search parents of components but once the
-    ;; tree is traversed we only want to process the objects in components
-    (->> (keys transforms)
-         (map #(get objects %))
-         (reduce get-ignore-tree nil))))
-
 (defn assoc-position-data
  [shape position-data old-shape]
  (let [deltav (gpt/to-vec (gpt/point (:selrect old-shape))
@@ -675,17 +625,8 @@

      (let [objects          (dsh/lookup-page-objects state)

-            geometry-entries
-            (parse-geometry-modifiers modif-tree)
-
-            snap-pixel?
-            (and (not ignore-snap-pixel) (contains? (:workspace-layout state) :snap-pixel-grid))
-
-            transforms
-            (into {} (wasm.api/propagate-modifiers geometry-entries snap-pixel?))
-
            ignore-tree
-            (calculate-ignore-tree-wasm transforms objects)
+            (calculate-ignore-tree modif-tree objects)

            options
            (-> params
@@ -695,6 +636,15 @@
                ;; way we don't have to check all the attributes
                (assoc :attrs transform-attrs))

+            geometry-entries
+            (parse-geometry-modifiers modif-tree)
+
+            snap-pixel?
+            (and (not ignore-snap-pixel) (contains? (:workspace-layout state) :snap-pixel-grid))
+
+            transforms
+            (into {} (wasm.api/propagate-modifiers geometry-entries snap-pixel?))
+
            modif-tree
            (propagate-structure-modifiers modif-tree (dsh/lookup-page-objects state))

--- a/frontend/src/app/main/data/workspace/shape_layout.cljs
+++ b/frontend/src/app/main/data/workspace/shape_layout.cljs
@@ -104,7 +104,7 @@
    (watch [_ state _]
      (let [page-id (or page-id (:current-page-id state))
            objects (dsh/lookup-page-objects state page-id)
-            ids (->> ids (remove uuid/zero?) (filter #(contains? objects %)))]
+            ids (->> ids (filter #(contains? objects %)))]
        (if (d/not-empty? ids)
          (let [modif-tree (dwm/create-modif-tree ids (ctm/reflow-modifiers))]
            (if (features/active-feature? state "render-wasm/v1")
--- a/frontend/src/app/main/data/workspace/texts.cljs
+++ b/frontend/src/app/main/data/workspace/texts.cljs
@@ -46,7 +46,6 @@
 (def ^function create-editor editor.v2/create)
 (def ^function set-editor-root! editor.v2/setRoot)
 (def ^function get-editor-root editor.v2/getRoot)
-(def ^function is-empty? editor.v2/isEmpty)
 (def ^function dispose! editor.v2/dispose)

 (declare v2-update-text-shape-content)
@@ -777,7 +776,11 @@
             (rx/of (v2-update-text-editor-styles id attrs)))

           (when (features/active-feature? state "render-wasm/v1")
-             (rx/of (dwwt/resize-wasm-text-debounce id)))))))
+             ;; This delay is to give time for the font to be correctly rendered
+             ;; in wasm.
+             (cond->> (rx/of (dwwt/resize-wasm-text id))
+               (contains? attrs :font-id)
+               (rx/delay 200)))))))

    ptk/EffectEvent
    (effect [_ state _]
@@ -902,22 +905,15 @@
      (update-in state [:workspace-text-modifier shape-id] {:position-data position-data}))))

 (defn v2-update-text-shape-content
-  [id content & {:keys [update-name? name finalize? save-undo?]
-                 :or {update-name? false name nil finalize? false save-undo? true}}]
+  [id content & {:keys [update-name? name finalize?]
+                 :or {update-name? false name nil finalize? false}}]
  (ptk/reify ::v2-update-text-shape-content
    ptk/WatchEvent
    (watch [_ state _]
      (if (features/active-feature? state "render-wasm/v1")
        (let [objects      (dsh/lookup-page-objects state)
              shape        (get objects id)
-              new-shape?   (nil? (:content shape))
-              prev-content (:content shape)
-              has-prev-content? (not (nil? (:prev-content shape)))
-              has-content? (when-not new-shape?
-                             (v2-content-has-text? content))
-              did-has-content? (when-not new-shape?
-                                 (v2-content-has-text? prev-content))]
-
+              new-shape?   (nil? (:content shape))]
          (rx/concat
           (rx/of
            (dwsh/update-shapes
@@ -925,16 +921,10 @@
             (fn [shape]
               (let [new-shape (-> shape
                                   (assoc :content content)
-                                   (cond-> (and has-content?
-                                                has-prev-content?)
-                                     (dissoc :prev-content))
-                                   (cond-> (and did-has-content?
-                                                (not has-content?))
-                                     (assoc :prev-content prev-content))
                                   (cond-> (and update-name? (some? name))
                                     (assoc :name name)))]
                 new-shape))
-             {:save-undo? save-undo? :undo-group (when new-shape? id)})
+             {:undo-group (when new-shape? id)})

            (if (and (not= :fixed (:grow-type shape)) finalize?)
              (dwm/apply-wasm-modifiers
@@ -947,16 +937,8 @@

           (when finalize?
             (rx/concat
-              (when (and (not has-content?) (some? id))
+              (when (and (not (v2-content-has-text? content)) (some? id))
                (rx/of
-                 (when has-prev-content?
-                   (dwsh/update-shapes
-                    [id]
-                    (fn [shape]
-                      (let [new-shape (-> shape
-                                          (assoc :content (:prev-content shape)))]
-                        new-shape))
-                    {:save-undo? false}))
                 (dws/deselect-shape id)
                 (dwsh/delete-shapes #{id})))
              (rx/of (dwt/finish-transform))))))
--- a/frontend/src/app/main/data/workspace/tokens/application.cljs
+++ b/frontend/src/app/main/data/workspace/tokens/application.cljs
@@ -7,7 +7,7 @@
 (ns app.main.data.workspace.tokens.application
  (:require
   [app.common.data :as d]
-   [app.common.files.tokens :as cfo]
+   [app.common.files.tokens :as cft]
   [app.common.types.component :as ctk]
   [app.common.types.shape.layout :as ctsl]
   [app.common.types.shape.radius :as ctsr]
@@ -648,11 +648,11 @@
                          shape-ids (d/nilv (keys shapes)  [])
                          any-variant? (->> shapes vals (some ctk/is-variant?) boolean)

-                          resolved-value (get-in resolved-tokens [(cfo/token-identifier token) :resolved-value])
+                          resolved-value (get-in resolved-tokens [(cft/token-identifier token) :resolved-value])
                          resolved-value (if (contains? cf/flags :tokenscript)
                                           (ts/tokenscript-symbols->penpot-unit resolved-value)
                                           resolved-value)
-                          tokenized-attributes (cfo/attributes-map attributes token)
+                          tokenized-attributes (cft/attributes-map attributes token)
                          type (:type token)]
                      (rx/concat
                       (rx/of
@@ -711,7 +711,7 @@
    ptk/WatchEvent
    (watch [_ _ _]
      (rx/of
-       (let [remove-token #(when % (cfo/remove-attributes-for-token attributes token-name %))]
+       (let [remove-token #(when % (cft/remove-attributes-for-token attributes token-name %))]
         (dwsh/update-shapes
          shape-ids
          (fn [shape]
@@ -740,7 +740,7 @@
            (get token-properties (:type token))

            unapply-tokens?
-            (cfo/shapes-token-applied? token shapes (or attrs all-attributes attributes))
+            (cft/shapes-token-applied? token shapes (or attrs all-attributes attributes))

            shape-ids (map :id shapes)]

--- a/frontend/src/app/main/data/workspace/tokens/color.cljs
+++ b/frontend/src/app/main/data/workspace/tokens/color.cljs
@@ -6,7 +6,7 @@

 (ns app.main.data.workspace.tokens.color
  (:require
-   [app.common.files.tokens :as cfo]
+   [app.common.files.tokens :as cft]
   [app.config :as cf]
   [app.main.data.tinycolor :as tinycolor]
   [app.main.data.tokenscript :as ts]))
@@ -22,5 +22,5 @@
  (if (contains? cf/flags :tokenscript)
    (when (and resolved-value (ts/color-symbol? resolved-value))
      (ts/color-symbol->penpot-color resolved-value))
-    (when (and resolved-value (cfo/color-token? token))
+    (when (and resolved-value (cft/color-token? token))
      (color-bullet-color resolved-value))))
--- a/frontend/src/app/main/data/workspace/tokens/library_edit.cljs
+++ b/frontend/src/app/main/data/workspace/tokens/library_edit.cljs
@@ -195,30 +195,27 @@

 (defn create-token-set
  [token-set]
-  (assert (ctob/token-set? token-set) "a token set is required") ;; TODO should check token-set-schema?
  (ptk/reify ::create-token-set
-    ptk/WatchEvent
-    (watch [it state _]
-      (let [data    (dsh/lookup-file-data state)
-            changes (-> (pcb/empty-changes it)
-                        (pcb/with-library-data data)
-                        (pcb/set-token-set (ctob/get-id token-set) token-set))]
-        (rx/of (set-selected-token-set-id (ctob/get-id token-set))
-               (dch/commit-changes changes))))))
+    ptk/UpdateEvent
+    (update [_ state]
+      ;; Clear possible local state
+      (update state :workspace-tokens dissoc :token-set-new-path))

-(defn rename-token-set
-  [token-set new-name]
-  (assert (ctob/token-set? token-set) "a token set is required") ;; TODO should check token-set-schema after renaming?
-  (assert (string? new-name) "a new name is required") ;; TODO should assert normalized-set-name?
-  (ptk/reify ::update-token-set
    ptk/WatchEvent
    (watch [it state _]
-      (let [data    (dsh/lookup-file-data state)
-            changes (-> (pcb/empty-changes it)
-                        (pcb/with-library-data data)
-                        (pcb/rename-token-set (ctob/get-id token-set) new-name))]
-        (rx/of (set-selected-token-set-id (ctob/get-id token-set))
-               (dch/commit-changes changes))))))
+      (let [data       (dsh/lookup-file-data state)
+            tokens-lib (get data :tokens-lib)
+            token-set  (ctob/rename token-set (ctob/normalize-set-name (ctob/get-name token-set)))]
+        (if (and tokens-lib (ctob/get-set-by-name tokens-lib (ctob/get-name token-set)))
+          (rx/of (ntf/show {:content (tr "errors.token-set-already-exists")
+                            :type :toast
+                            :level :error
+                            :timeout 9000}))
+          (let [changes (-> (pcb/empty-changes it)
+                            (pcb/with-library-data data)
+                            (pcb/set-token-set (ctob/get-id token-set) token-set))]
+            (rx/of (set-selected-token-set-id (ctob/get-id token-set))
+                   (dch/commit-changes changes))))))))

 (defn rename-token-set-group
  [set-group-path set-group-fname]
@@ -230,6 +227,26 @@
        (rx/of
         (dch/commit-changes changes))))))

+(defn update-token-set
+  [token-set name]
+  (ptk/reify ::update-token-set
+    ptk/WatchEvent
+    (watch [it state _]
+      (let [data       (dsh/lookup-file-data state)
+            name       (ctob/normalize-set-name name (ctob/get-name token-set))
+            tokens-lib (get data :tokens-lib)]
+
+        (if (ctob/get-set-by-name tokens-lib name)
+          (rx/of (ntf/show {:content (tr "errors.token-set-already-exists")
+                            :type :toast
+                            :level :error
+                            :timeout 9000}))
+          (let [changes (-> (pcb/empty-changes it)
+                            (pcb/with-library-data data)
+                            (pcb/rename-token-set (ctob/get-id token-set) name))]
+            (rx/of (set-selected-token-set-id (ctob/get-id token-set))
+                   (dch/commit-changes changes))))))))
+
 (defn duplicate-token-set
  [id]
  (ptk/reify ::duplicate-token-set
@@ -505,7 +522,7 @@
                                           (ctob/get-id token-set)
                                           token-id)]
            (let [tokens (vals (ctob/get-tokens tokens-lib (ctob/get-id token-set)))
-                  unames (map :name tokens)     ;; TODO: add function duplicate-token in tokens-lib
+                  unames (map :name tokens)
                  suffix (tr "workspace.tokens.duplicate-suffix")
                  copy-name (cfh/generate-unique-name (:name token) unames :suffix suffix)
                  new-token (-> token
--- a/frontend/src/app/main/data/workspace/transforms.cljs
+++ b/frontend/src/app/main/data/workspace/transforms.cljs
@@ -621,7 +621,7 @@
      (->> stream
           (rx/filter (ptk/type? ::dws/duplicate-selected))
           (rx/take 1)
-           (rx/map #(start-move from-position nil true))))))
+           (rx/map #(start-move from-position))))))

 (defn get-drop-cell
  [target-frame objects position]
@@ -641,9 +641,8 @@
        (dom/set-property! node "transform" (gmt/translate-matrix move-vector))))))

 (defn start-move
-  ([from-position] (start-move from-position nil false))
-  ([from-position ids] (start-move from-position ids false))
-  ([from-position ids from-duplicate?]
+  ([from-position] (start-move from-position nil))
+  ([from-position ids]
   (ptk/reify ::start-move
     ptk/UpdateEvent
     (update [_ state]
@@ -751,47 +750,38 @@
                      (rx/share))]

             (if (features/active-feature? state "render-wasm/v1")
-               (let [duplicate-stopper
-                     (->> ms/mouse-position-alt
-                          (rx/mapcat
-                           (fn [alt?]
-                             (if (and alt? (not from-duplicate?))
-                               (rx/of true)
-                               (rx/empty)))))]
-                 (rx/merge
-                  (->> modifiers-stream
-                       (rx/take-until duplicate-stopper)
-                       (rx/map
-                        (fn [[modifiers snap-ignore-axis]]
-                          (dwm/set-wasm-modifiers modifiers :snap-ignore-axis snap-ignore-axis))))
+               (rx/merge
+                (->> modifiers-stream
+                     (rx/map
+                      (fn [[modifiers snap-ignore-axis]]
+                        (dwm/set-wasm-modifiers modifiers :snap-ignore-axis snap-ignore-axis))))

-                  (->> move-stream
-                       (rx/with-latest-from ms/mouse-position-alt)
-                       (rx/filter (fn [[_ alt?]] alt?))
-                       (rx/take 1)
-                       (rx/mapcat
-                        (fn [[_ alt?]]
-                          (if (and (not from-duplicate?) alt?)
-                            (rx/of (start-move-duplicate from-position)
-                                   (dws/duplicate-selected false true))
-                            (rx/empty)))))
+                (->> move-stream
+                     (rx/with-latest-from ms/mouse-position-alt)
+                     (rx/filter (fn [[_ alt?]] alt?))
+                     (rx/take 1)
+                     (rx/mapcat
+                      (fn [[_ alt?]]
+                        (if (and (not duplicate-move-started?) alt?)
+                          (rx/of (start-move-duplicate from-position)
+                                 (dws/duplicate-selected false true))
+                          (rx/empty)))))

-                  ;; Last event will write the modifiers creating the changes
-                  (->> move-stream
-                       (rx/last)
-                       (rx/take-until duplicate-stopper)
-                       (rx/with-latest-from modifiers-stream)
-                       (rx/mapcat
-                        (fn [[[_ target-frame drop-index drop-cell] [modifiers snap-ignore-axis]]]
-                          (let [undo-id (js/Symbol)]
-                            (rx/of
-                             (dwu/start-undo-transaction undo-id)
-                             (dwm/apply-wasm-modifiers modifiers
-                                                       :snap-ignore-axis snap-ignore-axis
-                                                       :undo-transation? false)
-                             (move-shapes-to-frame ids target-frame drop-index drop-cell)
-                             (finish-transform)
-                             (dwu/commit-undo-transaction undo-id))))))))
+                ;; Last event will write the modifiers creating the changes
+                (->> move-stream
+                     (rx/last)
+                     (rx/with-latest-from modifiers-stream)
+                     (rx/mapcat
+                      (fn [[[_ target-frame drop-index drop-cell] [modifiers snap-ignore-axis]]]
+                        (let [undo-id (js/Symbol)]
+                          (rx/of
+                           (dwu/start-undo-transaction undo-id)
+                           (dwm/apply-wasm-modifiers modifiers
+                                                     :snap-ignore-axis snap-ignore-axis
+                                                     :undo-transation? false)
+                           (move-shapes-to-frame ids target-frame drop-index drop-cell)
+                           (finish-transform)
+                           (dwu/commit-undo-transaction undo-id)))))))

               (rx/merge
                (->> modifiers-stream
--- a/frontend/src/app/main/data/workspace/wasm_text.cljs
+++ b/frontend/src/app/main/data/workspace/wasm_text.cljs
@@ -10,7 +10,6 @@
  This exists to avoid circular deps:
  workspace.texts -> workspace.libraries -> workspace.texts"
  (:require
-   [app.common.data.macros :as dm]
   [app.common.files.helpers :as cfh]
   [app.common.geom.matrix :as gmt]
   [app.common.geom.point :as gpt]
@@ -18,7 +17,6 @@
   [app.main.data.helpers :as dsh]
   [app.main.data.workspace.modifiers :as dwm]
   [app.render-wasm.api :as wasm.api]
-   [app.render-wasm.api.fonts :as wasm.fonts]
   [beicon.v2.core :as rx]
   [potok.v2.core :as ptk]))

@@ -64,84 +62,6 @@
          (rx/of (dwm/apply-wasm-modifiers (resize-wasm-text-modifiers shape)))
          (rx/empty))))))

-(defn resize-wasm-text-debounce-commit
-  []
-  (ptk/reify ::resize-wasm-text-debounce-commit
-    ptk/WatchEvent
-    (watch [_ state _]
-      (let [ids (get state ::resize-wasm-text-debounce-ids)
-            objects (dsh/lookup-page-objects state)
-
-            modifiers
-            (reduce
-             (fn [modifiers id]
-               (let [shape (get objects id)]
-                 (cond-> modifiers
-                   (and (some? shape)
-                        (cfh/text-shape? shape)
-                        (not= :fixed (:grow-type shape)))
-                   (merge (resize-wasm-text-modifiers shape)))))
-             {}
-             ids)]
-        (if (not (empty? modifiers))
-          (rx/of (dwm/apply-wasm-modifiers modifiers))
-          (rx/empty))))))
-
-;; This event will debounce the resize events so, if there are many, they
-;; are processed at the same time and not one-by-one. This will improve
-;; performance because it's better to make only one layout calculation instead
-;; of (potentialy) hundreds.
-(defn resize-wasm-text-debounce-inner
-  [id]
-  (let [cur-event (js/Symbol)]
-    (ptk/reify ::resize-wasm-text-debounce-inner
-      ptk/UpdateEvent
-      (update [_ state]
-        (-> state
-            (update ::resize-wasm-text-debounce-ids (fnil conj []) id)
-            (cond-> (nil? (::resize-wasm-text-debounce-event state))
-              (assoc ::resize-wasm-text-debounce-event cur-event))))
-
-      ptk/WatchEvent
-      (watch [_ state stream]
-        (if (= (::resize-wasm-text-debounce-event state) cur-event)
-          (let [stopper (->> stream (rx/filter (ptk/type? :app.main.data.workspace/finalize)))]
-            (rx/concat
-             (rx/merge
-              (->> stream
-                   (rx/filter (ptk/type? ::resize-wasm-text-debounce-inner))
-                   (rx/debounce 40)
-                   (rx/take 1)
-                   (rx/map #(resize-wasm-text-debounce-commit))
-                   (rx/take-until stopper))
-              (rx/of (resize-wasm-text-debounce-inner id)))
-             (rx/of #(dissoc %
-                             ::resize-wasm-text-debounce-ids
-                             ::resize-wasm-text-debounce-event))))
-          (rx/empty))))))
-
-(defn resize-wasm-text-debounce
-  [id]
-  (ptk/reify ::resize-wasm-text-debounce
-    ptk/WatchEvent
-    (watch [_ state _]
-      (let [page-id (:current-page-id state)
-            objects (dsh/lookup-page-objects state page-id)
-            content (dm/get-in objects [id :content])
-            fonts   (wasm.fonts/get-content-fonts content)
-
-            fonts-loaded?
-            (->> fonts
-                 (every?
-                  (fn [font]
-                    (let [font-data (wasm.fonts/make-font-data font)]
-                      (wasm.fonts/font-stored? font-data (:emoji? font-data))))))]
-
-        (if (not fonts-loaded?)
-          (->> (rx/of (resize-wasm-text-debounce id))
-               (rx/delay 20))
-          (rx/of (resize-wasm-text-debounce-inner id)))))))
-
 (defn resize-wasm-text-all
  "Resize all text shapes (auto-width/auto-height) from a collection of ids."
  [ids]
--- a/frontend/src/app/main/ui/ds/buttons/icon_button.cljs
+++ b/frontend/src/app/main/ui/ds/buttons/icon_button.cljs
@@ -16,7 +16,6 @@
 (def ^:private schema:icon-button
  [:map
   [:class {:optional true} :string]
-   [:tooltip-class {:optional true} [:maybe :string]]
   [:icon-class {:optional true} :string]
   [:icon
    [:and :string [:fn #(contains? icon-list %)]]]
@@ -29,7 +28,7 @@
 (mf/defc icon-button*
  {::mf/schema schema:icon-button
   ::mf/memo true}
-  [{:keys [class icon icon-class variant aria-label children tooltip-placement tooltip-class] :rest props}]
+  [{:keys [class icon icon-class variant aria-label children tooltip-placement] :rest props}]
  (let [variant
        (d/nilv variant "primary")

@@ -50,7 +49,6 @@
                          :aria-labelledby tooltip-id})]

    [:> tooltip* {:content aria-label
-                  :class tooltip-class
                  :placement tooltip-placement
                  :id tooltip-id}
     [:> :button props
--- a/frontend/src/app/main/ui/ds/controls/numeric_input.cljs
+++ b/frontend/src/app/main/ui/ds/controls/numeric_input.cljs
@@ -18,6 +18,7 @@
   [app.main.ui.ds.controls.utilities.input-field :refer [input-field*]]
   [app.main.ui.ds.controls.utilities.token-field :refer [token-field*]]
   [app.main.ui.ds.foundations.assets.icon :refer [icon* icon-list] :as i]
+   [app.main.ui.ds.tooltip :refer [tooltip*]]
   [app.main.ui.formats :as fmt]
   [app.util.dom :as dom]
   [app.util.i18n :refer [tr]]
@@ -637,17 +638,27 @@
                                :on-change store-raw-value
                                :variant "comfortable"
                                :disabled disabled
-                                :icon icon
-                                :aria-label property
-                                :slot-start (when text-icon
+                                :slot-start (when (or icon text-icon)
                                              (mf/html
-                                               [:div {:class (stl/css :text-icon)}
-                                                text-icon]))
+                                               [:> tooltip*
+                                                {:content property
+                                                 :id property}
+                                                (cond
+                                                  icon
+                                                  [:> icon*
+                                                   {:icon-id icon
+                                                    :size "s"
+                                                    :aria-labelledby property
+                                                    :class (stl/css :icon)}]
+
+                                                  text-icon
+                                                  [:div {:class (stl/css :text-icon)
+                                                         :aria-labelledby property}
+                                                   text-icon])]))
                                :slot-end (when-not disabled
                                            (when (some? tokens)
                                              (mf/html [:> icon-button* {:variant "ghost"
                                                                         :icon i/tokens
-                                                                         :tooltip-class (stl/css :button-tooltip)
                                                                         :class (stl/css :invisible-button)
                                                                         :aria-label (tr "ds.inputs.numeric-input.open-token-list-dropdown")
                                                                         :ref open-dropdown-ref
@@ -675,19 +686,23 @@
                              :disabled disabled
                              :on-blur on-blur
                              :class inner-class
-                              :property property
                              :slot-start (when (or icon text-icon)
                                            (mf/html
-                                             (cond
-                                               icon
-                                               [:> icon*
-                                                {:icon-id icon
-                                                 :size "s"
-                                                 :class (stl/css :icon)}]
+                                             [:> tooltip*
+                                              {:content property
+                                               :id property}
+                                              (cond
+                                                icon
+                                                [:> icon*
+                                                 {:icon-id icon
+                                                  :size "s"
+                                                  :aria-labelledby property
+                                                  :class (stl/css :icon)}]

-                                               text-icon
-                                               [:div {:class (stl/css :text-icon)}
-                                                text-icon])))
+                                                text-icon
+                                                [:div {:class (stl/css :text-icon)
+                                                       :aria-labelledby property}
+                                                 text-icon])]))
                              :token-wrapper-ref token-wrapper-ref
                              :token-detach-btn-ref token-detach-btn-ref
                              :detach-token detach-token})))]
@@ -722,21 +737,40 @@
    (mf/with-effect [dropdown-options]
      (mf/set-ref-val! options-ref dropdown-options))

-    [:div {:class [class (stl/css :input-wrapper)]
-           :ref wrapper-ref}
+    (if (some? icon)
+      [:div {:class [class (stl/css :input-wrapper)]
+             :ref wrapper-ref}

-     (if (and (some? token-applied)
-              (not= :multiple token-applied))
-       [:> token-field* token-props]
-       [:> input-field* input-props])
+       (if (and (some? token-applied)
+                (not= :multiple token-applied))
+         [:> token-field* token-props]
+         [:> input-field* input-props])

-     (when ^boolean is-open
-       (let [options (if (delay? dropdown-options) @dropdown-options dropdown-options)]
-         [:> options-dropdown* {:on-click on-option-click
-                                :id listbox-id
-                                :options options
-                                :selected selected-id
-                                :focused focused-id
-                                :align align
-                                :empty-to-end empty-to-end
-                                :ref set-option-ref}]))]))
+       (when ^boolean is-open
+         (let [options (if (delay? dropdown-options) @dropdown-options dropdown-options)]
+           [:> options-dropdown* {:on-click on-option-click
+                                  :id listbox-id
+                                  :options options
+                                  :selected selected-id
+                                  :focused focused-id
+                                  :align align
+                                  :empty-to-end empty-to-end
+                                  :ref set-option-ref}]))]
+      [:div {:class [class (stl/css :input-wrapper)]
+             :ref wrapper-ref}
+
+       (if (and (some? token-applied)
+                (not= :multiple token-applied))
+         [:> token-field* token-props]
+         [:> input-field* input-props])
+
+       (when ^boolean is-open
+         (let [options (if (delay? dropdown-options) @dropdown-options dropdown-options)]
+           [:> options-dropdown* {:on-click on-option-click
+                                  :id listbox-id
+                                  :options options
+                                  :selected selected-id
+                                  :focused focused-id
+                                  :align align
+                                  :empty-to-end empty-to-end
+                                  :ref set-option-ref}]))])))
--- a/frontend/src/app/main/ui/ds/controls/numeric_input.scss
+++ b/frontend/src/app/main/ui/ds/controls/numeric_input.scss
@@ -55,8 +55,3 @@
    --opacity-button: 1;
  }
 }
-
-.button-tooltip {
-  inline-size: var($sz-28);
-  block-size: 100%;
-}
--- a/frontend/src/app/main/ui/ds/controls/utilities/input_field.cljs
+++ b/frontend/src/app/main/ui/ds/controls/utilities/input_field.cljs
@@ -42,6 +42,7 @@
        type  (d/nilv type "text")
        variant (d/nilv variant "dense")
        tooltip-id (mf/use-id)
+
        props (mf/spread-props props
                               {:class [class
                                        (stl/css-case
@@ -53,11 +54,15 @@
                                                "true")
                                :aria-describedby (when has-hint
                                                    (str id "-hint"))
-                                :aria-labelledby tooltip-id
                                :type (d/nilv type "text")
                                :id id
                                :max-length (d/nilv max-length max-input-length)})

+        props (if (and aria-label (not (some? icon)))
+                (mf/spread-props props
+                                 {:aria-label aria-label})
+                (mf/spread-props props
+                                 {:aria-labelledby tooltip-id}))
        inside-class (stl/css-case :input-wrapper true
                                   :has-hint has-hint
                                   :hint-type-hint (= hint-type "hint")
@@ -78,14 +83,11 @@
     (when (some? slot-start)
       slot-start)
     (when (some? icon)
-       [:> icon* {:icon-id icon
-                  :class (stl/css :icon)
-                  :size "s"
-                  :on-click on-icon-click}])
-     (if aria-label
-       [:> tooltip* {:content aria-label
-                     :id tooltip-id}
-        [:> "input" props]]
-       [:> "input" props])
+       (if aria-label
+         [:> tooltip* {:content aria-label
+                       :id tooltip-id}
+          [:> icon* {:icon-id icon :class (stl/css :icon) :on-click on-icon-click}]]
+         [:> icon* {:icon-id icon :class (stl/css :icon) :on-click on-icon-click}]))
+     [:> "input" props]
     (when (some? slot-end)
       slot-end)]))
--- a/frontend/src/app/main/ui/ds/controls/utilities/input_field.scss
+++ b/frontend/src/app/main/ui/ds/controls/utilities/input_field.scss
@@ -118,5 +118,4 @@

 .icon {
  color: var(--color-foreground-secondary);
-  min-inline-size: var(--sp-l);
 }
--- a/frontend/src/app/main/ui/ds/controls/utilities/token_field.cljs
+++ b/frontend/src/app/main/ui/ds/controls/utilities/token_field.cljs
@@ -22,7 +22,6 @@
   [:class {:optional true} [:maybe :string]]
   [:id {:optional true} [:maybe :string]]
   [:label {:optional true} [:maybe :string]]
-   [:property {:optional true} [:maybe :string]]
   [:value :any]
   [:disabled {:optional true} :boolean]
   [:slot-start {:optional true} [:maybe some?]]
@@ -36,7 +35,7 @@
  {::mf/schema schema:token-field}
  [{:keys [id label value slot-start disabled class
           on-click on-token-key-down on-blur detach-token
-           token-wrapper-ref token-detach-btn-ref on-focus property]}]
+           token-wrapper-ref token-detach-btn-ref on-focus]}]
  (let [set-active? (some? id)
        content     (if set-active?
                      label
@@ -51,42 +50,37 @@
           (when-not ^boolean disabled
             (dom/prevent-default event)
             (dom/focus! (mf/ref-val token-wrapper-ref)))))]
-    [:> tooltip* {:content property
-                  :class (stl/css :token-field-wrapper)
-                  :id (dm/str default-id "-input")}
-     [:div {:class [class (stl/css-case :token-field true
-                                        :with-icon (some? slot-start)
-                                        :token-field-disabled disabled)]
-            :on-click focus-wrapper
-            :disabled disabled
-            :on-key-down on-token-key-down
-            :ref token-wrapper-ref
-            :on-blur on-blur
-            :on-focus on-focus
-            :aria-labelledby (dm/str default-id "-input")
-            :tab-index (if disabled -1 0)}

-      (when (some? slot-start) slot-start)
+    [:div {:class [class (stl/css-case :token-field true
+                                       :with-icon (some? slot-start)
+                                       :token-field-disabled disabled)]
+           :on-click focus-wrapper
+           :disabled disabled
+           :on-key-down on-token-key-down
+           :ref token-wrapper-ref
+           :on-blur on-blur
+           :on-focus on-focus
+           :tab-index (if disabled -1 0)}

-      [:div  {:class (stl/css :content-wrapper)}
-       [:> tooltip* {:content content
-                     :id (dm/str id "-pill")}
-        [:button {:on-click on-click
-                  :class (stl/css-case :pill true
-                                       :no-set-pill (not set-active?)
-                                       :pill-disabled disabled)
-                  :disabled disabled
-                  :aria-labelledby (dm/str id "-pill")
-                  :on-key-down on-token-key-down}
-         value
-         (when-not set-active?
-           [:div {:class (stl/css :pill-dot)}])]]]
+     (when (some? slot-start) slot-start)

-      (when-not ^boolean disabled
-        [:> icon-button* {:variant "ghost"
-                          :class (stl/css :invisible-button)
-                          :tooltip-class (stl/css :button-tooltip)
-                          :icon i/broken-link
-                          :ref token-detach-btn-ref
-                          :aria-label (tr "ds.inputs.token-field.detach-token")
-                          :on-click detach-token}])]]))
+     [:> tooltip* {:content content
+                   :id (dm/str id "-pill")}
+      [:button {:on-click on-click
+                :class (stl/css-case :pill true
+                                     :no-set-pill (not set-active?)
+                                     :pill-disabled disabled)
+                :disabled disabled
+                :aria-labelledby (dm/str id "-pill")
+                :on-key-down on-token-key-down}
+       value
+       (when-not set-active?
+         [:div {:class (stl/css :pill-dot)}])]]
+
+     (when-not ^boolean disabled
+       [:> icon-button* {:variant "ghost"
+                         :class (stl/css :invisible-button)
+                         :icon i/broken-link
+                         :ref token-detach-btn-ref
+                         :aria-label (tr "ds.inputs.token-field.detach-token")
+                         :on-click detach-token}])]))
--- a/frontend/src/app/main/ui/ds/controls/utilities/token_field.scss
+++ b/frontend/src/app/main/ui/ds/controls/utilities/token_field.scss
@@ -9,7 +9,6 @@
@use "ds/typography.scss" as t;
@use "ds/colors.scss" as *;
@use "ds/mixins.scss" as *;
-@use "ds/_utils.scss" as *;

 .token-field {
  --token-field-bg-color: var(--color-background-tertiary);
@@ -38,9 +37,6 @@
    --token-field-outline-color: var(--color-accent-primary);
  }
 }
-.token-field-wrapper {
-  inline-size: 100%;
-}

 .with-icon {
  grid-template-columns: auto 1fr;
@@ -136,12 +132,3 @@
    --opacity-button: 1;
  }
 }
-
-.content-wrapper {
-  inline-size: 100%;
-}
-
-.button-tooltip {
-  inline-size: px2rem(28);
-  block-size: 100%;
-}
--- a/frontend/src/app/main/ui/ds/tooltip/tooltip.cljs
+++ b/frontend/src/app/main/ui/ds/tooltip/tooltip.cljs
@@ -171,7 +171,7 @@

 (def ^:private schema:tooltip
  [:map
-   [:class {:optional true} [:maybe :string]]
+   [:class {:optional true} :string]
   [:id {:optional true} :string]
   [:offset {:optional true} :int]
   [:delay {:optional true} :int]
@@ -184,7 +184,6 @@
  [{:keys [class id children content placement offset delay] :rest props}]
  (let [internal-id
        (mf/use-id)
-        trigger-ref (mf/use-ref nil)

        id
        (d/nilv id internal-id)
@@ -205,23 +204,19 @@
        (mf/use-fn
         (mf/deps id placement offset)
         (fn [event]
+           (clear-schedule schedule-ref)
+           (when-let [tooltip (dom/get-element id)]
+             (let [origin-brect
+                   (->> (dom/get-target event)
+                        (dom/get-bounding-rect))

-           (let [current (dom/get-current-target event)
-                 related (dom/get-related-target event)
-                 is-node? (fn [node] (and node (.-nodeType node)))]
-             (when-not (and related (is-node? related) (.contains current related))
-               (clear-schedule schedule-ref)
-               (when-let [tooltip (dom/get-element id)]
-                 (let [origin-brect
-                       (dom/get-bounding-rect (mf/ref-val trigger-ref))
+                   update-position
+                   (fn []
+                     (let [new-placement (update-tooltip-position tooltip placement origin-brect offset)]
+                       (when (not= new-placement placement)
+                         (reset! placement* new-placement))))]

-                       update-position
-                       (fn []
-                         (let [new-placement (update-tooltip-position tooltip placement origin-brect offset)]
-                           (when (not= new-placement placement)
-                             (reset! placement* new-placement))))]
-
-                   (add-schedule schedule-ref delay update-position)))))))
+               (add-schedule schedule-ref delay update-position)))))

        on-hide
        (mf/use-fn
@@ -257,7 +252,6 @@
                          :on-focus on-show
                          :on-blur on-hide
                          :on-key-down handle-key-down
-                          :ref trigger-ref
                          :class [class (stl/css :tooltip-trigger)]
                          :aria-describedby id})
        content
--- a/frontend/src/app/main/ui/forms.cljs
+++ b/frontend/src/app/main/ui/forms.cljs
@@ -49,6 +49,7 @@

 (mf/defc form-submit*
  [{:keys [disabled on-submit] :rest props}]
+
  (let [form      (mf/use-ctx context)
        disabled? (or (and (some? form)
                           (or (not (:valid @form))
--- a/frontend/src/app/main/ui/workspace/plugins.cljs
+++ b/frontend/src/app/main/ui/workspace/plugins.cljs
@@ -95,10 +95,10 @@
  []

  (let [plugins-state* (mf/use-state #(preg/plugins-list))
-        plugins-state  (deref plugins-state*)
+        plugins-state @plugins-state*

-        plugin-url*    (mf/use-state "")
-        plugin-url     (deref plugin-url*)
+        plugin-url* (mf/use-state "")
+        plugin-url  @plugin-url*

        fetching-manifest? (mf/use-state false)

--- a/frontend/src/app/main/ui/workspace/shapes/text/v2_editor.cljs
+++ b/frontend/src/app/main/ui/workspace/shapes/text/v2_editor.cljs
@@ -117,8 +117,7 @@
              (st/emit! (dwt/v2-update-text-shape-content shape-id content
                                                          :update-name? update-name?
                                                          :name generated-name
-                                                          :finalize? true
-                                                          :save-undo? false))))
+                                                          :finalize? true))))

          (let [container-node (mf/ref-val container-ref)]
            (dom/set-style! container-node "opacity" 0)))
@@ -136,21 +135,15 @@
        on-needs-layout
        (fn []
          (when-let [content (content/dom->cljs (dwt/get-editor-root instance))]
-            (st/emit! (dwt/v2-update-text-shape-content shape-id content
-                                                        :update-name? true
-                                                        :save-undo? false)))
+            (st/emit! (dwt/v2-update-text-shape-content shape-id content :update-name? true)))
          ;; FIXME: We need to find a better way to trigger layout changes.
          #_(st/emit!
             (dwt/v2-update-text-shape-position-data shape-id [])))

        on-change
        (fn []
-          (let [is-empty? (dwt/is-empty? instance)
-                save-undo? (not is-empty?)]
-            (when-let [content (content/dom->cljs (dwt/get-editor-root instance))]
-              (st/emit! (dwt/v2-update-text-shape-content shape-id content
-                                                          :update-name? true
-                                                          :save-undo? save-undo?)))))
+          (when-let [content (content/dom->cljs (dwt/get-editor-root instance))]
+            (st/emit! (dwt/v2-update-text-shape-content shape-id content :update-name? true))))

        on-clipboard-change
        (fn [event]
@@ -254,16 +247,16 @@
      :ref container-ref
      :data-testid "text-editor-container"
      :style {:width "var(--editor-container-width)"
-              :height "var(--editor-container-height)"}}
-     ;; We hide the editor when is blurred because otherwise the
-     ;; selection won't let us see the underlying text. Use opacity
-     ;; because display or visibility won't allow to recover focus
-     ;; afterwards.
-
-     ;; IMPORTANT! This is now done through DOM mutations (see
-     ;; on-blur and on-focus) but I keep this for future references.
-     ;; :opacity (when @blurred 0)}}
+              :height "var(--editor-container-height)"}
+      ;; We hide the editor when is blurred because otherwise the
+      ;; selection won't let us see the underlying text. Use opacity
+      ;; because display or visibility won't allow to recover focus
+      ;; afterwards.

+      ;; IMPORTANT! This is now done through DOM mutations (see
+      ;; on-blur and on-focus) but I keep this for future references.
+      ;; :opacity (when @blurred 0)}}
+      }
     [:div
      {:class (dm/str
               "mousetrap "
--- a/frontend/src/app/main/ui/workspace/sidebar/layer_item.cljs
+++ b/frontend/src/app/main/ui/workspace/sidebar/layer_item.cljs
@@ -300,7 +300,7 @@

        on-drop
        (mf/use-fn
-         (mf/deps id objects expanded? selected)
+         (mf/deps id index objects expanded? selected)
         (fn [side _data]
           (let [single? (= (count selected) 1)
                 same?   (and single? (= (first selected) id))]
@@ -321,18 +321,14 @@

                     [parent-id _] (ctn/find-valid-parent-and-frame-ids parent-id objects (map #(get objects %) selected) false files)

-                     parent        (get objects parent-id)
-                     current-index (d/index-of (:shapes parent) id)
+                     parent    (get objects parent-id)

                     to-index  (cond
                                 (= side :center) 0
                                 (and expanded? (= side :bot) (d/not-empty? (:shapes shape))) (count (:shapes parent))
-                                 ;; target not found in parent (while lazy loading)
-                                 (neg? current-index) nil
-                                 (= side :top) (inc current-index)
-                                 :else current-index)]
-                 (when (some? to-index)
-                   (st/emit! (dw/relocate-selected-shapes parent-id to-index))))))))
+                                 (= side :top) (inc index)
+                                 :else index)]
+                 (st/emit! (dw/relocate-selected-shapes parent-id to-index)))))))

        on-hold
        (mf/use-fn
@@ -421,7 +417,11 @@
                current @children-count*
                new-count (min total (max current chunk-size min-count))]
            (reset! children-count* new-count))
-          (reset! children-count* 0))))
+          (reset! children-count* 0)))
+      (fn []
+        (when-let [obs ^js @observer-var]
+          (.disconnect obs)
+          (reset! observer-var nil))))

    ;; Re-observe sentinel whenever children-count changes (sentinel moves)
    ;; and (shapes item) to reconnect observer after shape changes
@@ -502,4 +502,4 @@
                :component-child? component-tree?}])))
        (when (< children-count (count (:shapes item)))
          [:div {:ref lazy-ref
-                 :class (stl/css :lazy-load-sentinel)}])])]))
+                 :style {:min-height 1}}])])]))
--- a/frontend/src/app/main/ui/workspace/sidebar/layer_item.scss
+++ b/frontend/src/app/main/ui/workspace/sidebar/layer_item.scss
@@ -298,11 +298,3 @@
 .filtered {
  min-inline-size: $sz-12;
 }
-.lazy-load-sentinel {
-  min-height: 1px;
-  pointer-events: none;
-}
-.lazy-load-sentinel {
-  min-height: 1px;
-  pointer-events: none;
-}
--- a/frontend/src/app/main/ui/workspace/sidebar/layers.cljs
+++ b/frontend/src/app/main/ui/workspace/sidebar/layers.cljs
@@ -521,7 +521,8 @@
         [:& filters-tree {:objects filtered-objects
                           :key (dm/str (:id page))
                           :parent-size size-parent}]
-         [:div {:ref lazy-load-ref}]]
+         [:div {:ref lazy-load-ref
+                :style {:min-height 16}}]]
        [:div {:on-scroll on-scroll
               :class (stl/css :tool-window-content)
               :data-scroll-container true
--- a/frontend/src/app/main/ui/workspace/sidebar/options/menus/measures.cljs
+++ b/frontend/src/app/main/ui/workspace/sidebar/options/menus/measures.cljs
@@ -541,8 +541,7 @@
              :value (get values :rotation)}]

            [:div {:class (stl/css :rotation)
-                   :title (tr "workspace.options.rotation")
-                   :data-testid "rotation"}
+                   :title (tr "workspace.options.rotation")}
             [:span {:class (stl/css :icon)}  deprecated-icon/rotation]
             [:> deprecated-input/numeric-input*
              {:no-validate true
--- a/frontend/src/app/main/ui/workspace/tokens/management/context_menu.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/context_menu.cljs
@@ -9,7 +9,7 @@
  (:require
   [app.common.data :as d]
   [app.common.data.macros :as dm]
-   [app.common.files.tokens :as cfo]
+   [app.common.files.tokens :as cft]
   [app.common.types.shape.layout :as ctsl]
   [app.common.types.token :as ctt]
   [app.main.data.modal :as modal]
@@ -47,9 +47,9 @@
 ;; Actions ---------------------------------------------------------------------

 (defn attribute-actions [token selected-shapes attributes]
-  (let [ids-by-attributes (cfo/shapes-ids-by-applied-attributes token selected-shapes attributes)
+  (let [ids-by-attributes (cft/shapes-ids-by-applied-attributes token selected-shapes attributes)
        shape-ids (into #{} (map :id selected-shapes))]
-    {:all-selected? (cfo/shapes-applied-all? ids-by-attributes shape-ids attributes)
+    {:all-selected? (cft/shapes-applied-all? ids-by-attributes shape-ids attributes)
     :shape-ids shape-ids
     :selected-pred #(seq (% ids-by-attributes))}))

--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/color.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/color.cljs
@@ -6,25 +6,48 @@

 (ns app.main.ui.workspace.tokens.management.forms.color
  (:require
-   [app.common.files.tokens :as cfo]
+   [app.common.files.tokens :as cft]
   [app.common.schema :as sm]
+   [app.common.types.token :as cto]
   [app.main.ui.workspace.tokens.management.forms.controls :as token.controls]
   [app.main.ui.workspace.tokens.management.forms.generic-form :as generic]
+   [app.util.i18n :refer [tr]]
+   [cuerdas.core :as str]
   [rumext.v2 :as mf]))

-(mf/defc form*
-  [{:keys [token token-type] :as props}]
-  (let [initial
-        (mf/with-memo [token-type token]
-          {:type token-type
-           :name (:name token "")
-           :value (:value token "")
-           :description (:description token "")
-           :color-result ""})
+(defn- token-value-error-fn
+  [{:keys [value]}]
+  (when (or (str/empty? value)
+            (str/blank? value))
+    (tr "workspace.tokens.empty-input")))

-        props (mf/spread-props props {:make-schema #(-> (cfo/make-token-schema %1 token-type)
-                                                        (sm/dissoc-key :id)
-                                                        (sm/assoc-key :color-result :string))
-                                      :initial initial
+(defn- make-schema
+  [tokens-tree _]
+  (sm/schema
+   [:and
+    [:map
+     [:name
+      [:and
+       [:string {:min 1 :max 255 :error/fn #(str (:value %) (tr "workspace.tokens.token-name-length-validation-error"))}]
+       (sm/update-properties cto/token-name-ref assoc :error/fn #(str (:value %) (tr "workspace.tokens.token-name-validation-error")))
+       [:fn {:error/fn #(tr "workspace.tokens.token-name-duplication-validation-error" (:value %))}
+        #(not (cft/token-name-path-exists? % tokens-tree))]]]
+
+     [:value [::sm/text {:error/fn token-value-error-fn}]]
+
+     [:color-result {:optional true} ::sm/any]
+
+     [:description {:optional true}
+      [:string {:max 2048 :error/fn #(tr "errors.field-max-length" 2048)}]]]
+
+    [:fn {:error/field :value
+          :error/fn #(tr "workspace.tokens.self-reference")}
+     (fn [{:keys [name value]}]
+       (when (and name value)
+         (nil? (cto/token-value-self-reference? name value))))]]))
+
+(mf/defc form*
+  [props]
+  (let [props (mf/spread-props props {:make-schema make-schema
                                      :input-component token.controls/color-input*})]
    [:> generic/form* props]))
--- 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
@@ -156,6 +156,7 @@
        color-resolved
        (get-in @form [:data :color-result] "")

+
        valid-color (or (tinycolor/valid-color value)
                        (tinycolor/valid-color color-resolved))

--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/font_family.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/font_family.cljs
@@ -6,8 +6,6 @@

 (ns app.main.ui.workspace.tokens.management.forms.font-family
  (:require
-   [app.common.files.tokens :as cfo]
-   [app.common.schema :as sm]
   [app.common.types.token :as cto]
   [app.main.data.workspace.tokens.errors :as wte]
   [app.main.ui.workspace.tokens.management.forms.controls :as token.controls]
@@ -37,11 +35,6 @@
            {:type token-type}))
        props (mf/spread-props props {:token token
                                      :token-type token-type
-                                      :make-schema #(-> (cfo/make-token-schema %1 token-type)
-                                                        (sm/dissoc-key :id)
-                                                        ;; The value as edited in the form is a simple stirng.
-                                                        ;; It's converted to vector in the validator.
-                                                        (sm/assoc-key :value cfo/schema:token-value-generic))
                                      :validator validate-font-family-token
                                      :input-component token.controls/fonts-combobox*})]
    [:> generic/form* props]))
--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/form_container.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/form_container.cljs
@@ -7,6 +7,7 @@
 (ns app.main.ui.workspace.tokens.management.forms.form-container
  (:require
   [app.common.data :as d]
+   [app.common.files.tokens :as cft]
   [app.common.types.tokens-lib :as ctob]
   [app.main.refs :as refs]
   [app.main.ui.workspace.tokens.management.forms.color :as color]
@@ -27,7 +28,7 @@

        token-path
        (mf/with-memo [token]
-          (ctob/get-token-path token))
+          (cft/token-name->path (:name token)))

        tokens-tree-in-selected-set
        (mf/with-memo [token-path tokens-in-selected-set]
--- 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
@@ -8,8 +8,9 @@
  (:require-macros [app.main.style :as stl])
  (:require
   [app.common.data :as d]
-   [app.common.files.tokens :as cfo]
+   [app.common.files.tokens :as cft]
   [app.common.schema :as sm]
+   [app.common.types.token :as cto]
   [app.common.types.tokens-lib :as ctob]
   [app.main.constants :refer [max-input-length]]
   [app.main.data.helpers :as dh]
@@ -35,6 +36,13 @@
   [cuerdas.core :as str]
   [rumext.v2 :as mf]))

+(defn- token-value-error-fn
+  [{:keys [value]}]
+  (when (or (str/empty? value)
+            (str/blank? value))
+    (tr "workspace.tokens.empty-input")))
+
+
 (defn get-value-for-validator
  [active-tab value value-subfield form-type]

@@ -51,6 +59,29 @@

    value))

+(defn- default-make-schema
+  [tokens-tree _]
+  (sm/schema
+   [:and
+    [:map
+     [:name
+      [:and
+       [:string {:min 1 :max 255 :error/fn #(str (:value %) (tr "workspace.tokens.token-name-length-validation-error"))}]
+       (sm/update-properties cto/token-name-ref assoc :error/fn #(str (:value %) (tr "workspace.tokens.token-name-validation-error")))
+       [:fn {:error/fn #(tr "workspace.tokens.token-name-duplication-validation-error" (:value %))}
+        #(not (cft/token-name-path-exists? % tokens-tree))]]]
+
+     [:value [::sm/text {:error/fn token-value-error-fn}]]
+
+     [:description {:optional true}
+      [:string {:max 2048 :error/fn #(tr "errors.field-max-length" 2048)}]]]
+
+    [:fn {:error/field :value
+          :error/fn #(tr "workspace.tokens.self-reference")}
+     (fn [{:keys [name value]}]
+       (when (and name value)
+         (nil? (cto/token-value-self-reference? name value))))]]))
+
 (mf/defc form*
  [{:keys [token
           validator
@@ -66,12 +97,11 @@
           value-subfield
           input-value-placeholder] :as props}]

-  (let [make-schema     (or make-schema #(-> (cfo/make-token-schema % token-type)
-                                             (sm/dissoc-key :id)))
+  (let [make-schema     (or make-schema default-make-schema)
        input-component (or input-component token.controls/input*)
        validate-token  (or validator default-validate-token)

-        active-tab*     (mf/use-state #(if (cfo/is-reference? token) :reference :composite))
+        active-tab*     (mf/use-state #(if (cft/is-reference? token) :reference :composite))
        active-tab      (deref active-tab*)

        token
@@ -102,10 +132,9 @@
          (make-schema tokens-tree-in-selected-set active-tab))

        initial
-        (mf/with-memo [token initial]
+        (mf/with-memo [token]
          (or initial
-              {:type token-type
-               :name (:name token "")
+              {:name (:name token "")
               :value (:value token "")
               :description (:description token "")}))

--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/shadow.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/shadow.cljs
@@ -8,9 +8,9 @@
  (:require-macros [app.main.style :as stl])
  (:require
   [app.common.data :as d]
+   [app.common.files.tokens :as cft]
   [app.common.schema :as sm]
   [app.common.types.token :as cto]
-   [app.common.types.tokens-lib :as ctob]
   [app.main.data.workspace.tokens.errors :as wte]
   [app.main.ui.ds.buttons.icon-button :refer [icon-button*]]
   [app.main.ui.ds.controls.radio-buttons :refer [radio-buttons*]]
@@ -51,7 +51,7 @@
    ;; Entering form without a value - show no error just resolve nil
    (nil? token-value) (rx/of nil)
    ;; Validate refrence string
-    (cto/composite-token-reference? token-value) (default-validate-token params)
+    (cto/shadow-composite-token-reference? token-value) (default-validate-token params)
    ;; Validate composite token
    :else
    (let [params (-> params
@@ -253,7 +253,6 @@
       [:> reference-form* {:token token
                            :tokens tokens}])]))

-;; TODO: use cfo/make-schema:token-value and extend it with shadow and reference fields
 (defn- make-schema
  [tokens-tree active-tab]
  (sm/schema
@@ -263,10 +262,10 @@
      [:and
       [:string {:min 1 :max 255
                 :error/fn #(str (:value %) (tr "workspace.tokens.token-name-length-validation-error"))}]
-       (sm/update-properties cto/schema:token-name assoc
+       (sm/update-properties cto/token-name-ref assoc
                             :error/fn #(str (:value %) (tr "workspace.tokens.token-name-validation-error")))
       [:fn {:error/fn #(tr "workspace.tokens.token-name-duplication-validation-error" (:value %))}
-        #(not (ctob/token-name-path-exists? % tokens-tree))]]]
+        #(not (cft/token-name-path-exists? % tokens-tree))]]]

     [:value
      [:map
--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/typography.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/typography.cljs
@@ -8,9 +8,9 @@
  (:require-macros [app.main.style :as stl])
  (:require
   [app.common.data :as d]
+   [app.common.files.tokens :as cft]
   [app.common.schema :as sm]
   [app.common.types.token :as cto]
-   [app.common.types.tokens-lib :as ctob]
   [app.main.data.workspace.tokens.errors :as wte]
   [app.main.ui.ds.controls.radio-buttons :refer [radio-buttons*]]
   [app.main.ui.ds.foundations.assets.icon :as i]
@@ -48,7 +48,7 @@
    ;; Entering form without a value - show no error just resolve nil
    (nil? token-value) (rx/of nil)
    ;; Validate refrence string
-    (cto/composite-token-reference? token-value) (default-validate-token props)
+    (cto/typography-composite-token-reference? token-value) (default-validate-token props)
    ;; Validate composite token
    :else
    (-> props
@@ -208,7 +208,6 @@

 ;; SCHEMA

-;; TODO: use cfo/make-schema:token-value and extend it with typography and reference fields
 (defn- make-schema
  [tokens-tree active-tab]
  (sm/schema
@@ -218,10 +217,10 @@
      [:and
       [:string {:min 1 :max 255
                 :error/fn #(str (:value %) (tr "workspace.tokens.token-name-length-validation-error"))}]
-       (sm/update-properties cto/schema:token-name assoc
+       (sm/update-properties cto/token-name-ref assoc
                             :error/fn #(str (:value %) (tr "workspace.tokens.token-name-validation-error")))
       [:fn {:error/fn #(tr "workspace.tokens.token-name-duplication-validation-error" (:value %))}
-        #(not (ctob/token-name-path-exists? % tokens-tree))]]]
+        #(not (cft/token-name-path-exists? % tokens-tree))]]]

     [:value
      [:map
--- a/frontend/src/app/main/ui/workspace/tokens/management/forms/validators.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/forms/validators.cljs
@@ -1,11 +1,13 @@
 (ns app.main.ui.workspace.tokens.management.forms.validators
  (:require
   [app.common.data :as d]
+   [app.common.files.tokens :as cft]
   [app.common.schema :as sm]
   [app.common.types.token :as cto]
   [app.common.types.tokens-lib :as ctob]
   [app.main.data.style-dictionary :as sd]
   [app.main.data.workspace.tokens.errors :as wte]
+   [app.util.i18n :refer [tr]]
   [beicon.v2.core :as rx]
   [cuerdas.core :as str]))

@@ -27,8 +29,7 @@
                ;; When creating a new token we dont have a name yet or invalid name,
                ;; but we still want to resolve the value to show in the form.
                ;; So we use a temporary token name that hopefully doesn't clash with any of the users token names
-                (not (sm/valid? cto/schema:token-name (:name token)))
-                (assoc :name "__PENPOT__TOKEN__NAME__PLACEHOLDER__"))
+                (not (sm/valid? cto/token-name-ref (:name token))) (assoc :name "__PENPOT__TOKEN__NAME__PLACEHOLDER__"))
        tokens' (cond-> tokens
                  ;; Remove previous token when renaming a token
                  (not= (:name token) (:name prev-token))
@@ -88,3 +89,23 @@
  [token-name token-vals]
  (when (some #(cto/token-value-self-reference? token-name %) token-vals)
    (wte/get-error-code :error.token/direct-self-reference)))
+
+
+
+;; This is used in plugins
+
+(defn- make-token-name-schema
+  "Generate a dynamic schema validation to check if a token path derived
+  from the name already exists at `tokens-tree`."
+  [tokens-tree]
+  [:and
+   [:string {:min 1 :max 255 :error/fn #(str (:value %) (tr "workspace.tokens.token-name-length-validation-error"))}]
+   (sm/update-properties cto/token-name-ref assoc :error/fn #(str (:value %) (tr "workspace.tokens.token-name-validation-error")))
+   [:fn {:error/fn #(tr "workspace.tokens.token-name-duplication-validation-error" (:value %))}
+    #(not (cft/token-name-path-exists? % tokens-tree))]])
+
+(defn validate-token-name
+  [tokens-tree name]
+  (let [schema    (make-token-name-schema tokens-tree)
+        explainer (sm/explainer schema)]
+    (-> name explainer sm/simplify not-empty)))
--- a/frontend/src/app/main/ui/workspace/tokens/management/token_pill.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management/token_pill.cljs
@@ -10,7 +10,7 @@
   [app.main.style :as stl])
  (:require
   [app.common.data :as d]
-   [app.common.files.tokens :as cfo]
+   [app.common.files.tokens :as cft]
   [app.common.path-names :as cpn]
   [app.common.types.token :as ctt]
   [app.config :as cf]
@@ -157,9 +157,9 @@

 (defn- applied-all-attributes?
  [token selected-shapes attributes]
-  (let [ids-by-attributes (cfo/shapes-ids-by-applied-attributes token selected-shapes attributes)
+  (let [ids-by-attributes (cft/shapes-ids-by-applied-attributes token selected-shapes attributes)
        shape-ids         (into #{} xf:map-id selected-shapes)]
-    (cfo/shapes-applied-all? ids-by-attributes shape-ids attributes)))
+    (cft/shapes-applied-all? ids-by-attributes shape-ids attributes)))

 (defn attributes-match-selection?
  [selected-shapes attrs & {:keys [selected-inside-layout?]}]
@@ -181,7 +181,7 @@
        resolved-token (get active-theme-tokens (:name token))

        has-selected?  (pos? (count selected-shapes))
-        is-reference?  (cfo/is-reference? token)
+        is-reference?  (cft/is-reference? token)
        contains-path? (str/includes? name ".")

        attributes (as-> (get dwta/token-properties type) $
@@ -194,7 +194,7 @@

        applied?
        (if has-selected?
-          (cfo/shapes-token-applied? token selected-shapes attributes)
+          (cft/shapes-token-applied? token selected-shapes attributes)
          false)

        half-applied?
@@ -224,7 +224,7 @@
            no-valid-value)

        color
-        (when (cfo/color-token? token)
+        (when (cft/color-token? token)
          (or (dwtc/resolved-token-bullet-color resolved-token)
              (dwtc/resolved-token-bullet-color token)))

--- a/frontend/src/app/main/ui/workspace/tokens/sets.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/sets.cljs
@@ -63,8 +63,7 @@
             (st/emit! (dwtl/start-token-set-edition id)))))]

    [:> controlled-sets-list*
-     {:tokens-lib tokens-lib
-      :token-sets token-sets
+     {:token-sets token-sets

      :is-token-set-active token-set-active?
      :is-token-set-group-active token-set-group-active?
@@ -81,6 +80,6 @@

      :on-toggle-token-set on-toggle-token-set-click
      :on-toggle-token-set-group on-toggle-token-set-group-click
-      :on-update-token-set (partial sets-helpers/on-update-token-set tokens-lib)
+      :on-update-token-set sets-helpers/on-update-token-set
      :on-update-token-set-group sets-helpers/on-update-token-set-group
      :on-create-token-set sets-helpers/on-create-token-set}]))
--- a/frontend/src/app/main/ui/workspace/tokens/sets/helpers.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/sets/helpers.cljs
@@ -1,13 +1,9 @@
 (ns app.main.ui.workspace.tokens.sets.helpers
  (:require
-   [app.common.files.tokens :as cfo]
-   [app.common.schema :as sm]
   [app.common.types.tokens-lib :as ctob]
   [app.main.data.event :as ev]
-   [app.main.data.notifications :as ntf]
   [app.main.data.workspace.tokens.library-edit :as dwtl]
   [app.main.store :as st]
-   [app.util.i18n :refer [tr]]
   [potok.v2.core :as ptk]))

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -15,18 +11,9 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 (defn on-update-token-set
-  [tokens-lib token-set name]
-  (let [name   (ctob/normalize-set-name name (ctob/get-name token-set))
-        errors (sm/validation-errors name (cfo/make-token-set-name-schema
-                                           tokens-lib
-                                           (ctob/get-id token-set)))]
-    (st/emit! (dwtl/clear-token-set-edition))
-    (if (empty? errors)
-      (st/emit! (dwtl/rename-token-set token-set name))
-      (st/emit! (ntf/show {:content (tr "errors.token-set-already-exists")
-                           :type :toast
-                           :level :error
-                           :timeout 9000})))))
+  [token-set name]
+  (st/emit! (dwtl/clear-token-set-edition)
+            (dwtl/update-token-set token-set name)))

 (defn on-update-token-set-group
  [path name]
@@ -34,15 +21,15 @@
            (dwtl/rename-token-set-group path name)))

 (defn on-create-token-set
-  [tokens-lib parent-set name]
-  (let [name   (ctob/make-child-name parent-set name)
-        errors (sm/validation-errors name (cfo/make-token-set-name-schema tokens-lib nil))]
+  [parent-set name]
+  (let [;; FIXME: this code should be reusable under helper under
+        ;; common types namespace
+        name
+        (if-let [parent-path (ctob/get-set-path parent-set)]
+          (->> (concat parent-path (ctob/split-set-name name))
+               (ctob/join-set-path))
+          (ctob/normalize-set-name name))
+        token-set (ctob/make-token-set :name name)]
+
    (st/emit! (ptk/data-event ::ev/event {::ev/name "create-token-set" :name name})
-              (dwtl/clear-token-set-creation))
-    (if (empty? errors)
-      (let [token-set (ctob/make-token-set :name name)]
-        (st/emit! (dwtl/create-token-set token-set)))
-      (st/emit! (ntf/show {:content (tr "errors.token-set-already-exists")
-                           :type :toast
-                           :level :error
-                           :timeout 9000})))))
+              (dwtl/create-token-set token-set))))
--- a/frontend/src/app/main/ui/workspace/tokens/sets/lists.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/sets/lists.cljs
@@ -321,7 +321,6 @@
           on-select
           on-toggle-set
           on-toggle-set-group
-           tokens-lib
           token-sets
           new-path
           edition-id]}]
@@ -409,7 +408,7 @@

            :on-drop on-drop
            :on-reset-edition on-reset-edition
-            :on-edit-submit (partial sets-helpers/on-create-token-set tokens-lib)}]
+            :on-edit-submit sets-helpers/on-create-token-set}]

          :else
          [:> sets-tree-set*
@@ -435,8 +434,7 @@
            :on-edit-submit on-edit-submit-set}])))))

 (mf/defc controlled-sets-list*
-  [{:keys [tokens-lib
-           token-sets
+  [{:keys [token-sets
           selected
           on-update-token-set
           on-update-token-set-group
@@ -488,7 +486,6 @@
        {:is-draggable draggable?
         :new-path new-path
         :edition-id edition-id
-         :tokens-lib tokens-lib
         :token-sets token-sets
         :selected selected
         :on-select on-select
--- a/frontend/src/app/main/ui/workspace/tokens/themes/create_modal.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/themes/create_modal.cljs
@@ -7,11 +7,8 @@
 (ns app.main.ui.workspace.tokens.themes.create-modal
  (:require-macros [app.main.style :as stl])
  (:require
-   [app.common.data :as d]
   [app.common.data.macros :as dm]
-   [app.common.files.tokens :as cfo]
   [app.common.logic.tokens :as clt]
-   [app.common.schema :as sm]
   [app.common.types.tokens-lib :as ctob]
   [app.main.constants :refer [max-input-length]]
   [app.main.data.event :as ev]
@@ -33,9 +30,32 @@
   [app.util.i18n :refer [tr]]
   [app.util.keyboard :as k]
   [cuerdas.core :as str]
+   [malli.core :as m]
+   [malli.error :as me]
   [potok.v2.core :as ptk]
   [rumext.v2 :as mf]))

+;; Schemas ---------------------------------------------------------------------
+
+(defn- theme-name-schema
+  "Generate a dynamic schema validation to check if a theme path derived from the name already exists at `tokens-tree`."
+  [{:keys [group theme-id tokens-lib]}]
+  (m/-simple-schema
+   {:type :token/name-exists
+    :pred (fn [name]
+            (if tokens-lib
+              (let [theme (ctob/get-theme-by-name tokens-lib group name)]
+                (or (nil? theme)
+                    (= (ctob/get-id theme) theme-id)))
+              true))  ;; if still no library exists, cannot be duplicate
+    :type-properties {:error/fn #(tr "workspace.tokens.theme-name-already-exists")}}))
+
+(defn validate-theme-name
+  [tokens-lib group theme-id name]
+  (let [schema     (theme-name-schema {:tokens-lib tokens-lib :theme-id theme-id :group group})
+        validation (m/explain schema (str/trim name))]
+    (me/humanize validation)))
+
 ;; Form Component --------------------------------------------------------------

 (mf/defc empty-themes
@@ -161,43 +181,26 @@
                            theme-groups)
        current-group* (mf/use-state (:group theme))
        current-group  (deref current-group*)
-        current-name*  (mf/use-state (:name theme))
-        current-name   (deref current-name*)
-        group-errors*  (mf/use-state nil)
-        group-errors   (deref group-errors*)
        name-errors*   (mf/use-state nil)
        name-errors    (deref name-errors*)

        on-update-group
        (mf/use-fn
-         (mf/deps on-change-field tokens-lib current-name)
+         (mf/deps on-change-field)
         (fn [value]
-           (let [errors (sm/validation-errors value (cfo/make-token-theme-group-schema
-                                                     tokens-lib
-                                                     current-name
-                                                     (ctob/get-id theme)))]
-             (reset! group-errors* errors)
-             (if (empty? errors)
-               (do
-                 (reset! current-group* value)
-                 (on-change-field :group value))
-               (on-change-field :group "")))))
+           (reset! current-group* value)
+           (on-change-field :group value)))

        on-update-name
        (mf/use-fn
         (mf/deps on-change-field tokens-lib current-group)
         (fn [event]
           (let [value  (-> event dom/get-target dom/get-value)
-                 errors (sm/validation-errors value (cfo/make-token-theme-name-schema
-                                                     tokens-lib
-                                                     current-group
-                                                     (ctob/get-id theme)))]
+                 errors (validate-theme-name tokens-lib current-group (ctob/get-id theme) value)]
             (reset! name-errors* errors)
             (mf/set-ref-val! theme-name-ref value)
             (if (empty? errors)
-               (do
-                 (reset! current-name* value)
-                 (on-change-field :name value))
+               (on-change-field :name value)
               (on-change-field :name "")))))]

    [:div {:class (stl/css :edit-theme-inputs-wrapper)}
@@ -207,7 +210,6 @@
                     :placeholder (tr "workspace.tokens.label.group-placeholder")
                     :default-selected (:group theme)
                     :options (clj->js options)
-                     :has-error (d/not-empty? group-errors)
                     :on-change on-update-group}]]

     [:div {:class (stl/css :group-input-wrapper)}
@@ -260,7 +262,6 @@
 (mf/defc edit-create-theme*
  [{:keys [change-view theme on-save is-editing has-prev-view]}]
  (let [ordered-token-sets (mf/deref refs/workspace-ordered-token-sets)
-        tokens-lib (mf/deref refs/tokens-lib)
        token-sets (mf/deref refs/workspace-token-sets-tree)

        current-theme* (mf/use-state theme)
@@ -362,8 +363,7 @@
       [:div {:class (stl/css :sets-list-wrapper)}

        [:> wts/controlled-sets-list*
-         {:tokens-lib tokens-lib
-          :token-sets token-sets
+         {:token-sets token-sets
          :is-token-set-active token-set-active?
          :is-token-set-group-active token-set-group-active?
          :on-select on-click-token-set
--- a/frontend/src/app/main/ui/workspace/viewport/utils.cljs
+++ b/frontend/src/app/main/ui/workspace/viewport/utils.cljs
@@ -75,31 +75,32 @@
  [{:keys [points] :as shape} zoom grid-edition?]
  (let [leftmost  (->> points (reduce left?))
        topmost   (->> points (remove #{leftmost}) (reduce top?))
-        rightmost (->> points (remove #{leftmost topmost}) (reduce right?))]
-    (when (and (some? leftmost) (some? topmost) (some? rightmost))
-      (let [left-top (gpt/to-vec leftmost topmost)
-            left-top-angle (gpt/angle left-top)
+        rightmost (->> points (remove #{leftmost topmost}) (reduce right?))

-            top-right (gpt/to-vec topmost rightmost)
-            top-right-angle (gpt/angle top-right)
+        left-top (gpt/to-vec leftmost topmost)
+        left-top-angle (gpt/angle left-top)

-            ;; Choose the position that creates the less angle between left-side and top-side
-            [label-pos angle h-pos v-pos]
-            (if (< (mth/abs left-top-angle) (mth/abs top-right-angle))
-              [leftmost left-top-angle left-top (gpt/perpendicular left-top)]
-              [topmost top-right-angle top-right (gpt/perpendicular top-right)])
+        top-right (gpt/to-vec topmost rightmost)
+        top-right-angle (gpt/angle top-right)

-            delta-x (if grid-edition? 40 0)
-            delta-y (if grid-edition? 50 10)
+        ;; Choose the position that creates the less angle between left-side and top-side
+        [label-pos angle h-pos v-pos]
+        (if (< (mth/abs left-top-angle) (mth/abs top-right-angle))
+          [leftmost left-top-angle left-top (gpt/perpendicular left-top)]
+          [topmost top-right-angle top-right (gpt/perpendicular top-right)])

-            label-pos
-            (-> label-pos
-                (gpt/subtract (gpt/scale (gpt/unit v-pos) (/ delta-y zoom)))
-                (gpt/subtract (gpt/scale (gpt/unit h-pos) (/ delta-x zoom))))]
-        (dm/fmt "rotate(% %,%) scale(%, %) translate(%, %)"
-                ;; rotate
-                angle (:x label-pos) (:y label-pos)
-                ;; scale
-                (/ 1 zoom) (/ 1 zoom)
-                ;; translate
-                (* zoom (:x label-pos)) (* zoom (:y label-pos)))))))
+        delta-x (if grid-edition? 40 0)
+        delta-y (if grid-edition? 50 10)
+
+        label-pos
+        (-> label-pos
+            (gpt/subtract (gpt/scale (gpt/unit v-pos) (/ delta-y zoom)))
+            (gpt/subtract (gpt/scale (gpt/unit h-pos) (/ delta-x zoom))))]
+
+    (dm/fmt "rotate(% %,%) scale(%, %) translate(%, %)"
+            ;; rotate
+            angle (:x label-pos) (:y label-pos)
+            ;; scale
+            (/ 1 zoom) (/ 1 zoom)
+            ;; translate
+            (* zoom (:x label-pos)) (* zoom (:y label-pos)))))
--- a/frontend/src/app/main/ui/workspace/viewport_wasm.cljs
+++ b/frontend/src/app/main/ui/workspace/viewport_wasm.cljs
@@ -705,8 +705,8 @@
          [:& grid-layout/editor
           {:zoom zoom
            :objects objects-modified
-            :shape (or (get objects-modified edition)
-                       (get objects-modified @hover-top-frame-id))
+            :shape (or (get base-objects edition)
+                       (get base-objects @hover-top-frame-id))
            :view-only (not show-grid-editor?)}])]

       [:g.scrollbar-wrapper {:clipPath "url(#clip-handlers)"}
--- a/frontend/src/app/plugins/api.cljs
+++ b/frontend/src/app/plugins/api.cljs
@@ -26,7 +26,6 @@
   [app.main.data.workspace.groups :as dwg]
   [app.main.data.workspace.media :as dwm]
   [app.main.data.workspace.selection :as dws]
-   [app.main.data.workspace.wasm-text :as dwwt]
   [app.main.fonts :refer [fetch-font-css]]
   [app.main.router :as rt]
   [app.main.store :as st]
@@ -349,14 +348,9 @@

        :else
        (let [page  (dsh/lookup-page @st/state)
-              shape (-> (cts/setup-shape {:type :text
-                                          :x 0 :y 0
-                                          :width 1 :height 1
-                                          :grow-type :auto-width})
-                        (update :content txt/change-text text
-                                ;; Text should be given a color by default
-                                {:fills [{:fill-color "#000000" :fill-opacity 1}]})
-                        (dissoc :position-data))
+              shape (-> (cts/setup-shape {:type :text :x 0 :y 0 :grow-type :auto-width})
+                        (update :content txt/change-text text)
+                        (assoc :position-data nil))

              changes
              (-> (cb/empty-changes)
@@ -364,10 +358,9 @@
                  (cb/with-objects (:objects page))
                  (cb/add-object shape))]

-          (st/emit! (ch/commit-changes changes)
-                    (se/event plugin-id "create-shape" :type :text)
-                    (dwwt/resize-wasm-text-debounce (:id shape)))
-
+          (st/emit!
+           (ch/commit-changes changes)
+           (se/event plugin-id "create-shape" :type :text))
          (shape/shape-proxy plugin-id (:id shape)))))

    :createShapeFromSvg
--- a/frontend/src/app/plugins/register.cljs
+++ b/frontend/src/app/plugins/register.cljs
@@ -38,7 +38,6 @@
        desc (obj/get manifest "description")
        code (obj/get manifest "code")
        icon (obj/get manifest "icon")
-        vers (d/nilv (obj/get manifest "version") 1)

        permissions (into #{} (obj/get manifest "permissions" []))
        permissions
@@ -56,13 +55,9 @@
        (u/uri plugin-url)

        origin
-        (if (= vers 1)
-          (-> plugin-url
-              (assoc :path "/")
-              (str))
-          (-> plugin-url
-              (u/join ".")
-              (str)))
+        (-> plugin-url
+            (u/join ".")
+            (str))

        prev-plugin
        (->> (:data @registry)
--- a/Show More
+++ b/Show More