♻️ Sanitize heap write and read operations

Mainly improves the offset management making it less
error prone, encapsulating the write operation and offeset
management into write-* operations with proper asserts
for the expected heap type.

common/src/app/common/types/path/impl.cljc

@@ -29,6 +29,7 @@
 #?(:clj (set! *warn-on-reflection* true))
 
 (def ^:const SEGMENT-U8-SIZE 28)
+(def ^:const SEGMENT-U32-SIZE (/ SEGMENT-U8-SIZE 4))
 
 (defprotocol IPathData
   (-write-to [_ buffer offset] "write the content to the specified buffer")

frontend/src/app/main/data/workspace/modifiers.cljs

@@ -530,25 +530,24 @@
                   nil)))))))
    modif-tree))
 
+
+(def ^:private xf:parse-geometry-modifier
+  (let [default-transform (gmt/matrix)]
+    (keep (fn [[id data]]
+            (cond
+              (= id uuid/zero)
+              nil
+
+              (ctm/has-geometry? (:modifiers data))
+              (d/vec2 id (ctm/modifiers->transform (:modifiers data)))
+
+              ;; Unit matrix is used for reflowing
+              :else
+              (d/vec2 id default-transform))))))
+
 (defn- parse-geometry-modifiers
   [modif-tree]
-  (into
-   []
-   (keep
-    (fn [[id data]]
-      (cond
-        (= id uuid/zero)
-        nil
-
-        (ctm/has-geometry? (:modifiers data))
-        {:id id
-         :transform (ctm/modifiers->transform (:modifiers data))}
-
-        ;; Unit matrix is used for reflowing
-        :else
-        {:id id
-         :transform (gmt/matrix)})))
-   modif-tree))
+  (into [] xf:parse-geometry-modifier modif-tree))
 
 (defn- extract-property-changes
   [modif-tree]
@@ -573,6 +572,8 @@
     (update [_ state]
       (assoc state :workspace-wasm-modifiers modifiers))))
 
+(def ^:private xf:map-key (map key))
+
 #_:clj-kondo/ignore
 (defn set-wasm-modifiers
   [modif-tree & {:keys [ignore-constraints ignore-snap-pixel]
@@ -591,16 +592,17 @@
     (watch [_ state _]
       (wasm.api/clean-modifiers)
       (let [prev-wasm-props (:prev-wasm-props state)
-            wasm-props (:wasm-props state)
-            objects (dsh/lookup-page-objects state)
+            wasm-props      (:wasm-props state)
+            objects         (dsh/lookup-page-objects state)
             pixel-precision false]
         (set-wasm-props! objects prev-wasm-props wasm-props)
         (let [structure-entries (parse-structure-modifiers modif-tree)]
           (wasm.api/set-structure-modifiers structure-entries)
           (let [geometry-entries (parse-geometry-modifiers modif-tree)
-                modifiers (wasm.api/propagate-modifiers geometry-entries pixel-precision)]
+                modifiers        (wasm.api/propagate-modifiers geometry-entries pixel-precision)]
             (wasm.api/set-modifiers modifiers)
-            (let [selrect (wasm.api/get-selection-rect (->> geometry-entries (map :id)))]
+            (let [ids     (into [] xf:map-key geometry-entries)
+                  selrect (wasm.api/get-selection-rect ids)]
               (rx/of (set-temporary-selrect selrect)
                      (set-temporary-modifiers modifiers)))))))))
 
@@ -649,16 +651,14 @@
                 ;; way we don't have to check all the attributes
                 (assoc :attrs transform-attrs))
 
-            geometry-entries (parse-geometry-modifiers modif-tree)
+            geometry-entries
+            (parse-geometry-modifiers modif-tree)
 
             snap-pixel?
             (and (not ignore-snap-pixel) (contains? (:workspace-layout state) :snap-pixel-grid))
 
             transforms
-            (into
-             {}
-             (map (fn [{:keys [id transform]}] [id transform]))
-             (wasm.api/propagate-modifiers geometry-entries snap-pixel?))
+            (into {} (wasm.api/propagate-modifiers geometry-entries snap-pixel?))
 
             modif-tree
             (propagate-structure-modifiers modif-tree (dsh/lookup-page-objects state))
@@ -709,10 +709,9 @@
                  (gm/set-objects-modifiers objects))
 
              modifiers
-             (->> modif-tree
-                  (map (fn [[id {:keys [modifiers]}]]
-                         {:id id
-                          :transform (ctm/modifiers->transform modifiers)})))]
+             (mapv (fn [[id {:keys [modifiers]}]]
+                     (d/vec2 id (ctm/modifiers->transform modifiers)))
+                   modif-tree)]
 
          (wasm.api/set-modifiers modifiers))))))
 

frontend/src/app/render_wasm/api.cljs

@@ -10,8 +10,6 @@
    ["react-dom/server" :as rds]
    [app.common.data :as d :refer [not-empty?]]
    [app.common.data.macros :as dm]
-   [app.common.geom.matrix :as gmt]
-   [app.common.geom.point :as gpt]
    [app.common.types.fills :as types.fills]
    [app.common.types.fills.impl :as types.fills.impl]
    [app.common.types.path :as path]
@@ -41,39 +39,17 @@
 
 (def use-dpr? (contains? cf/flags :render-wasm-dpr))
 
-;;
-;; List of common entry sizes.
-;;
-;; All of these entries are in bytes so we need to adjust
-;; these values to work with TypedArrays of 32 bits.
-;;
 (def ^:const UUID-U8-SIZE 16)
 (def ^:const UUID-U32-SIZE (/ UUID-U8-SIZE 4))
 
 (def ^:const MODIFIER-U8-SIZE 40)
+(def ^:const MODIFIER-U32-SIZE (/ MODIFIER-U8-SIZE 4))
 (def ^:const MODIFIER-TRANSFORM-U8-OFFSET-SIZE 16)
 
 (def ^:const GRID-LAYOUT-ROW-U8-SIZE 5)
 (def ^:const GRID-LAYOUT-COLUMN-U8-SIZE 5)
 (def ^:const GRID-LAYOUT-CELL-U8-SIZE 37)
 
-(defn modifier-get-entries-size
-  "Returns the list of a modifier list in bytes"
-  [modifiers]
-  (mem/get-list-size modifiers MODIFIER-U8-SIZE))
-
-(defn grid-layout-get-row-entries-size
-  [rows]
-  (mem/get-list-size rows GRID-LAYOUT-ROW-U8-SIZE))
-
-(defn grid-layout-get-column-entries-size
-  [columns]
-  (mem/get-list-size columns GRID-LAYOUT-COLUMN-U8-SIZE))
-
-(defn grid-layout-get-cell-entries-size
-  [cells]
-  (mem/get-list-size cells GRID-LAYOUT-CELL-U8-SIZE))
-
 (def dpr
   (if use-dpr? (if (exists? js/window) js/window.devicePixelRatio 1.0) 1.0))
 
@@ -172,20 +148,20 @@
 
 (defn set-shape-children
   [children]
-  (let [heap   (mem/get-heap-u32)
-        length (count children)]
-    (perf/begin-measure "set-shape-children")
-    (when (pos? length)
-      (let [offset (mem/alloc->offset-32 (* UUID-U8-SIZE length))]
-        (reduce (fn [offset id]
-                  (sr/heapu32-set-uuid id heap offset)
-                  (+ offset UUID-U32-SIZE))
-                offset
-                children)))
 
-    (let [result (h/call wasm/internal-module "_set_children")]
-      (perf/end-measure "set-shape-children")
-      result)))
+  (when-not ^boolean (empty? children)
+    (perf/begin-measure "set-shape-children")
+    (let [heap   (mem/get-heap-u32)
+          size   (mem/get-alloc-size children UUID-U8-SIZE)
+          offset (mem/alloc->offset-32 size)]
+      (reduce (fn [offset id]
+                (sr/write-uuid offset heap id))
+              offset
+              children)
+
+      (let [result (h/call wasm/internal-module "_set_children")]
+        (perf/end-measure "set-shape-children")
+        result))))
 
 (defn- get-string-length
   [string]
@@ -467,14 +443,11 @@
 
 (defn set-grid-layout-rows
   [entries]
-  (let [size (grid-layout-get-row-entries-size entries)
+  (let [size   (mem/get-alloc-size entries GRID-LAYOUT-ROW-U8-SIZE)
         offset (mem/alloc size)
+        heap   (-> (mem/get-heap-u8)
+                   (mem/view offset size))]
 
-        heap
-        (js/Uint8Array.
-         (.-buffer (mem/get-heap-u8))
-         offset
-         size)]
     (loop [entries (seq entries)
            current-offset  0]
       (when-not (empty? entries)
@@ -486,14 +459,11 @@
 
 (defn set-grid-layout-columns
   [entries]
-  (let [size (grid-layout-get-column-entries-size entries)
+  (let [size   (mem/get-alloc-size entries GRID-LAYOUT-COLUMN-U8-SIZE)
         offset (mem/alloc size)
+        heap   (-> (mem/get-heap-u8)
+                   (mem/view offset size))]
 
-        heap
-        (js/Uint8Array.
-         (.-buffer (mem/get-heap-u8))
-         offset
-         size)]
     (loop [entries (seq entries)
            current-offset  0]
       (when-not (empty? entries)
@@ -506,14 +476,10 @@
 (defn set-grid-layout-cells
   [cells]
   (let [entries (vals cells)
-        size (grid-layout-get-cell-entries-size entries)
-        offset (mem/alloc size)
-
-        heap
-        (js/Uint8Array.
-         (.-buffer (mem/get-heap-u8))
-         offset
-         size)]
+        size    (mem/get-alloc-size entries GRID-LAYOUT-CELL-U8-SIZE)
+        offset  (mem/alloc size)
+        heap    (-> (mem/get-heap-u8)
+                    (mem/view offset size))]
 
     (loop [entries (seq entries)
            current-offset  0]
@@ -625,7 +591,7 @@
           (h/call wasm/internal-module "_add_shape_shadow" rgba blur spread x y (sr/translate-shadow-style style) hidden)
           (recur (inc index)))))))
 
-(declare propagate-apply)
+;; (declare propagate-apply)
 
 (defn set-shape-text-content
   [shape-id content]
@@ -824,134 +790,90 @@
 
 (defn set-focus-mode
   [entries]
-  (let [offset (mem/alloc->offset-32 (* (count entries) 16))
-        heapu32 (mem/get-heap-u32)]
+  (when-not ^boolean (empty? entries)
+    (let [size   (mem/get-alloc-size entries UUID-U8-SIZE)
+          heap   (mem/get-heap-u32)
+          offset (mem/alloc->offset-32 size)]
 
-    (loop [entries (seq entries)
-           current-offset  offset]
-      (when-not (empty? entries)
-        (let [id (first entries)]
-          (sr/heapu32-set-uuid id heapu32 current-offset)
-          (recur (rest entries) (+ current-offset (mem/->offset-32 16))))))
+      (reduce (fn [offset id]
+                (sr/write-uuid offset heap id))
+              offset
+              entries)
 
-    (h/call wasm/internal-module "_set_focus_mode")
-    (clear-drawing-cache)
-    (request-render "set-focus-mode")))
+      (h/call wasm/internal-module "_set_focus_mode")
+      (clear-drawing-cache)
+      (request-render "set-focus-mode"))))
 
 (defn set-structure-modifiers
   [entries]
-  (when-not (empty? entries)
-    (let [offset (mem/alloc->offset-32 (mem/get-list-size entries 44))
+  (when-not ^boolean (empty? entries)
+    (let [size    (mem/get-alloc-size entries 44)
+          offset  (mem/alloc->offset-32 size)
           heapu32 (mem/get-heap-u32)
           heapf32 (mem/get-heap-f32)]
-      (loop [entries (seq entries)
-             current-offset  offset]
-        (when-not (empty? entries)
-          (let [{:keys [type parent id index value] :as entry} (first entries)]
-            (sr/heapu32-set-u32 (sr/translate-structure-modifier-type type) heapu32 (+ current-offset 0))
-            (sr/heapu32-set-u32 (or index 0) heapu32 (+ current-offset 1))
-            (sr/heapu32-set-uuid parent heapu32 (+ current-offset 2))
-            (sr/heapu32-set-uuid id heapu32 (+ current-offset 6))
-            (aset heapf32 (+ current-offset 10) value)
-            (recur (rest entries) (+ current-offset 11)))))
+
+
+      (reduce (fn [offset {:keys [type parent id index value]}]
+                (-> offset
+                    (sr/write-u32 heapu32 (sr/translate-structure-modifier-type type))
+                    (sr/write-u32 heapu32 (d/nilv index 0))
+                    (sr/write-uuid heapu32 parent)
+                    (sr/write-uuid heapu32 id)
+                    (sr/write-f32 heapf32 value)))
+              offset
+              entries)
+
       (h/call wasm/internal-module "_set_structure_modifiers"))))
 
 (defn propagate-modifiers
   [entries pixel-precision]
-  (when (d/not-empty? entries)
-    (let [offset  (mem/alloc->offset-32 (modifier-get-entries-size entries))
-          heapf32 (mem/get-heap-f32)
-          heapu32 (mem/get-heap-u32)]
+  (when-not ^boolean (empty? entries)
+    (let [heapf32 (mem/get-heap-f32)
+          heapu32 (mem/get-heap-u32)
+          size    (mem/get-alloc-size entries MODIFIER-U8-SIZE)
+          offset  (mem/alloc->offset-32 size)]
 
-      (loop [entries (seq entries)
-             current-offset  offset]
-        (when-not (empty? entries)
-          (let [{:keys [id transform]} (first entries)]
-            (sr/heapu32-set-uuid id heapu32 current-offset)
-            (sr/heapf32-set-matrix transform heapf32 (+ current-offset (mem/->offset-32 MODIFIER-TRANSFORM-U8-OFFSET-SIZE)))
-            (recur (rest entries) (+ current-offset (mem/->offset-32 MODIFIER-U8-SIZE))))))
+      (reduce (fn [offset [id transform]]
+                (-> offset
+                    (sr/write-uuid heapu32 id)
+                    (sr/write-matrix heapf32 transform)))
+              offset
+              entries)
+
+      (let [offset     (-> (h/call wasm/internal-module "_propagate_modifiers" pixel-precision)
+                           (mem/->offset-32))
+            length     (aget heapu32 offset)
+            max-offset (+ offset 1 (* length MODIFIER-U32-SIZE))
+            result     (loop [result (transient [])
+                              offset (inc offset)]
+                         (if (< offset max-offset)
+                           (let [entry (dr/read-modifier-entry heapu32 heapf32 offset)]
+                             (recur (conj! result entry)
+                                    (+ offset MODIFIER-U32-SIZE)))
+                           (persistent! result)))]
 
-      (let [result-offset (h/call wasm/internal-module "_propagate_modifiers" pixel-precision)
-            heapf32 (mem/get-heap-f32)
-            heapu32 (mem/get-heap-u32)
-            len (aget heapu32 (mem/->offset-32 result-offset))
-            result
-            (->> (range 0 len)
-                 (mapv #(dr/heap32->entry heapu32 heapf32 (mem/->offset-32 (+ result-offset 4 (* % MODIFIER-U8-SIZE))))))]
         (mem/free)
-
         result))))
 
-(defn propagate-apply
-  [entries pixel-precision]
-  (when (d/not-empty? entries)
-    (let [offset (mem/alloc->offset-32 (modifier-get-entries-size entries))
-          heapf32 (mem/get-heap-f32)
-          heapu32 (mem/get-heap-u32)]
-
-      (loop [entries (seq entries)
-             current-offset  offset]
-        (when-not (empty? entries)
-          (let [{:keys [id transform]} (first entries)]
-            (sr/heapu32-set-uuid id heapu32 current-offset)
-            (sr/heapf32-set-matrix transform heapf32 (+ current-offset (mem/->offset-32 MODIFIER-TRANSFORM-U8-OFFSET-SIZE)))
-            (recur (rest entries) (+ current-offset (mem/->offset-32 MODIFIER-U8-SIZE))))))
-
-      (let [offset (h/call wasm/internal-module "_propagate_apply" pixel-precision)
-            heapf32 (mem/get-heap-f32)
-            width (aget heapf32 (mem/->offset-32 (+ offset 0)))
-            height (aget heapf32 (mem/->offset-32 (+ offset 4)))
-            cx (aget heapf32 (mem/->offset-32 (+ offset 8)))
-            cy (aget heapf32 (mem/->offset-32 (+ offset 12)))
-
-            a (aget heapf32 (mem/->offset-32 (+ offset 16)))
-            b (aget heapf32 (mem/->offset-32 (+ offset 20)))
-            c (aget heapf32 (mem/->offset-32 (+ offset 24)))
-            d (aget heapf32 (mem/->offset-32 (+ offset 28)))
-            e (aget heapf32 (mem/->offset-32 (+ offset 32)))
-            f (aget heapf32 (mem/->offset-32 (+ offset 36)))
-            transform (gmt/matrix a b c d e f)]
-
-        (mem/free)
-        (request-render "set-modifiers")
-
-        {:width width
-         :height height
-         :center (gpt/point cx cy)
-         :transform transform}))))
-
 (defn get-selection-rect
   [entries]
-  (when (d/not-empty? entries)
-    (let [offset (mem/alloc->offset-32 (* (count entries) 16))
-          heapu32 (mem/get-heap-u32)]
 
-      (loop [entries (seq entries)
-             current-offset  offset]
-        (when-not (empty? entries)
-          (let [id (first entries)]
-            (sr/heapu32-set-uuid id heapu32 current-offset)
-            (recur (rest entries) (+ current-offset (mem/->offset-32 16))))))
+  (when-not ^boolean (empty? entries)
+    (let [size    (mem/get-alloc-size entries UUID-U8-SIZE)
+          offset  (mem/alloc->offset-32 size)
+          heapu32 (mem/get-heap-u32)
+          heapf32 (mem/get-heap-f32)]
 
-      (let [offset (h/call wasm/internal-module "_get_selection_rect")
-            heap   (mem/get-heap-f32)
-            width  (aget heap (mem/->offset-32 (+ offset 0)))
-            height (aget heap (mem/->offset-32 (+ offset 4)))
-            cx     (aget heap (mem/->offset-32 (+ offset 8)))
-            cy     (aget heap (mem/->offset-32 (+ offset 12)))
-            a      (aget heap (mem/->offset-32 (+ offset 16)))
-            b      (aget heap (mem/->offset-32 (+ offset 20)))
-            c      (aget heap (mem/->offset-32 (+ offset 24)))
-            d      (aget heap (mem/->offset-32 (+ offset 28)))
-            e      (aget heap (mem/->offset-32 (+ offset 32)))
-            f      (aget heap (mem/->offset-32 (+ offset 36)))]
+      (reduce (fn [offset id]
+                (sr/write-uuid offset heapu32 id))
+              offset
+              entries)
 
+      (let [offset (-> (h/call wasm/internal-module "_get_selection_rect")
+                       (mem/->offset-32))
+            result (dr/read-selection-rect heapf32 offset)]
         (mem/free)
-        {:width width
-         :height height
-         :center (gpt/point cx cy)
-         :transform (gmt/matrix a b c d e f)}))))
-
+        result))))
 
 (defn set-canvas-background
   [background]
@@ -965,22 +887,26 @@
 
 (defn set-modifiers
   [modifiers]
-  (when-not (empty? modifiers)
-    (let [offset (mem/alloc->offset-32 (* MODIFIER-U8-SIZE (count modifiers)))
-          heapu32 (mem/get-heap-u32)
-          heapf32 (mem/get-heap-f32)]
 
-      (loop [entries (seq modifiers)
-             current-offset  offset]
-        (when-not (empty? entries)
-          (let [{:keys [id transform]} (first entries)]
-            (sr/heapu32-set-uuid id heapu32 current-offset)
-            (sr/heapf32-set-matrix transform heapf32 (+ current-offset (mem/->offset-32 MODIFIER-TRANSFORM-U8-OFFSET-SIZE)))
-            (recur (rest entries) (+ current-offset (mem/->offset-32 MODIFIER-U8-SIZE))))))
+  ;; We need to ensure efficient operations
+  (assert (vector? modifiers) "expected a vector for `set-modifiers`")
 
-      (h/call wasm/internal-module "_set_modifiers")
+  (let [length (count modifiers)]
+    (when (pos? length)
+      (let [offset  (mem/alloc->offset-32 (* MODIFIER-U8-SIZE length))
+            heapu32 (mem/get-heap-u32)
+            heapf32 (mem/get-heap-f32)]
 
-      (request-render "set-modifiers"))))
+        (reduce (fn [offset [id transform]]
+                  (-> offset
+                      (sr/write-uuid heapu32 id)
+                      (sr/write-matrix heapf32 transform)))
+                offset
+                modifiers)
+
+        (h/call wasm/internal-module "_set_modifiers")
+
+        (request-render "set-modifiers")))))
 
 (defn initialize
   [base-objects zoom vbox background]
@@ -1062,41 +988,42 @@
 (defn shape-to-path
   [id]
   (use-shape id)
-  (let [offset  (h/call wasm/internal-module "_current_to_path")
-        offset  (mem/->offset-32 offset)
-        heapu32 (mem/get-heap-u32)
-
-        length  (aget heapu32 offset)
-        data    (mem/slice heapu32
-                           (+ offset 1)
-                           (+ offset 1 (* length (/ path.impl/SEGMENT-U8-SIZE 4))))
+  (let [offset (-> (h/call wasm/internal-module "_current_to_path")
+                   (mem/->offset-32))
+        heap   (mem/get-heap-u32)
+        length (aget heap offset)
+        data   (mem/slice heap
+                          (+ offset 1)
+                          (* length path.impl/SEGMENT-U32-SIZE))
         content (path/from-bytes data)]
     (mem/free)
     content))
 
+(defn- calculate-bool*
+  [bool-type]
+  (-> (h/call wasm/internal-module "_calculate_bool" (sr/translate-bool-type bool-type))
+      (mem/->offset-32)))
+
 (defn calculate-bool
   [bool-type ids]
-  (let [num-ids (count ids)
-        offset  (mem/alloc->offset-32 (* UUID-U8-SIZE num-ids))
-        heap    (mem/get-heap-u32)]
+
+  (let [size   (mem/get-alloc-size ids UUID-U8-SIZE)
+        heap   (mem/get-heap-u32)
+        offset (mem/alloc->offset-32 size)]
 
     (reduce (fn [offset id]
-              (sr/heapu32-set-uuid id heap offset)
-              (+ offset UUID-U32-SIZE))
+              (sr/write-uuid offset heap id))
             offset
-            (rseq ids)))
+            (rseq ids))
 
-  (let [offset  (h/call wasm/internal-module "_calculate_bool" (sr/translate-bool-type bool-type))
-        offset  (mem/->offset-32 offset)
-        heapu32 (mem/get-heap-u32)
-
-        length  (aget heapu32 offset)
-        data    (mem/slice heapu32
-                           (+ offset 1)
-                           (+ offset 1 (* length (/ path.impl/SEGMENT-U8-SIZE 4))))
-        content (path/from-bytes data)]
-    (mem/free)
-    content))
+    (let [offset  (calculate-bool* bool-type)
+          length  (aget heap offset)
+          data    (mem/slice heap
+                             (+ offset 1)
+                             (* length path.impl/SEGMENT-U32-SIZE))
+          content (path/from-bytes data)]
+      (mem/free)
+      content)))
 
 (defonce module
   (delay

frontend/src/app/render_wasm/deserializers.cljs

@@ -5,25 +5,44 @@
 ;; Copyright (c) KALEIDOS INC
 (ns app.render-wasm.deserializers
   (:require
+   [app.common.data :as d]
    [app.common.geom.matrix :as gmt]
+   [app.common.geom.point :as gpt]
    [app.common.uuid :as uuid]))
 
-(defn heap32->entry
+(defn read-modifier-entry
   [heapu32 heapf32 offset]
   (let [id1 (aget heapu32 (+ offset 0))
         id2 (aget heapu32 (+ offset 1))
         id3 (aget heapu32 (+ offset 2))
         id4 (aget heapu32 (+ offset 3))
 
-        a (aget heapf32 (+ offset 4))
-        b (aget heapf32 (+ offset 5))
-        c (aget heapf32 (+ offset 6))
-        d (aget heapf32 (+ offset 7))
-        e (aget heapf32 (+ offset 8))
-        f (aget heapf32 (+ offset 9))
+        a   (aget heapf32 (+ offset 4))
+        b   (aget heapf32 (+ offset 5))
+        c   (aget heapf32 (+ offset 6))
+        d   (aget heapf32 (+ offset 7))
+        e   (aget heapf32 (+ offset 8))
+        f   (aget heapf32 (+ offset 9))]
 
-        id (uuid/from-unsigned-parts id1 id2 id3 id4)]
+    (d/vec2 (uuid/from-unsigned-parts id1 id2 id3 id4)
+            (gmt/matrix a b c d e f))))
 
-    {:id id
+
+(defn read-selection-rect
+  [heapf32 offset]
+  (let [width  (aget heapf32 (+ offset 0))
+        height (aget heapf32 (+ offset 1))
+        cx     (aget heapf32 (+ offset 2))
+        cy     (aget heapf32 (+ offset 3))
+        a      (aget heapf32 (+ offset 4))
+        b      (aget heapf32 (+ offset 5))
+        c      (aget heapf32 (+ offset 6))
+        d      (aget heapf32 (+ offset 7))
+        e      (aget heapf32 (+ offset 8))
+        f      (aget heapf32 (+ offset 9))]
+    {:width width
+     :height height
+     :center (gpt/point cx cy)
      :transform (gmt/matrix a b c d e f)}))
 
+

frontend/src/app/render_wasm/mem.cljs

@@ -15,10 +15,12 @@
   ;; Divides the value by 4
   (bit-shift-right value 2))
 
-(defn get-list-size
-  "Returns the size of a list in bytes"
-  [list list-item-size]
-  (* list-item-size (count list)))
+(defn get-alloc-size
+  "Calculate allocation size for a sequential collection of identical
+  objects of the specified size."
+  [coll item-size]
+  (assert (counted? coll) "`coll` should be constant time countable")
+  (* item-size (count coll)))
 
 (defn alloc
   "Allocates an arbitrary amount of bytes (aligned to 4 bytes).
@@ -61,5 +63,11 @@
 (defn slice
   "Returns a copy of a portion of a typed array into a new typed array
   object selected from start to end."
-  [heap start end]
-  (.slice ^js heap start end))
+  [heap offset size]
+  (.slice ^js heap offset (+ offset size)))
+
+(defn view
+  "Returns a new typed array on the same ArrayBuffer store and with the
+  same element types as for this typed array."
+  [heap offset size]
+  (.subarray ^js heap offset (+ offset size)))

frontend/src/app/render_wasm/serializers.cljs

@@ -55,18 +55,32 @@
     (catch :default _e
       [uuid/zero])))
 
-(defn heapu32-set-u32
-  [value heap offset]
-  (aset heap offset value))
+(defn write-u32
+  [offset heap value]
+  (assert (instance? js/Uint32Array heap) "expected Uint32Array instance for `heap`")
+  (aset heap offset value)
+  (inc offset))
 
-(defn heapu32-set-uuid
-  [id heap offset]
+(defn write-f32
+  [offset heap value]
+  (assert (instance? js/Float32Array heap) "expected Float32Array instance for `heap`")
+  (aset heap offset value)
+  (inc offset))
+
+(defn write-uuid
+  "Write a uuid to 32 bits addressed heap and return the offset
+  after write."
+  [offset heap id]
+  (assert (instance? js/Uint32Array heap) "expected Uint32Array instance for `heap`")
   (let [buffer (uuid/get-u32 id)]
     (.set heap buffer offset)
-    buffer))
+    (+ offset 4)))
 
-(defn heapf32-set-matrix
-  [matrix heap offset]
+(defn write-matrix
+  "Write a matrix to 32 bits addressed heap and return the offset
+  after write."
+  [offset heap matrix]
+  (assert (instance? js/Float32Array heap) "expected Float32Array instance for `heap`")
   (let [a (dm/get-prop matrix :a)
         b (dm/get-prop matrix :b)
         c (dm/get-prop matrix :c)
@@ -78,7 +92,8 @@
     (aset heap (+ offset 2) c)
     (aset heap (+ offset 3) d)
     (aset heap (+ offset 4) e)
-    (aset heap (+ offset 5) f)))
+    (aset heap (+ offset 5) f)
+    (+ offset 6)))
 
 (defn translate-shape-type
   [type]