diff --git a/doc/anyplex.md b/doc/anyplex.md
new file mode 100644
index 0000000000..d07a3e09f0
--- /dev/null
+++ b/doc/anyplex.md
@@ -0,0 +1,98 @@
+### AnyPlex Protocol (APP)
+
+The **AnyPlex Protocol** allows vector, bitmap, and extensible markup objects to be embedded directly into the terminal's scrollback buffer.
+
+#### Backend & Frontend Separation
+
+The protocol operates on a decoupled architecture to ensure high performance and display adaptability.
+
+Scope                           | Role
+--------------------------------|-----
+**The Backend (BE)**            | Acts as the "Source of Truth". It manages the terminal state, handles the scrollback buffer, and maintains the global object cache. It tracks metadata per cell but remains agnostic of physical pixels.
+**The Graphical Frontend (FE)** | Acts as the "Painter". It performs the actual rasterization of documents (e.g., SVG to pixels) based on local cell metrics. It handles alpha-blending, Z-order layering, and pixel-wise offsets.
+
+#### Rendering & Interaction
+
+- **Rectangular Area**: The object is hosted within a grid of cells defined by `ceil(width)` and `ceil(height)`.
+- **Pixel-wise Precision**: The raster is scaled using floating-point `width` and `height` and positioned with `dx` and `dy` offsets. Offsets are calculated **per-frontend** based on its current cell metrics.
+- **Asynchronous Rasterization**: It is recommended to perform rasterization in a parallel thread. Until the raster is ready, the frontend should display the cells without the graphic.
+- **Persistence**: Metadata is stored per-cell to survive scrollback and ensure that wrapped cell-runs remain logically linked for a strict rectangular reflow.
+- **Cursor Position**: Anchored at the top-left; moves to the cell immediately following the rectangle's bottom-right corner after output.
+- **Destructivity**:
+  - If the **`gc`** attribute is not empty, the provided grapheme cluster is written to **every cell** in the area (`ceil(width)` by `ceil(height)`), replacing existing text and SGR attributes.
+  - If **`gc`** is empty, the output is non-destructive; existing text and SGR attributes remain visually intact under the transparent object.
+  - Any text subsequently written over the object's area does not destroy the underlying object. The object metadata remains intact in the cell until explicitly cleared or replaced.
+- **Selection & SGR 7**: When selecting text/graphics with the mouse, or when the **SGR 7** attribute is present in a cell, the frontend **halves the alpha channel** of the object's pixels within that cell.
+- **Searchability**: Any text contained within the document (e.g., `<text>` in SVG) is treated as part of the graphic and is not required to be indexed by the terminal's text search.
+- **Layering & Transparency**: Supports per-pixel alpha transparency. The `ontop` attribute determines Z-order relative to text (0 = background `[Cell BG] -> [Object] -> [Text]`, 1 = foreground `[Cell BG] -> [Text] -> [Object]`; the cell's background color always remains in the background). The terminal cursor is always drawn on top of everything. Alpha blending is performed in **linear color space**.
+- **Foreground Color**: The underlying cell **SGR foreground color** maps to `currentColor` (for SVG). All other external references (e.g., `http://...`) are ignored for security.
+
+#### Scroll & Reflow Behavior
+
+- **Normal Buffer**: If the cell-run containing the object does not fit within the viewport width, it triggers a standard wrap with a scroll-up if necessary (without triggering **BCE - Background Color Erase**). This may break the rectangular visual of the raster until the viewport is widened or a non-wrap mode is enabled.
+- **Alternate Buffer**: The object's rectangle is strictly clipped (cropped) by the right and bottom edges of the viewport; no scrolling occurs.
+
+#### Sequence Format
+
+```
+ESC ] app ; [<attributes>] [<document>] ST
+```
+
+Field             | Description
+------------------|------------
+**OSC command**   | Mandatory. `app`.
+**attributes**    | Optional. Space-separated `key=value` pairs. Values can be quoted (`"` or `'`) or unquoted. All keys and values are **case-sensitive**.
+**document**      | Optional. UTF-8 data starting with `<` (the first character of the openning tag, e.g. `<svg>`) and ending with `>` (the last character of the closing tag, e.g. `</svg>`). The specified document is considered to be an `empty-doc` if it has the form `<tag></tag>`, where `tag` is any string.
+
+#### Attributes
+
+Attribute     | Values                                 | Default                  | Description
+--------------|----------------------------------------|--------------------------|------------
+**id**        | `<id>[/sub-id]`                        | empty string (`""`)      | Object reference ID.
+**gc**        | `string`                               | empty string (`""`)      | Grapheme cluster to write to cells (will be scaled to a 1x1 cell size).
+**ontop**     | `0`\|`1`                               | `0`                      | 0 = under text, 1 = over text.
+**width**     | `float (0..65535]`                     | Terminal viewport width  | Raster scale width (cells).
+**height**    | `float (0..65535]`                     | Terminal viewport height | Raster scale height (cells).
+**dx**        | `float`                                | `0.0`                    | Horizontal offset of the raster within the grid (cells).
+**dy**        | `float`                                | `0.0`                    | Vertical offset of the raster within the grid (cells).
+**column**    | `0`..`ceil(width)`                     | `0`                      | Horizontal 1-based slicing index for partial rendering (0 = full width, 1..n = specific cell/slice).
+**row**       | `0`..`ceil(height)`                    | `0`                      | Vertical 1-based slicing index for partial rendering (0 = full height, 1..m = specific cell/slice).
+**align**     | \[`left`\|`center`\|`right`\]\[`-`\]\[`top`\|`middle`\|`bottom`\] | `center-middle` | 2D alignment within the rectangle.
+**scale**     | `inside`\|`outside`\|`stretch`\|`none` | `inside`                 | Fit logic (none = exact pixels, cropped if larger).
+**transform** | `0`..`7`                               | `0`                      | 3-bit compact transformation state `[FlipY][FlipX][SwapXY]`.
+**flip**      | `none`\|`v`\|`h`\|`vh`\|`hv`           | `none`                   | Applied in order of appearance in the string.
+**rotate**    | `0`\|`90`\|`180`\|`270`                | `0`                      | CCW rotation applied in order of appearance.
+
+> Notes:
+> - If `id` is omitted , the empty string `id=""` is used for registration and output.
+> - Attribute values `width` and `height` are clamped to the `(0..65535]` range and further limited by the terminal's maximum window size settings.
+> - Attribute values `width`, `height`, `dx` and `dy` are multiplied by the cell size and **rounded** to get the exact pixel values on the FE side.
+> - The first part of the object reference ID (`id`) references the raw object document in the Backend cache.
+> - The second part of the object reference ID (`sub-id`) addresses the specific named element (e.g., an `id="..."` within an SVG document). The Frontend renders only this fragment if it is specified.
+
+#### Lifecycle & Cache Management
+
+Input State             | Action
+------------------------|-------
+**id** + **doc**        | Store/update the object document in cache and output.
+**id** + **empty-doc**  | Unregister `id` and free the index.
+**id** + **no-doc**     | Output cached object.
+**id/sub-id**           | If a `sub-id` is specified, the FE renders that specific element in its original coordinates (as it would appear in the full document), inheriting all parent styles (CSS, `<g>` groups).
+**Errors**              | If a document is invalid, the `id` is unknown, the `sub-id` is missing, or the cache is full, the FE **clears the object metadata** in the target area (rendering nothing) and logs the error.
+
+> Note:
+> When the BE deletes an `id`, or upon `reset`/session close, it frees the index and signals the FEs.
+> - FEs then traverse their viewport cells; any image in the FE cache no longer referenced by any cell is purged.
+> - If an FE encounters an unknown object index in a cell, it must request full metadata/document from the BE.
+
+#### Parsing Rules (Backend)
+
+1. Scan the OSC string for `key=value` pairs.
+2. Identify document boundaries via first `<` and last `>`.
+3. Apply transformation pipeline (`transform`, `flip`, `rotate`) in the order they appear.
+
+#### Extensibility
+
+The protocol is engine-agnostic. Focused on **SVG**, but designed to support other formats (e.g., `<html>`, `<object>`) via root tag identification.
+
+The protocol can be extended to include non-visual data segments such as `<audio>` or `<wav>`, allowing for synchronized multimedia playback managed by the Frontend.
diff --git a/doc/architecture.md b/doc/architecture.md
index ebb64dcf3b..7ffa800db4 100644
--- a/doc/architecture.md
+++ b/doc/architecture.md
@@ -438,7 +438,7 @@ Note: You can explicitly specify running vtm inside the terminal (run `vtm --tui
 
 - In general, the local and remote platforms may be different.
 - When the DirectVT mode is used, all keyboard, mouse, and other input events are transmitted between hosts in a binary form.
-- The following examples assume that vtm is accessible via PATH on both the local and remote sides. 
+- The following examples assume that vtm is accessible via PATH on both the local and remote sides.
 
 ### Run remote desktop/terminal over SSH
 
diff --git a/doc/character_geometry.md b/doc/character_geometry.md
index e0f574733f..235a0d2974 100644
--- a/doc/character_geometry.md
+++ b/doc/character_geometry.md
@@ -159,17 +159,7 @@ VS12 | 0xFE0B    | Rotate 270° CCW
 VS13 | 0xFE0C    | Horizontal flip
 VS14 | 0xFE0D    | Vertical flip
 
-Example functions for applying a rotation operation to the current three-bit integer state:
-```c++
-void VS10(int& state) { state = (state & 0b100) | ((state + 0b001) & 0b011); }
-void VS11(int& state) { state = (state & 0b100) | ((state + 0b010) & 0b011); }
-void VS12(int& state) { state = (state & 0b100) | ((state + 0b011) & 0b011); }
-void VS13(int& state) { state = (state ^ 0b100) | ((state + (state & 1 ? 0 : 0b010)) & 0b011); }
-void VS14(int& state) { state = (state ^ 0b100) | ((state + (state & 1 ? 0b010 : 0)) & 0b011); }
-
-int get_angle(int state) { int angle = 90 * (state & 0b011); return angle; }
-int get_hflip(int state) { int hflip = state >> 2; return hflip; }
-```
+Note: Due to non-commutativity, transformations are performed in the order they appear.
 
 # New Look for Text-based User Interface
 
diff --git a/doc/settings.md b/doc/settings.md
index 857691cdf6..cd6dea6a49 100644
--- a/doc/settings.md
+++ b/doc/settings.md
@@ -1003,12 +1003,12 @@ Notes
             <default fgc=whitedk bgc=pureblack/>  <!-- Default terminal colors (SGR 39/49, set by OSC 10/11). -->
             <match fx="color" fgc=whitelt bgc= #007F00/>  <!-- Appearance of selected text matches. Available shaders (fx): "xlight", "color", "invert", "reverse". -->
             <selection>
-                <text      fx="color"  fgc=whitelt bgc=bluelt/>  <!-- Selection highlighting for plaintext clipboard mode. -->
-                <protected fx="color"  fgc=whitelt bgc=bluelt/>  <!-- Note: bgc and fgc attributes only apply when fx="color". -->
-                <ansi      fx="xlight" fgc=whitelt bgc=bluelt/>
-                <rich      fx="xlight" fgc=whitelt bgc=bluelt/>
-                <html      fx="xlight" fgc=whitelt bgc=bluelt/>
-                <none      fx="color"  fgc=whitedk bgc=blacklt/>  <!-- Appearance of an inactive selection. -->
+                <text      fx="color" inv=true bgc=whitelt fgc=bluelt/>  <!-- Selection highlighting for plaintext clipboard mode. -->
+                <protected fx="color" inv=true bgc=whitelt fgc=bluelt/>  <!-- Notes: -->
+                <ansi      fx="color" inv=true bgc=whitelt fgc=bluelt/>  <!--   - inv=true ensures that the embedded image becomes translucent (see AnyPlex Protocol). -->
+                <rich      fx="color" inv=true bgc=whitelt fgc=bluelt/>  <!--   - bgc and fgc attributes only apply when fx="color".            -->
+                <html      fx="color" inv=true bgc=whitelt fgc=bluelt/>
+                <none      fx="color" inv=true bgc=whitedk fgc=blacklt/>  <!-- Appearance of an inactive selection. -->
             </selection>
             <names=/X11ColorNames>  <!-- Color name mappings for OSC 4, 10-12. -->
                 <!--  <name="New Dark Orange" rgb= #FF8C00 /> -->
diff --git a/src/netxs/apps/tile.hpp b/src/netxs/apps/tile.hpp
index c89ae5134c..a10dd0c22d 100644
--- a/src/netxs/apps/tile.hpp
+++ b/src/netxs/apps/tile.hpp
@@ -794,14 +794,14 @@ namespace netxs::app::tile
         auto parse_data = [](auto&& parse_data, view& utf8, auto min_ratio, auto grip_bindings_ptr) -> netxs::sptr<ui::veer>
         {
             auto slot_ptr = node_veer(node_veer, min_ratio, grip_bindings_ptr);
-            utf::trim_front(utf8, ", ");
+            utf::trim_front(utf8, netxs::whitespaces_and<','>);
             if (utf8.empty()) return slot_ptr;
             auto tag = utf8.front();
             if ((tag == 'h' || tag == 'v') && utf8.find('(') < utf8.find(','))
             {
                 // add split
                 utf8.remove_prefix(1);
-                utf::trim_front(utf8, ' ');
+                utf::trim_front(utf8, netxs::whitespaces);
                 auto s1 = si32{ 1 };
                 auto s2 = si32{ 1 };
                 auto w  = si32{-1 };
@@ -813,14 +813,14 @@ namespace netxs::app::tile
                     if (auto r = utf::to_int(utf8)) // Right side ratio
                     {
                         s2 = std::abs(r.value());
-                        utf::trim_front(utf8, ' ');
+                        utf::trim_front(utf8, netxs::whitespaces);
                         if (!utf8.empty() && utf8.front() == ':') // Grip width.
                         {
                             utf8.remove_prefix(1);
                             if (auto g = utf::to_int(utf8))
                             {
                                 w = std::abs(g.value());
-                                utf::trim_front(utf8, ' ');
+                                utf::trim_front(utf8, netxs::whitespaces);
                             }
                         }
                     }
@@ -832,15 +832,15 @@ namespace netxs::app::tile
                 auto slot1 = node->attach(slot::_1, parse_data(parse_data, utf8, ui::fork::min_ratio, grip_bindings_ptr));
                 auto slot2 = node->attach(slot::_2, parse_data(parse_data, utf8, ui::fork::max_ratio, grip_bindings_ptr));
                 slot_ptr->attach(node);
-                utf::trim_front(utf8, ") ");
+                utf::trim_front(utf8, netxs::whitespaces_and<')'>);
             }
             else  // Add application.
             {
-                utf::trim_front(utf8, ' ');
-                auto menuid = utf::take_front(utf8, " ,)").str();
+                utf::trim_front(utf8, netxs::whitespaces);
+                auto menuid = utf::take_front(utf8, netxs::whitespaces_and<',', ')'>).str();
                 if (menuid.empty()) return slot_ptr;
 
-                utf::trim_front(utf8, " ,");
+                utf::trim_front(utf8, netxs::whitespaces_and<','>);
                 if (utf8.size() && utf8.front() == ')') utf8.remove_prefix(1); // pop ')';
 
                 auto& s = *slot_ptr;
diff --git a/src/netxs/desktopio/ansivt.hpp b/src/netxs/desktopio/ansivt.hpp
index 5b1fe04104..98ca3af1da 100644
--- a/src/netxs/desktopio/ansivt.hpp
+++ b/src/netxs/desktopio/ansivt.hpp
@@ -137,25 +137,27 @@ namespace netxs::ansi
     static const auto c0_us  = '\x1F'; // Unit Separator.
     static const auto c0_del = '\x7F'; // Delete cell backward.
 
-    static const auto osc_label_title  = "0"   ; // Set icon label and title.
-    static const auto osc_label        = "1"   ; // Set icon label.
-    static const auto osc_title        = "2"   ; // Set title.
-    static const auto osc_xprop        = "3"   ; // Set xprop.
-    static const auto osc_set_palette  = "4"   ; // Set 256 colors palette.
-    static const auto osc_linux_color  = "P"   ; // Set 16 colors palette. (Linux console)
-    static const auto osc_linux_reset  = "R"   ; // Reset 16/256 colors palette. (Linux console)
-    static const auto osc_clipboard    = "52"  ; // Set clipboard.
-    static const auto osc_term_notify  = "9"   ; // Terminal notifications.
-    static const auto osc_set_fgcolor  = "10"  ; // Set fg color.
-    static const auto osc_set_bgcolor  = "11"  ; // Set bg color.
-    static const auto osc_caret_color  = "12"  ; // Set cursor color.
-    static const auto osc_reset_color  = "104" ; // Reset color N to default palette. Without params all palette reset.
-    static const auto osc_reset_fgclr  = "110" ; // Reset fg color to default.
-    static const auto osc_reset_bgclr  = "111" ; // Reset bg color to default.
-    static const auto osc_reset_crclr  = "112" ; // Reset cursor color to default.
-    static const auto osc_semantic_fx  = "133" ; // Semantic markers (shell integration).
-    static const auto osc_title_report = "l"   ; // Get terminal window title.
-    static const auto osc_label_report = "L"   ; // Get terminal window icon label.
+    static const auto osc_label_title  = "0"      ; // Set icon label and title.
+    static const auto osc_label        = "1"      ; // Set icon label.
+    static const auto osc_title        = "2"      ; // Set title.
+    static const auto osc_xprop        = "3"      ; // Set xprop.
+    static const auto osc_set_palette  = "4"      ; // Set 256 colors palette.
+    static const auto osc_linux_color  = "P"      ; // Set 16 colors palette. (Linux console)
+    static const auto osc_linux_reset  = "R"      ; // Reset 16/256 colors palette. (Linux console)
+    static const auto osc_clipboard    = "52"     ; // Set clipboard.
+    static const auto osc_term_notify  = "9"      ; // Terminal notifications.
+    static const auto osc_set_fgcolor  = "10"     ; // Set fg color.
+    static const auto osc_set_bgcolor  = "11"     ; // Set bg color.
+    static const auto osc_caret_color  = "12"     ; // Set cursor color.
+    static const auto osc_reset_color  = "104"    ; // Reset color N to default palette. Without params all palette reset.
+    static const auto osc_reset_fgclr  = "110"    ; // Reset fg color to default.
+    static const auto osc_reset_bgclr  = "111"    ; // Reset bg color to default.
+    static const auto osc_reset_crclr  = "112"    ; // Reset cursor color to default.
+    static const auto osc_semantic_fx  = "133"    ; // Semantic markers (shell integration).
+    static const auto osc_title_report = "l"      ; // Get terminal window title.
+    static const auto osc_label_report = "L"      ; // Get terminal window icon label.
+    static const auto osc_glyph        = "glyph"  ; // Dynamic Glyph Redefinition.
+    static const auto osc_app          = "app"    ; // AnyPlex Protocol.
 
     static const auto sgr_rst       = 0;
     static const auto sgr_sav       = 10;
diff --git a/src/netxs/desktopio/application.hpp b/src/netxs/desktopio/application.hpp
index 8d31252376..cebcebf552 100644
--- a/src/netxs/desktopio/application.hpp
+++ b/src/netxs/desktopio/application.hpp
@@ -22,7 +22,7 @@ namespace netxs::app
 
 namespace netxs::app::shared
 {
-    static const auto version = "v2026.03.27";
+    static const auto version = "v2026.04.09";
     static const auto repository = "https://github.com/directvt/vtm";
     static const auto usr_config = "~/.config/vtm/settings.xml"s;
     static const auto sys_config = "/etc/vtm/settings.xml"s;
diff --git a/src/netxs/desktopio/canvas.hpp b/src/netxs/desktopio/canvas.hpp
index 9351c84890..66935183a3 100644
--- a/src/netxs/desktopio/canvas.hpp
+++ b/src/netxs/desktopio/canvas.hpp
@@ -18,6 +18,10 @@ namespace netxs
         dtvt ,
     };
 
+    enum class bias : byte { none, left, right, center, };
+    enum class wrap : byte { none, on,  off,            };
+    enum class rtol : byte { none, rtl, ltr,            };
+
     namespace zpos
     {
         static constexpr auto backmost = -1;
@@ -35,6 +39,32 @@ namespace netxs
         static constexpr auto dashed = 5;
     }
 
+    namespace scale_mode
+    {
+        static constexpr auto inside  = 0;
+        static constexpr auto outside = 1;
+        static constexpr auto stretch = 2;
+        static constexpr auto none    = 3;
+    }
+    namespace align_mode                         // horizontal            vertical
+    {
+        static constexpr auto center        = (si32)bias::center | ((si32)bias::center << 2);
+        static constexpr auto left          = (si32)bias::left   | ((si32)bias::center << 2);
+        static constexpr auto right         = (si32)bias::right  | ((si32)bias::center << 2);
+        static constexpr auto middle        = (si32)bias::center | ((si32)bias::center << 2);
+        static constexpr auto top           = (si32)bias::center | ((si32)bias::left   << 2);
+        static constexpr auto bottom        = (si32)bias::center | ((si32)bias::right  << 2);
+        static constexpr auto center_middle = (si32)bias::center | ((si32)bias::center << 2);
+        static constexpr auto center_top    = (si32)bias::center | ((si32)bias::left   << 2);
+        static constexpr auto center_bottom = (si32)bias::center | ((si32)bias::right  << 2);
+        static constexpr auto left_middle   = (si32)bias::left   | ((si32)bias::center << 2);
+        static constexpr auto left_top      = (si32)bias::left   | ((si32)bias::left   << 2);
+        static constexpr auto left_bottom   = (si32)bias::left   | ((si32)bias::right  << 2);
+        static constexpr auto right_middle  = (si32)bias::right  | ((si32)bias::center << 2);
+        static constexpr auto right_top     = (si32)bias::right  | ((si32)bias::left   << 2);
+        static constexpr auto right_bottom  = (si32)bias::right  | ((si32)bias::right  << 2);
+    }
+
     namespace text_cursor
     {
         static constexpr auto none      = 0;
@@ -1053,7 +1083,7 @@ namespace netxs
             return *this;
         }
         // irgb: Pack extra alpha into exponent/mantissa.
-        void pack_alpha(byte extra_alpha) 
+        void pack_alpha(byte extra_alpha)
         {
             auto a_8bit = (ui32)(a * 255.f + 0.5f);
             auto packed = 0x40000000u | (extra_alpha << 15) | (a_8bit << 7); // extra_alpha: bits 15-22, a_8bit: bits 7-14.
@@ -1160,69 +1190,247 @@ namespace netxs
         }
     };
 
-    // canvas: Grapheme cluster.
-    struct cell
+    namespace imagens
     {
-        struct glyf
+        // local:  stored in cells
+        // global: stored in image
+        // ux:     for user convenience
+        #define attr_list \
+            X(width    ) /* global */ \
+            X(height   ) /* global */ \
+            X(dx       ) /* global */ \
+            X(dy       ) /* global */ \
+            X(scale    ) /* global */ \
+            X(row      ) /* local  */ \
+            X(column   ) /* local  */ \
+            X(ontop    ) /* local  */ \
+            X(align    ) /* local  */ \
+            X(transform) /* local  */ \
+            X(flip     ) /* ux     */ \
+            X(rotate   ) /* ux     */
+
+        static constexpr auto _counter = __COUNTER__ + 1;
+        #define X(_attr) static constexpr auto _attr = __COUNTER__ - _counter; // width = __COUNTER__ - _counter;
+            attr_list
+            static constexpr auto attr_count = __COUNTER__ - _counter;
+        #undef X
+        static constexpr auto attr_names = std::array<view, imagens::attr_count>
+        {
+            #define X(_attr) #_attr, // "width",
+                attr_list
+            #undef X
+        };
+        // Dihedral group D4 (the symmetries of a square) 0b[FlipY][FlipX][SwapXY].
+        //    transfroms: 0   1   2   3   4   5   6   7  =xform
+        //    pull-based: lt  tl  rt  tr  lb  bl  rb  br (left/right/top/bottom-left/right/top/bottom)
+        //    push-based: lt  tl  rt  bl  lb  tr  rb  br (left/right/top/bottom-left/right/top/bottom)
+        //                            |       |
+        enum ds         { lt, tl, rt, tr, lb, bl, rb, br }; // Pull-based sequence.
+        // Reconcile the coordinate systems between the "pull-based" renderer (x_form_mirror_r90) and the "push-based" raster transformer (sprite::transform). In the D4 dihedral group, when SwapXY (bit 0) is active, the order of FlipX/Y applications is non-commutative.
+        // This conjugation table swaps 'Swap + FlipX' (3) with 'Swap + FlipY' (5) to synchronize the two algorithms.
+        static constexpr auto xlate = std::to_array({ lt, tl, rt, bl, lb, tr, rb, br });
+        enum class flips { none, hz, vt, hv };
+        enum class ccw { none, r90, r180, r270 };
+                                                           //direction: lt, tl, rt, tr, lb, bl, rb, br
+        static constexpr auto do_flip = std::to_array({ std::to_array({ lt, tl, rt, tr, lb, bl, rb, br }),    // none
+                                                        std::to_array({ rt, tr, lt, tl, rb, br, lb, bl }),    // hz_flip
+                                                        std::to_array({ lb, bl, rb, br, lt, tl, rt, tr }),    // vt_flip
+                                                        std::to_array({ rb, br, lb, bl, rt, tr, lt, tl }) }); // hv_flip (hz+vt)
+        static constexpr auto do_rCCW = std::to_array({ std::to_array({ lt, tl, rt, tr, lb, bl, rb, br }),    // none
+                                                        std::to_array({ bl, lb, tl, lt, br, rb, tr, rt }),    // CCW90
+                                                        std::to_array({ rb, br, lb, bl, rt, tr, lt, tl }),    // 180
+                                                        std::to_array({ tr, rt, br, rb, tl, lt, bl, lb }) }); // CCW270
+        auto mirror_fx = [](auto& state, auto fx)
+        {
+            auto t = (si32)state & 7;
+            auto f = (si32)fx & 3;
+            t = do_flip[f][t];
+            state = (std::decay_t<decltype(state)>)(t);
+        };
+        auto rotate_fx = [](auto& state, auto rx)
         {
-            static auto jumbos()
-            {
-                using lock = std::mutex;
-                using sync = std::lock_guard<lock>;
-                using depo = std::unordered_map<ui64, text>;
-                using uset = std::unordered_set<ui64>;
+            auto t = (si32)state & 7;
+            auto r = (si32)rx & 3;
+            t = do_rCCW[r][t];
+            state = (std::decay_t<decltype(state)>)(t);
+        };
+        auto combine_transform_fx = [](auto t1, auto t2)
+        {
+            auto s1 = (si32)t1;
+            auto s2 = (si32)t2;
+            bool f1 = s1 & 4; // Extract reflection bits (4) and rotation bits (3).
+            bool f2 = s2 & 4;
+            auto r1 = s1 & 3;
+            auto r2 = s2 & 3;
+            // The new reflection bit is a simple XOR.
+            auto f = (f1 ^ f2) ? 4 : 0;
+            // The new rotation bit:
+            // If the first state was reflected, the second rotation is subtracted.
+            // Otherwise, it is added.
+            auto r = (f1 ? (r1 - r2) : (r1 + r2)) & 3;
+            return (decltype(t1))(f | r);
+        };
+        auto combine_align_fx = [](auto f_old_align, auto f_new_align)
+        {
+            auto old_align = (si32)f_old_align;
+            auto new_align = (si32)f_new_align;
+            auto res_h = (old_align & 0b0011) ? (old_align & 0b0011) : (new_align & 0b0011);
+            auto res_v = (old_align & 0b1100) ? (old_align & 0b1100) : (new_align & 0b1100);
+            return (decltype(f_old_align))(res_h | res_v);
+        };
 
-                struct vars
+        static const auto attr_index_map = utf::unordered_map<text, si32>
+        {
+            #define X(_attr) { #_attr, imagens::_attr },
+                attr_list
+            #undef X
+        };
+        #undef attr_list
+        static const auto value_index_map = std::unordered_map<si32, utf::unordered_map<text, si32>>
+        {
+            { imagens::align, {{ "center" , align_mode::center }, { "center-middle" , align_mode::center_middle }, { "center-top" , align_mode::center_top }, { "center-bottom" , align_mode::center_bottom },
+                               { "left"   , align_mode::left   }, { "left-middle"   , align_mode::left_middle   }, { "left-top"   , align_mode::left_top   }, { "left-bottom"   , align_mode::left_bottom   },
+                               { "right"  , align_mode::right  }, { "right-middle"  , align_mode::right_middle  }, { "right-top"  , align_mode::right_top  }, { "right-bottom"  , align_mode::right_bottom  },
+                               { "middle" , align_mode::middle }, { "middle-center" , align_mode::center_middle }, { "top-center" , align_mode::center_top }, { "bottom-center" , align_mode::center_bottom },
+                               { "top"    , align_mode::top    }, { "middle-left"   , align_mode::left_middle   }, { "top-left"   , align_mode::left_top   }, { "bottom-left"   , align_mode::left_bottom   },
+                               { "bottom" , align_mode::bottom }, { "middle-right"  , align_mode::right_middle  }, { "top-right"  , align_mode::right_top  }, { "bottom-right"  , align_mode::right_bottom  }} },
+            { imagens::scale, {{ "inside" , scale_mode::inside  },
+                               { "outside", scale_mode::outside },
+                               { "stretch", scale_mode::stretch },
+                               { "none"   , scale_mode::none    }} },
+            { imagens::flip,   {{ "none", 0 }, { "v" , (si32)flips::vt }, { "h" , (si32)flips::hz }, { "vh" , (si32)flips::hv }, { "hv" , (si32)flips::hv }} },
+            { imagens::rotate, {{ "0", 0 }, { "90" , (si32)ccw::r90 }, { "180" , (si32)ccw::r180 }, { "270" , (si32)ccw::r270 }} },
+        };
+        auto parse_pair(qiew key, qiew val) -> std::optional<std::pair<si32, fp32>>
+        {
+            if (auto key_iter = imagens::attr_index_map.find(key); key_iter != imagens::attr_index_map.end())
+            {
+                auto key_index = key_iter->second;
+                if (val.empty())
                 {
-                    lock mutex{}; // Cluster map mutex. Do we need to reset/clear/flush the map?
-                    depo jumbo{}; // Jumbo cluster map.
-                    uset undef{}; // List of unknown tokens.
-                };
-                struct guard : sync
-                {
-                    depo& map;
-                    uset& unk;
-                    guard(vars& inst)
-                        : sync{ inst.mutex },
-                           map{ inst.jumbo },
-                           unk{ inst.undef }
-                    { }
-                    // jumbos: Get cluster.
-                    auto& get(ui64 token)
-                    {
-                        if (auto iter = map.find(token); iter != map.end())
-                        {
-                            return iter->second;
-                        }
-                        else
-                        {
-                            static auto empty = text{};
-                            unk.insert(token);
-                            return empty;
-                        }
-                    }
-                    // jumbos: Set cluster.
-                    void set(ui64 token, view data)
-                    {
-                        map[token] = data;
-                    }
-                    // jumbos: Add cluster.
-                    void add(ui64 token, view data)
+                    return std::pair{ key_index, 0.f };
+                }
+                else if (auto val_map_iter = imagens::value_index_map.find(key_index); val_map_iter != imagens::value_index_map.end()) // Look literals.
+                {
+                    auto& val_map = val_map_iter->second;
+                    if (auto val_iter = val_map.find(val); val_iter != val_map.end())
                     {
-                        map.insert(std::pair{ token, data }); // Silently ignore if it exists.
+                        auto val_index = (fp32)val_iter->second;
+                        return std::pair{ key_index, val_index };
                     }
-                    // jumbos: Check the cluster existence by token.
-                    auto exists(ui64 token)
+                }
+                else if (auto v = utf::to_int<fp32>(val)) // Take a numeric value.
+                {
+                    auto val_index = v.value();
+                    return std::pair{ key_index, val_index };
+                }
+            }
+            return std::nullopt;
+        }
+
+        using docs = std::array<uptr<lunasvg::Document>, 3>; // Storing White/Black/Transparent variants. //todo request lunasvg to generate RGBAfp32 with A8A8
+        struct image
+        {
+            using attrs_t = std::array<std::optional<fp32>, imagens::attr_count>;
+
+            //todo tie id, document, dom to shared sptr<>
+            text          id;
+            text          sub_id; // Document's sub-element id.
+            text          document;
+            attrs_t       attrs;
+            ui16          index{};
+            sprite        fragment{ *std::pmr::new_delete_resource() }; // Rasterized fragment within the document area. Using default resource allocator.
+            rect          document_area; // All transformations and alignments must be performed for this area.
+            imagens::docs dom;
+        };
+
+        template<class T>
+        struct cache
+        {
+        protected:
+            using lock = std::mutex;
+            using sync = std::lock_guard<lock>;
+            using depo = std::array<netxs::sptr<T>, 65536>; // ~1MB
+            using uset = std::unordered_set<ui16>;
+            using pool = generics::indexer<ui16>;
+
+            lock mutex; // Object map mutex.
+            depo store; // Object map.
+            uset undef; // List of unknown tokens.
+            pool index; // Index pool.
+
+            struct guard : sync
+            {
+                depo& map;
+                uset& unk;
+                pool& ind;
+
+                guard(cache& inst)
+                    : sync{ inst.mutex },
+                       map{ inst.store },
+                       unk{ inst.undef },
+                       ind{ inst.index }
+                { }
+
+                // cache: Get object.
+                auto& get(ui16 image_index)
+                {
+                    auto image_ptr = map[image_index];
+                    if (!image_ptr)
                     {
-                        auto iter = map.find(token);
-                        auto okay = iter != map.end();
-                        if (!okay) unk.insert(token);
-                        return okay;
+                        unk.insert(image_index);
                     }
-                };
+                    return image_ptr;
+                }
+                // cache: Set object.
+                auto set(auto image_ptr)
+                {
+                    auto image_index = ind.get_new();
+                    map[image_index] = image_ptr;
+                    return image_index;
+                }
+                // cache: Remove object.
+                void remove(ui16 image_index)
+                {
+                    map[image_index].reset();
+                    ind.release(image_index);
+                }
+                // cache: Check the object existence by token.
+                auto exists(ui16 image_index)
+                {
+                    return map[image_index];
+                }
+            };
+
+        public:
+            cache() = default;
+            auto storage()
+            {
+                return guard{ *this };
+            }
+        };
+    }
+
+    // canvas: Grapheme cluster.
+    struct cell
+    {
+        static auto jumbos()
+        {
+            static auto cache = netxs::generics::cache<text>{};
+            return cache.storage();
+        }
+        static auto images()
+        {
+            static auto cache = imagens::cache<imagens::image>{};
+            return cache.storage();
+        }
 
-                static auto inst = vars{};
-                return guard{ inst };
+        struct glyf
+        {
+            static auto jumbos()
+            {
+                static auto cache = netxs::generics::cache<text>{};
+                return cache.storage();
             }
 
             // If bytes[1] & 0b11'00'0000 == 0b10'00'0000 (first byte in UTF-8 cannot start with 0b10......) - If so, cluster is stored in an external map (jumbo cluster).
@@ -1287,7 +1495,7 @@ namespace netxs
                 token |= isrtl;
                 size_w(2 - 1);
             }
-            auto mtx() const
+            constexpr auto mtx() const
             {
                 return twod{ size_w() + 1, size_h() + 1 };
             }
@@ -1323,7 +1531,7 @@ namespace netxs
                 }
             }
             // glyf: Cluster length in bytes (if it is not jumbo).
-            auto str_len() const
+            constexpr auto str_len() const
             {
                 return !(token & netxs::letoh((ui64)0xFF << 8 * 1)) ? 0 : // !bytes[1] ? 0 :
                        !(token & netxs::letoh((ui64)0xFF << 8 * 2)) ? 1 : // !bytes[2] ? 1 :
@@ -1337,7 +1545,7 @@ namespace netxs
             view get() const
             {
                 if constexpr (Mode == svga::dtvt) return {};
-                auto crop = is_jumbo() ? jumbos().get(jgc_token())
+                auto crop = is_jumbo() ? view{ jumbos().get(jgc_token()) }
                                        : view(bytes() + 1, str_len());
                 if constexpr (Mode != svga::vt_2D)
                 {
@@ -1348,11 +1556,11 @@ namespace netxs
                 }
                 return crop;
             }
-            auto is_space() const
+            constexpr auto is_space() const
             {
                 return (token & netxs::letoh((ui64)0xFF00)) <= netxs::letoh((ui64)whitespace << 8); // (byte)(bytes[1]) <= whitespace;
             }
-            auto is_null() const
+            constexpr auto is_null() const
             {
                 return (token & netxs::letoh((ui64)0xFF00)) == 0; // bytes[1] == 0; // Jumbo bits are nulls. Jumbo mark is the last two bits = 0b10'000000.
             }
@@ -1361,7 +1569,7 @@ namespace netxs
                 return !is_jumbo() || jumbos().exists(jgc_token());
             }
             // Return cluster storage length.
-            auto len() const
+            constexpr auto len() const
             {
                 return is_jumbo() ? sizeof(token) : 1/*first byte (props)*/ + str_len();
             }
@@ -1376,13 +1584,6 @@ namespace netxs
         };
         struct body
         {
-            struct pxtype
-            {
-                static constexpr auto none   = 0;
-                static constexpr auto bitmap = 1; // Attached argb bitmap reference: 32 bit: bitmap index.
-                static constexpr auto reserv = 2;
-            };
-
             // Shared attributes.
             static constexpr auto bolded_mask = (ui64)0b00000000'00000000'00000000'00000000'00000000'00000000'00000000'00000001; // bolded : 1;
             static constexpr auto italic_mask = (ui64)0b00000000'00000000'00000000'00000000'00000000'00000000'00000000'00000010; // italic : 1;
@@ -1392,12 +1593,11 @@ namespace netxs
             static constexpr auto unline_mask = (ui64)0b00000000'00000000'00000000'00000000'00000000'00000000'00000000'11100000; // unline : 3; // 0: none, 1: line, 2: biline, 3: wavy, 4: dotted, 5: dashed, 6 - 7: unknown.
             static constexpr auto ucolor_mask = (ui64)0b00000000'00000000'00000000'00000000'00000000'00000000'11111111'00000000; // ucolor : 8; // Underline 256-color 6x6x6-cube index. Alpha not used - it is shared with fgc alpha. If zero - sync with fgc.
             static constexpr auto cursor_mask = (ui64)0b00000000'00000000'00000000'00000000'00000000'00000011'00000000'00000000; // cursor : 2; // 0: None, 1: Underline, 2: Block, 3: I-bar.
-            static constexpr auto hplink_mask = (ui64)0b00000000'00000000'00000000'00000000'00000000'00000100'00000000'00000000; // hyperlink : 1; // cell::px strores string hash.
+            static constexpr auto hplink_mask = (ui64)0b00000000'00000000'00000000'00000000'00000000'00000100'00000000'00000000; // hyperlink : 1; // cell: strore string hash.
             static constexpr auto blinks_mask = (ui64)0b00000000'00000000'00000000'00000000'00000000'00001000'00000000'00000000; // blinks : 1;
-            static constexpr auto bitmap_mask = (ui64)0b00000000'00000000'00000000'00000000'00000000'00110000'00000000'00000000; // bitmap : 2; // body::pxtype: Cursor losts its colors when it covers bitmap.
-            static constexpr auto fusion_mask = (ui64)0b00000000'00000000'00000000'00000000'00000000'11000000'00000000'00000000; // fusion : 2; // todo The outlines of object boundaries must be set when rendering each window (pro::shape).
-            static constexpr auto shadow_mask = (ui64)0b00000000'00000000'00000000'00000000'11111111'00000000'00000000'00000000; // shadow : 8; // Shadow bits.
-            static constexpr auto hidden_mask = (ui64)0b00000000'00000000'00000000'00000001'00000000'00000000'00000000'00000000; // shadow : 8; // Hidden character.
+            static constexpr auto hidden_mask = (ui64)0b00000000'00000000'00000000'00000000'00000000'00010000'00000000'00000000; // hidden : 1; // Hidden character.
+          //static constexpr auto reserv_mask = (ui64)0b00000000'00000000'00000000'00000000'11111111'11100000'00000000'00000000; // reserv : 11;
+            static constexpr auto shadow_mask = (ui64)0b00000000'00000000'00000000'11111111'00000000'00000000'00000000'00000000; // shadow : 8; // Shadow bits.
             // Unique attributes. From 24th bit.
             static constexpr auto mosaic_mask = (ui64)0b00000000'00000000'11111111'00000000'00000000'00000000'00000000'00000000; // ui32 mosaic : 8; // High 3 bits -> y-fragment (0-4 utf::matrix::ky), low 5 bits -> x-fragment (0-16 utf::matrix::kx). // Ref:  https://gitlab.freedesktop.org/terminal-wg/specifications/-/issues/23
             static constexpr auto curbgc_mask = (ui64)0b00000000'11111111'00000000'00000000'00000000'00000000'00000000'00000000; // bgcclr : 8; // Cursor 256-color 6x6x6-cube index. Alpha not used.
@@ -1407,17 +1607,6 @@ namespace netxs
             static constexpr auto y_bits = utf::matrix::y_bits; // Character geometry y fragment selector bits offset (for mosaic_mask).
             static constexpr auto shared_bits = ((ui64)1 << netxs::field_offset<mosaic_mask>()) - 1;
 
-            // Fusion: Background interpolation current c0 with neighbor c1 and c2 cells:
-            //    c0 c1
-            //    c2
-            // BG interpolation type (two 1-bit values):
-            // 0 -- None
-            // 1 -- Cubic
-            //
-            // 0 1
-            // │ └────── interpolation type between `c0` and `c2`
-            // └──────── interpolation type between `c0` and `c1`
-
             //todo Cf's can not be entered: even using paste from clipboard
             //don't show (drop) Cf's but allow input it in any order (app is responsible to show it somehow)
 
@@ -1477,10 +1666,8 @@ namespace netxs
                         {
                             if (auto cursor = token & cursor_mask; cursor != (base.token & cursor_mask)) dest.cursor0((si32)(cursor >> netxs::field_offset<cursor_mask>()));
                             if (auto shadow = token & shadow_mask; shadow != (base.token & shadow_mask)) dest.dim(    (si32)(shadow >> netxs::field_offset<shadow_mask>()));
-                            //if (auto hplink = token & hplink_mask; hplink != (base.token & hplink_mask)) dest.hplink0((si32)(hplink >> netxs::field_offset<hplink_mask>()));
-                            //if (auto fusion = token & fusion_mask; fusion != (base.token & fusion_mask)) dest.fusion0((si32)(fusion >> netxs::field_offset<fusion_mask>()));
-                            //todo sync px
-                            //if (auto bitmap = token & bitmap_mask; bitmap != (base.token & bitmap_mask)) dest.bitmap0(!!bitmap);
+                            //todo check image
+                            //if (auto imageH = token & imageH_mask; imageH != (base.token & imageH_mask)) dest.imageH( (ui32)(imageH >> netxs::field_offset<imageH_mask>()));
                         }
                         if constexpr (Mode != svga::vt16) // It is not available in the Linux and Win8 consoles.
                         {
@@ -1523,9 +1710,7 @@ namespace netxs
             void unc(si32 c)         { token &= ~ucolor_mask; token |= ((ui64)(ui32)c << netxs::field_offset<ucolor_mask>()); }
             void cur(si32 s)         { token &= ~cursor_mask; token |= ((ui64)(ui32)s << netxs::field_offset<cursor_mask>()); }
             void mosaic(si32 m)      { token &= ~mosaic_mask; token |= ((ui64)(ui32)m << netxs::field_offset<mosaic_mask>()); }
-            void bitmap(si32 r)      { token &= ~bitmap_mask; token |= ((ui64)(ui32)r << netxs::field_offset<bitmap_mask>()); }
             void  xy(ui64 m)         { token &= ~mosaic_mask; token |= m; }
-            void raw(ui64 r)         { token &= ~bitmap_mask; token |= r; }
             void  xy(si32 x, si32 y) { mosaic(x + (y << y_bits)); }
             void fuse_dim(si32 n)    { token |= (ui64)(ui32)n << netxs::field_offset<shadow_mask>(); }
             void cursor0(si32 c)     { token &= ~cursor_mask; token |= ((ui64)(ui32)c << netxs::field_offset<cursor_mask>()); }
@@ -1538,27 +1723,24 @@ namespace netxs
                 token |= ((ui64)fg << netxs::field_offset<curfgc_mask>());
             }
             //void hplink0(ui64 c) { token &= ~hplink_mask; token |= (ui64)(c << netxs::field_offset<hplink_mask>()); }
-            //void fusion0(ui64 c) { token &= ~fusion_mask; token |= (ui64)(c << netxs::field_offset<fusion_mask>()); }
-
-            bool bld()    const { return !!(token & bolded_mask); }
-            bool itc()    const { return !!(token & italic_mask); }
-            bool inv()    const { return !!(token & invert_mask); }
-            bool ovr()    const { return !!(token & overln_mask); }
-            bool stk()    const { return !!(token & strike_mask); }
-            bool blk()    const { return !!(token & blinks_mask); }
-            bool hid()    const { return !!(token & hidden_mask); }
-            si32 und()    const { return (si32)((token & unline_mask) >> netxs::field_offset<unline_mask>()); }
-            si32 dim()    const { return (si32)((token & shadow_mask) >> netxs::field_offset<shadow_mask>()); }
-            si32 unc()    const { return (si32)((token & ucolor_mask) >> netxs::field_offset<ucolor_mask>()); }
-            si32 cur()    const { return (si32)((token & cursor_mask) >> netxs::field_offset<cursor_mask>()); }
-            //si32 cursor0() const { return (token & cursor_mask); }
-            //si32 hplink0() const { return (token & hplink_mask); }
-            //si32 fusion0() const { return (token & fusion_mask); }
-            ui64  xy()    const { return (token & mosaic_mask); }
-            ui64 raw()    const { return (token & bitmap_mask); }
-            si32 mosaic() const { return (si32)((token & mosaic_mask) >> netxs::field_offset<mosaic_mask>()); }
-            si32 bitmap() const { return (si32)((token & bitmap_mask) >> netxs::field_offset<bitmap_mask>()); }
-            auto cursor_color() const
+
+            constexpr bool bld()    const { return !!(token & bolded_mask); }
+            constexpr bool itc()    const { return !!(token & italic_mask); }
+            constexpr bool inv()    const { return !!(token & invert_mask); }
+            constexpr bool ovr()    const { return !!(token & overln_mask); }
+            constexpr bool stk()    const { return !!(token & strike_mask); }
+            constexpr bool blk()    const { return !!(token & blinks_mask); }
+            constexpr bool hid()    const { return !!(token & hidden_mask); }
+            constexpr si32 und()    const { return (si32)((token & unline_mask) >> netxs::field_offset<unline_mask>()); }
+            constexpr si32 dim()    const { return (si32)((token & shadow_mask) >> netxs::field_offset<shadow_mask>()); }
+            constexpr si32 unc()    const { return (si32)((token & ucolor_mask) >> netxs::field_offset<ucolor_mask>()); }
+            constexpr si32 cur()    const { return (si32)((token & cursor_mask) >> netxs::field_offset<cursor_mask>()); }
+            //constexpr si32 cursor0() const { return (token & cursor_mask); }
+            //constexpr si32 hplink0() const { return (token & hplink_mask); }
+            //constexpr si32 fusion0() const { return (token & fusion_mask); }
+            constexpr ui64  xy()    const { return (token & mosaic_mask); }
+            constexpr si32 mosaic() const { return (si32)((token & mosaic_mask) >> netxs::field_offset<mosaic_mask>()); }
+            constexpr auto cursor_color() const
             {
                 auto bgi = (byte)((token & curbgc_mask) >> netxs::field_offset<curbgc_mask>());
                 auto fgi = (byte)((token & curfgc_mask) >> netxs::field_offset<curfgc_mask>());
@@ -1664,40 +1846,19 @@ namespace netxs
                 fg.wipe();
             }
         };
-        struct pict
-        {
-            ui32 token;
-            constexpr pict()
-                : token{ 0 }
-            { }
-            constexpr pict(pict const& p)
-                : token{ p.token }
-            { }
-
-            constexpr pict& operator = (pict const&) = default;
-            bool operator == (pict const& p) const
-            {
-                return token == p.token;
-            }
-            void wipe()
-            {
-                token = 0;
-            }
-        };
 
         clrs uv; // 8U, cell: Fg and bg colors.
         glyf gc; // 8U, cell: Grapheme cluster.
         body st; // 8U, cell: Style attributes.
-        id_t id; // 4U, cell: Link ID.
-        pict px; // 4U, cell: Reference to the raw bitmap attached to the cell.
+        ui64 px{}; // 8U, cell: Image index and metadata.
+        id_t id{}; // 4U, cell: Link ID.
+        ui32 p2{}; // 4U, cell: Pad. Reserve.
 
         cell()
-            : id{ 0 }
         { }
         cell(char c)
             : gc{ c },
-              st{ utf::matrix::mosaic<11> },
-              id{ 0 }
+              st{ utf::matrix::mosaic<11> }
         {
             // sizeof(glyf);
             // sizeof(clrs);
@@ -1707,7 +1868,6 @@ namespace netxs
             // sizeof(cell);
         }
         cell(view utf8)
-            : id{ 0 }
         {
             txt(utf8);
         }
@@ -1715,15 +1875,15 @@ namespace netxs
             : uv{ base.uv },
               gc{ base.gc },
               st{ base.st },
-              id{ base.id },
-              px{ base.px }
+              px{ base.px },
+              id{ base.id }
         { }
         cell(cell const& base, char c)
             : uv{ base.uv },
               gc{ c       },
               st{ base.st, utf::matrix::mosaic<11> },
-              id{ base.id },
-              px{ base.px }
+              px{ base.px },
+              id{ base.id }
         { }
 
         auto operator == (cell const& c) const
@@ -1742,16 +1902,76 @@ namespace netxs
             uv = c.uv;
             gc = c.gc;
             st = c.st;
-            id = c.id;
             px = c.px;
+            id = c.id;
             return *this;
         }
 
         operator bool () const { return st.xy(); } // cell: Return true if cell contains printable character.
 
+        // Image prop masks:
+        // Internal, stored within the cell:
+        //  bits | value
+        // ------|------
+        //  16   | Image index. ui16
+        //  16   | x fragment. ui16
+        //  16   | y fragment. ui16
+        //  4    | align=[center|left|right][-][middle|top|bottom]
+        //  1    | ontop=0 | 1
+        //  3    | transform=0..7 ([FlipY][FlipX][SwapXY])
+        //  2    | scale=[inside|outside|stretch|none]
+
+        static constexpr auto px_objX_16_mask = (ui64)0b00000000'00000000'00000000'00000000'00000000'00000000'11111111'11111111;
+        static constexpr auto px_objY_16_mask = (ui64)0b00000000'00000000'00000000'00000000'11111111'11111111'00000000'00000000;
+        static constexpr auto px_index16_mask = (ui64)0b00000000'00000000'11111111'11111111'00000000'00000000'00000000'00000000;
+        static constexpr auto px_align_4_mask = (ui64)0b00000000'00001111'00000000'00000000'00000000'00000000'00000000'00000000;
+        static constexpr auto px_xform_3_mask = (ui64)0b00000000'01110000'00000000'00000000'00000000'00000000'00000000'00000000;
+        static constexpr auto px_ontop_1_mask = (ui64)0b00000000'10000000'00000000'00000000'00000000'00000000'00000000'00000000;
+      //static constexpr auto px_rsrvd_8_mask = (ui64)0b11111111'00000000'00000000'00000000'00000000'00000000'00000000'00000000;
+
+        auto get_image_xy() const
+        {
+            auto x = netxs::get_field<px_objX_16_mask>(px);
+            auto y = netxs::get_field<px_objY_16_mask>(px);
+            return twod{ x, y };
+        }
+        auto set_image_xy(si32 x, si32 y)
+        {
+            netxs::set_field<px_objX_16_mask>(x, px);
+            netxs::set_field<px_objY_16_mask>(y, px);
+        }
+        auto get_image_index() const { return (ui16)netxs::get_field<px_index16_mask>(px); }
+        auto get_image_align() const { return       netxs::get_field<px_align_4_mask>(px); }
+        auto get_image_xform() const { return       netxs::get_field<px_xform_3_mask>(px); }
+        auto get_image_ontop() const { return       netxs::get_field<px_ontop_1_mask>(px); }
+        auto set_image_index(si32 n) { netxs::set_field<px_index16_mask>(n, px); }
+        auto set_image_align(si32 n) { netxs::set_field<px_align_4_mask>(n, px); }
+        auto set_image_xform(si32 n) { netxs::set_field<px_xform_3_mask>(n, px); }
+        auto set_image_ontop(si32 n) { netxs::set_field<px_ontop_1_mask>(n, px); }
+        auto set_image_attrs(imagens::image& image, imagens::image::attrs_t& new_attrs)
+        {
+            auto attrs = std::array<si32, imagens::attr_count>{};
+            for (auto i = 0; i < imagens::attr_count; i++)
+            {
+                if (auto v = new_attrs[i]) attrs[i] = (si32)v.value();
+            }
+            set_image_index(image.index);
+            set_image_xy(   attrs[imagens::column   ],
+                            attrs[imagens::row      ]);
+            set_image_align(attrs[imagens::align    ]);
+            set_image_xform(attrs[imagens::transform]);
+            set_image_ontop(attrs[imagens::ontop    ]);
+            return *this;
+        }
+
+        //todo rename to has_image
+        auto raw() const
+        {
+            return !!px;
+        }
         auto is_empty() const // cell: Return true if cell is absolutely empty.
         {
-            return uv.bg.token == 0 && uv.fg.token == 0 && gc.token == 0 && st.token == 0 && id == 0 && px.token == 0;
+            return uv.bg.token == 0 && uv.fg.token == 0 && gc.token == 0 && st.token == 0 && id == 0 && px == 0;
         }
         auto same_txt(cell const& c) const // cell: Compare clusters.
         {
@@ -1761,14 +1981,14 @@ namespace netxs
         {
             return uv == c.uv
                 && st.like(c.st)
-                && (!st.raw() || px == c.px);
+                && (!raw() || px == c.px);
         }
         void wipe() // cell: Set colors, attributes and grapheme cluster to zero.
         {
             uv.wipe();
             gc.wipe();
             st.wipe();
-            px.wipe();
+            px = 0;
         }
         // cell: Blend two cells according to visibility and other attributes.
         auto& fuse(cell const& c)
@@ -1779,10 +1999,9 @@ namespace netxs
             if (uv.bg.chan.a == 0xFF) uv.bg.mix_one(c.uv.bg);
             else                      uv.bg.mix(c.uv.bg);
 
-            if (auto r = c.st.raw())
+            if (c.raw())
             {
                 px = c.px;
-                st.raw(r);
             }
             if (c.st.xy())
             {
@@ -1824,7 +2043,10 @@ namespace netxs
                 st = c.st;
                 gc = c.gc;
             }
-            if (st.raw()) px = c.px;
+            if (raw())
+            {
+                px = c.px;
+            }
         }
         // cell: Blend cell colors.
         void blend(cell const& c)
@@ -1837,10 +2059,9 @@ namespace netxs
         {
             uv.fg.mix(c.uv.fg, alpha);
             uv.bg.mix(c.uv.bg, alpha);
-            if (auto r = c.st.raw())
+            if (c.raw())
             {
                 px = c.px;
-                st.raw(r);
             }
             if (c.st.xy())
             {
@@ -1858,7 +2079,10 @@ namespace netxs
                 gc = c.gc;
                 uv.fg = uv.bg; // The character must be on top of the cell background. (see block graphics)
             }
-            if (st.raw()) px = c.px;
+            if (c.raw())
+            {
+                px = c.px;
+            }
             uv.fg.mix(c.uv.fg, alpha);
             uv.bg.mix(c.uv.bg, alpha);
         }
@@ -1893,7 +2117,7 @@ namespace netxs
             st = c.st;
             if (bg_opaque) uv.bg.mix_one(c.uv.bg);
             else           uv.bg.mix(c.uv.bg);
-            if (c.st.raw())
+            if (c.raw())
             {
                 px = c.px;
             }
@@ -1909,7 +2133,10 @@ namespace netxs
         {
             uv = c.uv;
             st.meta(c.st);
-            px = c.px;
+            if (c.raw())
+            {
+                px = c.px;
+            }
         }
         void skipnulls(cell const& c)
         {
@@ -1922,14 +2149,19 @@ namespace netxs
             }
             else
             {
-                if (c.uv.bg.token == argb::default_color) // Update gc while keeping SGR attributes (if bgc==0x00'FF'FF'FF).
+                gc = c.gc;
+                if (c.uv.bg.token != argb::default_color) // Update gc while keeping SGR attributes (if bgc==0x00'FF'FF'FF).
                 {
-                    gc = c.gc;
-                    st.xy(c.st.xy());
+                    uv = c.uv;
+                    st = c.st;
                 }
                 else // Copy all.
                 {
-                    *this = c;
+                    st.xy(c.st.xy());
+                }
+                if (c.raw())
+                {
+                    px = c.px;
                 }
             }
         }
@@ -2175,7 +2407,7 @@ namespace netxs
         auto& unc(argb c)        { st.unc(c.to_256cube()); return *this; } // cell: Set underline color.
         auto& unc(si32 c)        { st.unc(c);              return *this; } // cell: Set underline color.
         auto& cur(si32 s)        { st.cur(s);              return *this; } // cell: Set cursor style.
-        auto& img(ui32 p)        { px.token = p;           return *this; } // cell: Set attached bitmap.
+        auto& img(ui64 p)        { px = p;                 return *this; } // cell: Set attached image.
         auto& ovr(bool b)        { st.ovr(b);              return *this; } // cell: Set overline attribute.
         auto& inv(bool b)        { st.inv(b);              return *this; } // cell: Set invert attribute.
         auto& stk(bool b)        { st.stk(b);              return *this; } // cell: Set strikethrough attribute.
@@ -2250,41 +2482,41 @@ namespace netxs
             return *this;
         }
 
-        auto  rtl() const  { return gc.rtl();      } // cell: Return RTL attribute.
-        auto  mtx() const  { return gc.mtx();      } // cell: Return cluster matrix size (in cells).
-        auto  len() const  { return gc.len();      } // cell: Return grapheme cluster cell storage length (in bytes).
-        auto  tkn() const  { return gc.token;      } // cell: Return grapheme cluster token.
-        bool  jgc() const  { return gc.jgc();      } // cell: Check the grapheme cluster registration (foreign jumbo clusters).
-        ui64   xy() const  { return st.xy();       } // cell: Return matrix fragment metadata.
+        constexpr auto  rtl() const  { return gc.rtl();      } // cell: Return RTL attribute.
+        constexpr auto  mtx() const  { return gc.mtx();      } // cell: Return cluster matrix size (in cells).
+        constexpr auto  len() const  { return gc.len();      } // cell: Return grapheme cluster cell storage length (in bytes).
+        constexpr auto  tkn() const  { return gc.token;      } // cell: Return grapheme cluster token.
+                  bool  jgc() const  { return gc.jgc();      } // cell: Check the grapheme cluster registration (foreign jumbo clusters).
+        constexpr ui64   xy() const  { return st.xy();       } // cell: Return matrix fragment metadata.
         template<svga Mode = svga::vtrgb>
-        auto  txt() const  { return gc.get<Mode>(); } // cell: Return grapheme cluster.
-        auto& egc()        { return gc;            } // cell: Get grapheme cluster object.
-        auto& egc() const  { return gc;            } // cell: Get grapheme cluster object.
-        auto  clr() const  { return uv.bg || uv.fg;} // cell: Return true if color set.
-        auto  bga() const  { return uv.bg.chan.a;  } // cell: Return background alpha/transparency.
-        auto  fga() const  { return uv.fg.chan.a;  } // cell: Return foreground alpha/transparency.
-        auto& bgc()        { return uv.bg;         } // cell: Return background color.
-        auto& fgc()        { return uv.fg;         } // cell: Return foreground color.
-        auto& bgc() const  { return uv.bg;         } // cell: Return background color.
-        auto& fgc() const  { return uv.fg;         } // cell: Return foreground color.
-        auto  bld() const  { return st.bld();      } // cell: Return bold attribute.
-        auto  itc() const  { return st.itc();      } // cell: Return italic attribute.
-        auto  und() const  { return st.und();      } // cell: Return underline/Underscore attribute.
-        auto  unc() const  { return st.unc();      } // cell: Return underline color.
-        auto  cur() const  { return st.cur();      } // cell: Return cursor style.
-        auto& img()        { return px.token;      } // cell: Return attached bitmap.
-        auto& img() const  { return px.token;      } // cell: Return attached bitmap.
-        auto  ovr() const  { return st.ovr();      } // cell: Return overline attribute.
-        auto  inv() const  { return st.inv();      } // cell: Return negative attribute.
-        auto  stk() const  { return st.stk();      } // cell: Return strikethrough attribute.
-        auto  blk() const  { return st.blk();      } // cell: Return blink attribute.
-        auto  hid() const  { return st.hid();      } // cell: Return hidden attribute.
-        auto  dim() const  { return st.dim();      } // cell: Return shadow attribute.
-        auto& stl()        { return st.token;      } // cell: Return style token.
-        auto& stl() const  { return st.token;      } // cell: Return style token.
-        auto link() const  { return id;            } // cell: Return object ID.
-        auto isspc() const { return gc.is_space(); } // cell: Return true if char is whitespace.
-        auto isnul() const { return gc.is_null();  } // cell: Return true if char is null.
+        constexpr auto  txt() const  { return gc.get<Mode>(); } // cell: Return grapheme cluster.
+        constexpr auto& egc()        { return gc;            } // cell: Get grapheme cluster object.
+        constexpr auto& egc() const  { return gc;            } // cell: Get grapheme cluster object.
+        constexpr auto  clr() const  { return uv.bg || uv.fg;} // cell: Return true if color set.
+        constexpr auto  bga() const  { return uv.bg.chan.a;  } // cell: Return background alpha/transparency.
+        constexpr auto  fga() const  { return uv.fg.chan.a;  } // cell: Return foreground alpha/transparency.
+        constexpr auto& bgc()        { return uv.bg;         } // cell: Return background color.
+        constexpr auto& fgc()        { return uv.fg;         } // cell: Return foreground color.
+        constexpr auto& bgc() const  { return uv.bg;         } // cell: Return background color.
+        constexpr auto& fgc() const  { return uv.fg;         } // cell: Return foreground color.
+        constexpr auto  bld() const  { return st.bld();      } // cell: Return bold attribute.
+        constexpr auto  itc() const  { return st.itc();      } // cell: Return italic attribute.
+        constexpr auto  und() const  { return st.und();      } // cell: Return underline/Underscore attribute.
+        constexpr auto  unc() const  { return st.unc();      } // cell: Return underline color.
+        constexpr auto  cur() const  { return st.cur();      } // cell: Return cursor style.
+        constexpr auto& img()        { return px;            } // cell: Return attached image.
+        constexpr auto& img() const  { return px;            } // cell: Return attached image.
+        constexpr auto  ovr() const  { return st.ovr();      } // cell: Return overline attribute.
+        constexpr auto  inv() const  { return st.inv();      } // cell: Return negative attribute.
+        constexpr auto  stk() const  { return st.stk();      } // cell: Return strikethrough attribute.
+        constexpr auto  blk() const  { return st.blk();      } // cell: Return blink attribute.
+        constexpr auto  hid() const  { return st.hid();      } // cell: Return hidden attribute.
+        constexpr auto  dim() const  { return st.dim();      } // cell: Return shadow attribute.
+        constexpr auto& stl()        { return st.token;      } // cell: Return style token.
+        constexpr auto& stl() const  { return st.token;      } // cell: Return style token.
+        constexpr auto link() const  { return id;            } // cell: Return object ID.
+        constexpr auto isspc() const { return gc.is_space(); } // cell: Return true if char is whitespace.
+        constexpr auto isnul() const { return gc.is_null();  } // cell: Return true if char is null.
         auto issame_visual(cell const& c) const // cell: Is the cell visually identical.
         {
             if (gc == c.gc || (isspc() && c.isspc()))
@@ -2553,26 +2785,31 @@ namespace netxs
             struct color_t
             {
                 clrs colors;
+                bool invert;
                 si32 factor;
                 template<class T>
-                constexpr color_t(T colors, si32 factor = 1)
+                constexpr color_t(T colors, bool invert, si32 factor = 1)
                     : colors{ colors },
+                      invert{ invert },
                       factor{ factor }
                 { }
                 constexpr color_t(cell const& brush, si32 factor = 1)
                     : colors{ brush.uv },
+                      invert{ brush.inv() },
                       factor{ factor }
                 { }
                 template<class T>
                 inline auto operator [] (T param) const
                 {
-                    return color_t{ colors, param };
+                    return color_t{ colors, invert, param };
                 }
                 template<class D>
                 inline void operator () (D& dst) const
                 {
-                    auto b = dst.inv() ? dst.fgc() : dst.bgc();
+                    auto i = dst.inv() ^ invert;;
+                    auto b = i ? dst.fgc() : dst.bgc();
                     dst.uv = colors;
+                    dst.inv(i);
                     //if (b == colors.bg) dst.xlight();
                     if (b == colors.bg) dst.uv.bg.shadow();
                 }
@@ -2622,6 +2859,11 @@ namespace netxs
                     dst.fuse(src, id);
                 }
             };
+            struct image_t : public brush_t<image_t>
+            {
+                template<class C> constexpr inline auto operator () (C brush) const { return func<C>(brush); }
+                template<class D, class S>  inline void operator () (D& dst, S& src) const { dst.px = src.px; }
+            };
 
         public:
             static constexpr auto       color(auto brush) { return       color_t{ brush }; }
@@ -2653,6 +2895,7 @@ namespace netxs
             static constexpr auto   disabled =   disabled_t{};
             static constexpr auto     xlight =     xlight_t{ 1 };
             static constexpr auto underlight = underlight_t{ 1 };
+            static constexpr auto      image =      image_t{};
         };
 
         auto draw_cursor()
@@ -2700,10 +2943,6 @@ namespace netxs
         }
     };
 
-    enum class bias : byte { none, left, right, center, };
-    enum class wrap : byte { none, on,  off,            };
-    enum class rtol : byte { none, rtl, ltr,            };
-
     namespace mime
     {
         static constexpr auto _counter = __COUNTER__ + 1;
@@ -3070,9 +3309,11 @@ namespace netxs
         void  clip(rect new_client)            { client = new_client;                                                       }
         auto  hash() const                     { return digest;                                                             } // core: Return the digest value that associatated with the current canvas size.
         auto  hash(si32 d)                     { return digest != d ? ((void)(digest = d), true) : faux;                    } // core: Check and the digest value that associatated with the current canvas size.
+        template<bool Forced = faux>
         void size(twod new_size, cell const& c) // core: Resize canvas.
         {
-            if (region.size(std::max(dot_00, new_size)))
+            auto changed = region.size(std::max(dot_00, new_size));
+            if (changed || Forced)
             {
                 client.size = region.size;
                 digest++;
@@ -3586,7 +3827,7 @@ namespace netxs::misc
         auto v = r.size.x * r.size.y;
         boxblur_cache.resize(v);
         shadows_cache.resize(v);
-        auto shadows_image = netxs::raster<std::span<fp32>, rect>{ shadows_cache, r };
+        auto shadows_image = netxs::raster<std::span<fp32>>{ shadows_cache, r };
         netxs::misc::cage(shadows_image, shadows_image.area(), dent{ 1, 0, 1, 0 }, [](auto& dst){ dst = 0.f; }); // Clear cached garbage (or uninitialized data) after previous blur (1px border at the top and left sides).
         shadows_image.step(-dot_11);
         netxs::onbody(image, shadows_image, [](auto& src, auto& dst){ dst = src ? 255.f * 3.f : 0.f; }); // Note: Pure black pixels will become invisible/transparent.
diff --git a/src/netxs/desktopio/controls.hpp b/src/netxs/desktopio/controls.hpp
index edc4475b22..4372f45aa7 100644
--- a/src/netxs/desktopio/controls.hpp
+++ b/src/netxs/desktopio/controls.hpp
@@ -660,8 +660,7 @@ namespace netxs::events
     }
 
     auth::auth(bool use_timer)
-        : next_id{ 0 },
-          context_refs{ context },
+        : context_refs{ context },
           luafx{ *this },
           quartz{ *this },
           e2_timer_tick_id{ ui::e2::timer::tick.id },
diff --git a/src/netxs/desktopio/events.hpp b/src/netxs/desktopio/events.hpp
index ad40b77cc3..745f623018 100644
--- a/src/netxs/desktopio/events.hpp
+++ b/src/netxs/desktopio/events.hpp
@@ -291,7 +291,7 @@ namespace netxs::events
             static constexpr auto not_handled = __COUNTER__ - _counter;
         };
 
-        id_t                                      next_id;
+        generics::indexer<id_t>                   id_pool;
         std::recursive_mutex                      mutex;
         std::unordered_map<id_t, std::reference_wrapper<ui::base>>  objects; // auth: Map of objects by object id.
         clasess_umap                              classes; // auth: Map of classes by classname.
@@ -565,11 +565,18 @@ namespace netxs::events
         // auth: Returns the next available id. The default gear has id = 0.
         auto new_id()
         {
-            while (netxs::on_key(objects, next_id))
+            auto id = id_pool.get_new();
+            if (!id) [[unlikely]]
             {
-                next_id++;
+                log("%%No object indexes available", prompt::auth);
+                std::terminate();
             }
-            return next_id++;
+            return id;
+        }
+        // auth: Returns the next available id.
+        auto release_id(id_t id)
+        {
+            id_pool.release(id);
         }
         // auth: .
         template<bool Sync = true>
@@ -895,7 +902,10 @@ namespace netxs::events
             : indexer{ indexer },
               id{ indexer.new_id() }
         { }
-        virtual ~bell() = default;
+        virtual ~bell()
+        {
+            indexer.release_id(id);
+        }
     };
 }
 namespace netxs
diff --git a/src/netxs/desktopio/generics.hpp b/src/netxs/desktopio/generics.hpp
index b6df2e2083..ff77e4e3fb 100644
--- a/src/netxs/desktopio/generics.hpp
+++ b/src/netxs/desktopio/generics.hpp
@@ -1189,6 +1189,110 @@ namespace netxs::generics
             empty_key = ui32max;
         }
     };
+
+    // generics: Object cache.
+    template<class T, class Key = ui64>
+    struct cache
+    {
+    protected:
+        using lock = std::mutex;
+        using sync = std::lock_guard<lock>;
+        using depo = std::unordered_map<Key, T>;
+        using uset = std::unordered_set<Key>;
+
+        lock mutex{}; // Object map mutex.
+        depo store{}; // Object map.
+        uset undef{}; // List of unknown tokens.
+
+        struct guard : sync
+        {
+            depo& map;
+            uset& unk;
+
+            guard(cache& inst)
+                : sync{ inst.mutex },
+                   map{ inst.store },
+                   unk{ inst.undef }
+            { }
+
+            // cache: Get object.
+            auto& get(Key token)
+            {
+                if (auto iter = map.find(token); iter != map.end())
+                {
+                    return iter->second;
+                }
+                else
+                {
+                    static auto empty_object = T{};
+                    unk.insert(token);
+                    return empty_object;
+                }
+            }
+            // cache: Set object.
+            void set(Key token, auto&& object)
+            {
+                map[token] = std::forward<decltype(object)>(object);
+            }
+            // cache: Add object.
+            void add(Key token, auto&& object)
+            {
+                map.insert(std::pair{ token, std::forward<decltype(object)>(object) }); // Silently ignore if it exists.
+            }
+            // cache: Remove object.
+            void remove(Key token)
+            {
+                map.erase(token);
+            }
+            // cache: Check the object existence by token.
+            auto exists(Key token)
+            {
+                auto iter = map.find(token);
+                auto okay = iter != map.end();
+                if (!okay) unk.insert(token);
+                return okay;
+            }
+        };
+
+    public:
+        auto storage()
+        {
+            return guard{ *this };
+        }
+    };
+
+    // generics: Index manager.
+    template<class T>
+    struct indexer
+    {
+        T              next_index{};
+        std::vector<T> free_indices;
+
+        indexer(size_t expected_max_free = 2048)
+        {
+            free_indices.reserve(expected_max_free);
+        }
+        // indexer: Return the new index. Returns 0 if there are no indices available.
+        auto get_new()
+        {
+            if (!free_indices.empty())
+            {
+                auto id = free_indices.back();
+                free_indices.pop_back();
+                return id;
+            }
+            if (next_index == std::numeric_limits<T>::max() - 1) [[unlikely]]
+            {
+                return T{};
+            }
+            return ++next_index;
+        }
+        // indexer: Make index available.
+        void release(T id)
+        {
+            free_indices.push_back(id);
+        }
+    };
 }
 
 // generics: Map helpers.
diff --git a/src/netxs/desktopio/geometry.hpp b/src/netxs/desktopio/geometry.hpp
index e5abd79989..0d350f8892 100644
--- a/src/netxs/desktopio/geometry.hpp
+++ b/src/netxs/desktopio/geometry.hpp
@@ -336,10 +336,10 @@ namespace netxs
         // rect: Return rect with top-left orientation.
         constexpr rect normalize() const
         {
-            auto sx = size.x < 0;
-            auto sy = size.y < 0;
-            return {{ sx ?  coor.x + size.x : coor.x, sy ?  coor.y + size.y : coor.y },
-                    { sx ? -size.x : size.x         , sy ? -size.y : size.y          }};
+            auto r = *this;
+            if (r.size.x < 0) { r.coor.x = r.coor.x + r.size.x; r.size.x = -r.size.x; }
+            if (r.size.y < 0) { r.coor.y = r.coor.y + r.size.y; r.size.y = -r.size.y; }
+            return r;
         }
         // rect: Set top-left orientation.
         constexpr auto& normalize_itself()
@@ -375,6 +375,36 @@ namespace netxs
             if constexpr (sizeof...(rn)) return unite(ur, rn...);
             else                         return ur;
         }
+        // rect: *this in global coords. Take the relative child and return it in global coordinates applying xform. Transform D4 (3 bits: 0b[FlipY][FlipX][Swap]) the child rectangle and return it in global coordinates.
+        rect transform(rect relative_child, si32 xform) const
+        {
+            auto p = relative_child.coor;
+            auto s = relative_child.size;
+            auto psz = size;
+            if (xform & 0b001) // SwapXY
+            {
+                std::swap(p.x, p.y);
+                std::swap(s.x, s.y);
+                std::swap(psz.x, psz.y);
+            }
+            if (xform & 0b010) p.x = psz.x - p.x - s.x; // Flip X
+            if (xform & 0b100) p.y = psz.y - p.y - s.y; // Flip Y
+            return { coor + p, s };
+        }
+        // rect: *this in global coords. Take the global child element and return it to relative coordinates, undoing the transform (xform).
+        rect untransform(rect global_child, si32 xform) const
+        {
+            auto p = global_child.coor - coor;
+            auto s = global_child.size;
+            if (xform & 0b100) p.y = size.y - p.y - s.y;
+            if (xform & 0b010) p.x = size.x - p.x - s.x;
+            if (xform & 0b001)
+            {
+                std::swap(p.x, p.y);
+                std::swap(s.x, s.y);
+            }
+            return { p, s };
+        }
         // rect: Return true in case of normalized rectangles are overlapped.
         constexpr bool overlap(rect r) const
         {
@@ -703,4 +733,188 @@ namespace netxs
         if constexpr (std::is_same_v<T, twod>) return { dot_00, p };
         else                                   return { dot_00, { (si32)p,  1 } };
     }
+
+    // geometry: Generic bitmap.
+    template<class T>
+    struct raster
+    {
+        using base = T;
+        base _data;
+        rect _area;
+        rect _clip;
+        auto length() const { return _data.length(); }
+        auto  begin()       { return _data.begin();  }
+        auto  begin() const { return _data.begin();  }
+        auto   data()       { return _data.data();   }
+        auto   data() const { return _data.data();   }
+        auto    end()       { return _data.end();    }
+        auto    end() const { return _data.end();    }
+        auto&  clip()       { return _clip;          }
+        auto&  clip() const { return _clip;          }
+        auto&  area()       { return _area;          }
+        auto&  area() const { return _area;          }
+        auto   clip(auto c) { _clip = c;             }
+        void   step(auto s) { _area.coor += s;       }
+        void   move(auto p) { _area.coor = p;        }
+        auto&  size()       { return _area.size;     }
+        auto&  size() const { return _area.size;     }
+        auto&  coor()       { return _area.coor;     }
+        auto&  coor() const { return _area.coor;     }
+        auto& operator [] (auto p) { return *(begin() + p.x + p.y * _area.size.x); }
+        void size(auto new_size, auto... filler)
+        {
+            _area.size = new_size;
+            _data.resize(new_size.x * new_size.y, filler...);
+        }
+        void zeroize()
+        {
+            std::fill(_data.begin(), _data.end(), std::decay_t<decltype(*begin())>{});
+        }
+        raster() = default;
+        raster(T data, rect area)
+            : _data{ data },
+              _area{ area }
+        { }
+    };
+
+    // geometry: Color/monochromatic sprite.
+    struct sprite
+    {
+        using vect = std::pmr::vector<ui32>; // Use ui32 for 4-byte alignment (aarch requirement).
+
+        static constexpr auto undef = 0;
+        static constexpr auto alpha = 1; // Grayscale AA bitmap alphamix. byte-based. fx: pixel = blend(pixel, fgc, byte).
+        static constexpr auto color = 2; // irgb-colored bitmap colormix. irgb-based. fx: pixel = blend(blend(pixel, irgb.alpha(irgb.chan.a - (si32)irgb.chan.a)), fgc, (si32)irgb.chan.a - 256).
+
+        vect bits; // sprite: Contains: type=alpha: bytes [0-255]; type=color: irgb<fp32>.
+        rect area; // sprite: Bitmap black-box.
+        si32 type; // sprite: Bitmap type.
+
+        sprite(auto& pool)
+            : bits{ &pool },
+              type{ undef }
+        { }
+
+        template<class Elem>
+        auto raster()
+        {
+            return netxs::raster{ std::span{ (Elem*)bits.data(), bits.size() * sizeof(ui32) / sizeof(Elem) }, area };
+        }
+        // sprite: Resize sprite.
+        template<class irgb>
+        void set_area(rect new_area, bool is_colored = true)
+        {
+            area = new_area;
+            type = is_colored ? sprite::color : sprite::alpha;
+            auto pixel_size = is_colored ? sizeof(irgb) : sizeof(byte);
+            if (auto new_length = new_area.length() * pixel_size)
+            {
+                bits.resize(netxs::udivupper(new_length, sizeof(ui32)));
+            }
+        }
+        // sprite: Returns the minimum opaque area within the PMA fp32 sprite.
+        template<class irgb>
+        auto get_minimal_non_transparent_area_for_pma()
+        {
+            auto crop = rect{};
+            auto w = area.size.x;
+            auto h = area.size.y;
+            auto image_raster = raster<irgb>();
+            auto data = image_raster._data;
+            assert(area.length() <= data.size()); // Invalid sprite element type.
+            auto get_row = [&](si32 y){ return data.subspan(y * w, w); };
+            auto y0 = 0;
+            auto is_visible = [](irgb p){ return p.a != 0; };
+            while (y0 < h && std::none_of(get_row(y0).begin(), get_row(y0).end(), is_visible)) // Top bound.
+            {
+                y0++;
+            }
+            if (y0 != h)
+            {
+                auto y1 = h - 1;
+                while (y1 > y0 && std::none_of(get_row(y1).begin(), get_row(y1).end(), is_visible)) // Bottom bound.
+                {
+                    y1--;
+                }
+                auto x0 = w;
+                auto x1 = -1;
+                for (auto y = y0; y <= y1; ++y) // Look inside [y0, y1].
+                {
+                    auto row = get_row(y);
+                    auto first = std::find_if(row.begin(), row.end(), is_visible);
+                    if (first != row.end())
+                    {
+                        x0 = std::min(x0, (si32)std::distance(row.begin(), first)); // Left.
+                        auto last = std::find_if(row.rbegin(), row.rend(), is_visible);
+                        x1 = std::max(x1, (si32)(w - 1 - std::distance(row.rbegin(), last))); // Right.
+                    }
+                    if (x0 == 0 && x1 == w - 1) break; // Maximum possible found.
+                }
+                crop = {{ x0, y0 }, { x1 - x0 + 1, y1 - y0 + 1 }};
+            }
+            return crop;
+        }
+        // sprite: Perform Dihedral group (D4) transformations on the image raster ("push-based" iterate over source) (8 combinations of rotations and reflections).
+        template<class irgb>
+        void transform(si32 flip_swap, twod matrix)
+        {
+            static thread_local auto buffer = std::vector<ui32>{}; // Use ui32 for 4-byte alignment (aarch requirement).
+            buffer.assign(bits.begin(), bits.end());
+            auto xform = [&](auto elem)
+            {
+                using type = decltype(elem);
+                auto src = std::span{ (type*)buffer.data(), (size_t)area.length() };
+                auto dst = std::span{ (type*)bits.data(),   (size_t)area.length() };
+                auto src_ptr = src.begin();
+                auto dst_ptr = dst.begin();
+                auto src_sz = area.size;
+                auto dst_dx = 1;
+                auto dst_dy = area.size.x;
+                auto src_dy = area.size.x;
+                if (flip_swap & 0b010) // Flip X before swap!
+                {
+                    area.coor.x = matrix.x - area.coor.x - area.size.x;
+                }
+                if (flip_swap & 0b100) // Flip Y before swap!
+                {
+                    area.coor.y = matrix.y - area.coor.y - area.size.y;
+                }
+                if (flip_swap & 0b001) // SwapXY.
+                {
+                    std::swap(area.size.x, area.size.y);
+                    std::swap(area.coor.x, area.coor.y);
+                    dst_dx = src_sz.y;
+                    dst_dy = 1;
+                }
+                if (flip_swap & 0b010) // Flip X after swap!
+                {
+                    dst_ptr += (src_sz.x - 1) * dst_dx;
+                    dst_dx = -dst_dx;
+                }
+                if (flip_swap & 0b100) // Flip Y after swap!
+                {
+                    dst_ptr += (src_sz.y - 1) * dst_dy;
+                    dst_dy = -dst_dy;
+                }
+                auto h = src_sz.y;
+                while (true)
+                {
+                    auto s_ptr = src_ptr;
+                    auto d_ptr = dst_ptr;
+                    auto w = src_sz.x;
+                    while (true)
+                    {
+                        *d_ptr = *s_ptr;
+                        if (--w == 0) break;
+                        s_ptr++;
+                        d_ptr += dst_dx;
+                    }
+                    if (--h == 0) break;
+                    src_ptr += src_dy;
+                    dst_ptr += dst_dy;
+                }
+            };
+            type == sprite::color ? xform(irgb{}) : xform(byte{});
+        }
+    };
 }
\ No newline at end of file
diff --git a/src/netxs/desktopio/gui.hpp b/src/netxs/desktopio/gui.hpp
index fcf72fc4ec..9168eec3b2 100644
--- a/src/netxs/desktopio/gui.hpp
+++ b/src/netxs/desktopio/gui.hpp
@@ -3,17 +3,6 @@
 
 #pragma once
 
-#include <ft2build.h>
-#include FT_FREETYPE_H
-#include FT_TRUETYPE_TABLES_H
-#include FT_MULTIPLE_MASTERS_H
-#include FT_SFNT_NAMES_H
-#include FT_COLOR_H
-#include FT_OTSVG_H
-
-#include <hb-ft.h>
-#include <lunasvg.h>
-
 #if defined(_WIN32)
     #undef GetGlyphIndices
     #include <msctf.h>      // TSF
@@ -31,9 +20,9 @@ namespace netxs::gui
     namespace e2 = netxs::events::userland::e2;
 
     using namespace ui;
-    using bits = netxs::raster<std::span<argb>, rect>;
+    using bits = netxs::raster<std::span<argb>>;
     using byts = std::vector<byte>;
-    using gray = netxs::raster<byts, rect>;
+    using gray = netxs::raster<byts>;
     using shad = netxs::misc::shadow<gray>;
 
     static constexpr auto debug_foci = faux;
@@ -188,7 +177,7 @@ namespace netxs::gui
             axis_rec_t             weight_target{};
             axis_rec_t             italic_target{};
             std::vector<irgb>      palette; // CPAL cached palette in rgb-linear space.
-            std::unordered_map<si32, std::array<uptr<lunasvg::Document>, 3>> svg_cache; // Face specific SVG-document cache. We storing several documents for the currentColor workaround.
+            std::unordered_map<si32, imagens::docs> svg_cache; // Face specific SVG-document cache. We storing several documents for the currentColor workaround.
 
             auto get_weight_str() const
             {
@@ -1519,29 +1508,7 @@ namespace netxs::gui
     struct glyph
     {
         using irgb = netxs::irgb<fp32>;
-        using vect = std::pmr::vector<ui32>; // Use ui32 for 4-byte alignment (aarch requirement).
-
-        struct sprite
-        {
-            static constexpr auto undef = 0;
-            static constexpr auto alpha = 1; // Grayscale AA glyph alphamix. byte-based. fx: pixel = blend(pixel, fgc, byte).
-            static constexpr auto color = 2; // irgb-colored glyph colormix. irgb-based. fx: pixel = blend(blend(pixel, irgb.alpha(irgb.chan.a - (si32)irgb.chan.a)), fgc, (si32)irgb.chan.a - 256).
-
-            vect bits; // sprite: Contains: type=alpha: bytes [0-255]; type=color: irgb<fp32>.
-            rect area; // sprite: Glyph mask black-box.
-            si32 type; // sprite: Glyph mask type.
 
-            sprite(auto& pool)
-                : bits{ &pool },
-                  type{ undef }
-            { }
-
-            template<class Elem>
-            auto raster()
-            {
-                return netxs::raster{ std::span{ (Elem*)bits.data(), bits.size() * sizeof(ui32) / sizeof(Elem) }, area };
-            }
-        };
         struct synthetic
         {
             static constexpr auto _counter = 1 + __COUNTER__;
@@ -1858,7 +1825,7 @@ namespace netxs::gui
             {
                 auto dst_base = intersect.coor - canvas_area.coor;
                 auto src_base = intersect.coor - layer_area.coor;
-                auto* src_data = (ui32*)svg_btm.data(); 
+                auto* src_data = (ui32*)svg_btm.data();
                 auto src_stride = svg_btm.stride() / sizeof(argb);
                 for (auto y = 0; y < intersect.size.y; ++y)
                 {
@@ -1893,7 +1860,7 @@ namespace netxs::gui
                 }
             }
         }
-        void draw_svg_to_canvas(auto& canvas, 
+        void draw_svg_to_canvas(auto& canvas,
                                 lunasvg::Bitmap const& bitmap_black, // currentColor = #000000
                                 lunasvg::Bitmap const& bitmap_trans, // currentColor = 0x00000000
                                 lunasvg::Bitmap const& bitmap_white, // currentColor = #FFFFFF
@@ -1919,7 +1886,7 @@ namespace netxs::gui
                 for (auto x = 0; x < intersect.size.x; ++x)
                 {
                     auto white_px = argb{ r_white[x] };
-                    if (white_px.chan.a > 0) 
+                    if (white_px.chan.a > 0)
                     {
                         auto dst_xy = twod{ dst_base.x + x, dst_base.y + y };
                         auto& dst_px = canvas[dst_xy];
@@ -1975,6 +1942,170 @@ namespace netxs::gui
                 pos = crop.rfind("var(", pos - 1);
             }
         }
+        auto generate_DOM(std::span<char> svg_data)
+        {
+            resolveOTSVGVariables(svg_data);
+            // currentColor test
+            //auto test_view = view{ svg_data.data(), svg_data.size() };
+            ////auto test_cc = utf::replace_all(test_view, "gold", "currentColor");
+            //auto test_cc = utf::replace_all(test_view, "#C90900", "currentColor");
+            //svg_data = test_cc;
+            auto change_currentColor = [](std::span<char> data, view colorString) -> auto& // Workaround for currentColor.
+            {
+                static thread_local auto matches = std::vector<ui64>{}; // List of currentColors positions within the document.
+                matches.clear();
+                if (colorString.size() <= "currentColor"sv.size())
+                {
+                    auto pos = ui64{};
+                    auto crop = view{ data.data(), data.size() };
+                    while((pos = crop.find("currentColor", pos)) != text::npos)
+                    {
+                        matches.push_back(pos);
+                        std::copy(colorString.begin(), colorString.end(), data.begin() + pos); // "#556677"
+                        auto end = pos + "currentColor"sv.size();
+                        pos += colorString.size();
+                        std::fill(data.begin() + pos, data.begin() + end, ' '); // Trailing spaces.
+                        pos = end;
+                    }
+                }
+                return matches;
+            };
+            auto& matches = change_currentColor(svg_data, "#000000"); // Set black (default) for the currentColor if it is.
+            auto document_black = lunasvg::Document::loadFromData(svg_data.data(), svg_data.size());
+            //auto document_black = uptr<lunasvg::Document>{};
+            auto document_trans = uptr<lunasvg::Document>{};
+            auto document_white = uptr<lunasvg::Document>{};
+            if (!document_black) // Fallback to \uFFFD "�".
+            {
+                static constexpr auto badsvg = R"==(<svg viewBox="0 0 1000 1000">
+                                                        <path d="M 500,50 950,500 500,950 50,500 Z m -46.53619,594.80924 h 93.07238 v 93.07237 H 453.46381 Z M 430,381.07084 c 0,-50 30,-80 70,-80 40,0 70,30 70,80 0,50 -30,70 -55,95 -35,35 -45,65 -45,115 h 60 c 0,-30 10,-50 35,-75 25,-25 65,-60 65,-135 0,-80 -55,-140 -130,-140 -75,0 -130,60 -130,140 z" fill="currentColor" fill-rule="evenodd" />
+                                                    </svg>)=="sv;
+                auto black = utf::replace_all(badsvg, "currentColor", "#000000");
+                document_black = lunasvg::Document::loadFromData(black.data(), black.size());
+                auto trans = utf::replace_all(badsvg, "currentColor", "transparent");
+                document_trans = lunasvg::Document::loadFromData(trans.data(), trans.size());
+                auto white = utf::replace_all(badsvg, "currentColor", "#FFFFFF");
+                document_white = lunasvg::Document::loadFromData(white.data(), white.size());
+            }
+            else if (document_black && matches.size()) // We have currentColors. Generate addidtional document layers.
+            {
+                                                // "currentColor"
+                static constexpr auto pure_trans = "transparent "sv;
+                static constexpr auto pure_white = "#FFFFFF     "sv;
+                for (auto pos : matches)
+                {
+                    std::copy(pure_trans.begin(), pure_trans.end(), svg_data.begin() + pos);
+                }
+                document_trans = lunasvg::Document::loadFromData(svg_data.data(), svg_data.size());
+                for (auto pos : matches)
+                {
+                    std::copy(pure_white.begin(), pure_white.end(), svg_data.begin() + pos);
+                }
+                document_white = lunasvg::Document::loadFromData(svg_data.data(), svg_data.size());
+            }
+            return std::to_array({ std::move(document_black),
+                                   std::move(document_trans),
+                                   std::move(document_white) });
+        }
+        void rasterize_glyph_DOM(auto& canvas, imagens::docs& svg_DOM, qiew sub_id, rect area)
+        {
+            static thread_local auto bitmaps = std::array<lunasvg::Bitmap, 3>();
+
+            auto& [document_black_ptr, document_trans_ptr, document_white_ptr] = svg_DOM;
+            if (!document_black_ptr) return;
+            auto w = area.size.x;
+            auto h = area.size.y;
+            auto render_bitmap = [&](auto& document_ptr, auto& bitmap)
+            {
+                auto& document = *document_ptr;
+                auto element = [&]
+                {
+                    if (sub_id.empty()) return document.documentElement();
+                    auto e = document.getElementById(sub_id);
+                    if (!e) // Render a whole document if sub_id not found.
+                    {
+                        e = document.documentElement();
+                    }
+                    return e;
+                }();
+                auto bounds = element.getBoundingBox().transform(element.getLocalMatrix());
+                auto scale = std::min(w / bounds.w, h / bounds.h);
+                auto tx = (w - bounds.w * scale) / 2.f - bounds.x * scale;
+                auto ty = (h - bounds.h * scale) / 2.f - bounds.y * scale;
+                auto matrix = lunasvg::Matrix{ scale, 0, 0, scale, tx, ty };
+                if (bitmap.height() < h || bitmap.width() < w)
+                {
+                    bitmap = { w, h };
+                }
+                else
+                {
+                    bitmap.clear(0);
+                }
+                element.render(bitmap, matrix); // Premultiplied ARGB32 pixel data.
+            };
+            render_bitmap(document_black_ptr, bitmaps[0]);
+            if (document_trans_ptr)
+            {
+                render_bitmap(document_trans_ptr, bitmaps[1]);
+                render_bitmap(document_white_ptr, bitmaps[2]);
+                draw_svg_to_canvas(canvas, bitmaps[0], bitmaps[1], bitmaps[2], area);
+            }
+            else
+            {
+                draw_svg_to_canvas(canvas, bitmaps[0], area);
+            }
+        }
+        void rasterize_svg_DOM(auto& canvas, imagens::docs& svg_DOM, fp2d original_doc_size_fpx, qiew sub_id, bool keep_ratio)
+        {
+            static thread_local auto bitmaps = std::array<lunasvg::Bitmap, 3>();
+
+            auto& [document_black_ptr, document_trans_ptr, document_white_ptr] = svg_DOM;
+            if (!document_black_ptr) return;
+            auto area = canvas.area();
+            auto w = area.size.x;
+            auto h = area.size.y;
+            auto render_bitmap = [&](auto& document_ptr, auto& bitmap)
+            {
+                if (bitmap.height() < h || bitmap.width() < w)
+                {
+                    bitmap = { w, h };
+                }
+                else
+                {
+                    bitmap.clear(0);
+                }
+                auto& document = *document_ptr;
+                auto element = sub_id.empty() ? document.documentElement()
+                                              : document.getElementById(sub_id);
+                if (element) // Draw nothing if sub_id is not found.
+                {
+                    auto bounds = original_doc_size_fpx;
+                    auto scale = fp2d{ area.size.x / bounds.x, area.size.y / bounds.y };
+                    if (keep_ratio)
+                    {
+                        auto r = std::min(scale.x, scale.y);
+                        scale = { r, r };
+                    }
+                    auto matrix = lunasvg::Matrix{ scale.x, 0, 0, scale.y, 0, 0 };
+                    if (sub_id && element != document.documentElement())
+                    {
+                        matrix *= element.getGlobalMatrix();
+                    }
+                    element.render(bitmap, matrix); // Premultiplied ARGB32 pixel data.
+                }
+            };
+            render_bitmap(document_black_ptr, bitmaps[0]);
+            if (document_trans_ptr)
+            {
+                render_bitmap(document_trans_ptr, bitmaps[1]);
+                render_bitmap(document_white_ptr, bitmaps[2]);
+                draw_svg_to_canvas(canvas, bitmaps[0], bitmaps[1], bitmaps[2], area);
+            }
+            else
+            {
+                draw_svg_to_canvas(canvas, bitmaps[0], area);
+            }
+        }
         void rasterize_single_run(sprite& glyph_mask, fp2d base_line, fonts::shaper& fs, bool monochromatic, bool antialiasing)
         {
             auto run_area = rect{};
@@ -2041,10 +2172,7 @@ namespace netxs::gui
             if (run_area)
             {
                 pen = base_line;
-                glyph_mask.area = run_area;
-                glyph_mask.type = is_colored ? sprite::color : sprite::alpha;
-                auto pixel_size = is_colored ? sizeof(irgb) : sizeof(byte);
-                glyph_mask.bits.resize(netxs::udivupper(run_area.length() * pixel_size, sizeof(ui32)));
+                glyph_mask.set_area<irgb>(run_area, is_colored);
                 auto render_fx = [&](auto canvas)
                 {
                     for (auto& glyph : fs.glyphs) // Rasterize.
@@ -2095,114 +2223,12 @@ namespace netxs::gui
                                     if (svg_doc_iter == svg_cache.end())
                                     {
                                         auto svg_data = std::span{ (char*)doc->svg_document, doc->svg_document_length };
-                                        resolveOTSVGVariables(svg_data);
-
-                                        // currentColor test
-                                        //auto test_view = view{ svg_data.data(), svg_data.size() };
-                                        ////auto test_cc = utf::replace_all(test_view, "gold", "currentColor");
-                                        //auto test_cc = utf::replace_all(test_view, "#C90900", "currentColor");
-                                        //svg_data = test_cc;
-
-                                        auto change_currentColor = [](std::span<char> data, view colorString) -> auto& // Workaround for currentColor.
-                                        {
-                                            static thread_local auto matches = std::vector<ui64>{}; // List of currentColors positions within the document.
-                                            matches.clear();
-                                            if (colorString.size() <= "currentColor"sv.size())
-                                            {
-                                                auto pos = ui64{};
-                                                auto crop = view{ data.data(), data.size() };
-                                                while((pos = crop.find("currentColor", pos)) != text::npos)
-                                                {
-                                                    matches.push_back(pos);
-                                                    std::copy(colorString.begin(), colorString.end(), data.begin() + pos); // "#556677"
-                                                    auto end = pos + "currentColor"sv.size();
-                                                    pos += colorString.size();
-                                                    std::fill(data.begin() + pos, data.begin() + end, ' '); // Trailing spaces.
-                                                    pos = end;
-                                                }
-                                            }
-                                            return matches;
-                                        };
-                                        auto& matches = change_currentColor(svg_data, "#000000"); // Set black (default) for the currentColor if it is.
-                                        auto document_black = lunasvg::Document::loadFromData(svg_data.data(), svg_data.size());
-                                        //auto document_black = uptr<lunasvg::Document>{};
-                                        auto document_trans = uptr<lunasvg::Document>{};
-                                        auto document_white = uptr<lunasvg::Document>{};
-                                        if (!document_black) // Fallback to \uFFFD "�".
-                                        {
-                                            static constexpr auto replacement_svg_0 = R"==(<svg viewBox="0 0 1000 1000">
-                                                                                              <path d="M 500,50 950,500 500,950 50,500 Z m -46.53619,594.80924 h 93.07238 v 93.07237 H 453.46381 Z M 430,381.07084 c 0,-50 30,-80 70,-80 40,0 70,30 70,80 0,50 -30,70 -55,95 -35,35 -45,65 -45,115 h 60 c 0,-30 10,-50 35,-75 25,-25 65,-60 65,-135 0,-80 -55,-140 -130,-140 -75,0 -130,60 -130,140 z" fill="currentColor" fill-rule="evenodd" />
-                                                                                           </svg>)=="sv;
-                                            auto black = utf::replace_all(replacement_svg_0, "currentColor", "#000000");
-                                            document_black = lunasvg::Document::loadFromData(black.data(), black.size());
-                                            auto trans = utf::replace_all(replacement_svg_0, "currentColor", "transparent");
-                                            document_trans = lunasvg::Document::loadFromData(trans.data(), trans.size());
-                                            auto white = utf::replace_all(replacement_svg_0, "currentColor", "#FFFFFF");
-                                            document_white = lunasvg::Document::loadFromData(white.data(), white.size());
-                                        }
-                                        else if (document_black && matches.size()) // We have currentColors. Generate addidtional document layers.
-                                        {
-                                                                            // "currentColor"
-                                            static constexpr auto pure_trans = "transparent "sv;
-                                            static constexpr auto pure_white = "#FFFFFF     "sv;
-                                            for (auto pos : matches)
-                                            {
-                                                std::copy(pure_trans.begin(), pure_trans.end(), svg_data.begin() + pos);
-                                            }
-                                            document_trans = lunasvg::Document::loadFromData(svg_data.data(), svg_data.size());
-                                            for (auto pos : matches)
-                                            {
-                                                std::copy(pure_white.begin(), pure_white.end(), svg_data.begin() + pos);
-                                            }
-                                            document_white = lunasvg::Document::loadFromData(svg_data.data(), svg_data.size());
-                                        }
-                                        svg_doc_iter = svg_cache.emplace(svg_doc_id, std::to_array({ std::move(document_black),
-                                                                                                     std::move(document_trans),
-                                                                                                     std::move(document_white) })).first;
-                                    }
-                                    if (svg_doc_iter != svg_cache.end())
-                                    if (auto& [document_black_ptr, document_trans_ptr, document_white_ptr] = svg_doc_iter->second; document_black_ptr)
-                                    {
-                                        static thread_local auto glyph_id = text{};
-                                        static thread_local auto bitmaps = std::array<lunasvg::Bitmap, 3>();
-                                        glyph_id = "glyph" + std::to_string(glyph.index); // According to the OT-SVG standard, each glyph within a document must be contained within an element with id="glyph<index>".
-                                        auto w = glyph.b_box.size.x;
-                                        auto h = glyph.b_box.size.y;
-                                        auto render_bitmap = [&](auto& document_ptr, auto& bitmap)
-                                        {
-                                            auto& document = *document_ptr;
-                                            auto element = document.getElementById(glyph_id);
-                                            if (!element) // Render a whole document if glyph not found.
-                                            {
-                                                element = document.documentElement();
-                                            }
-                                            auto bounds = element.getBoundingBox().transform(element.getLocalMatrix());
-                                            auto scale = std::min(w / bounds.w, h / bounds.h);
-                                            auto tx = (w - bounds.w * scale) / 2.f - bounds.x * scale;
-                                            auto ty = (h - bounds.h * scale) / 2.f - bounds.y * scale;
-                                            auto matrix = lunasvg::Matrix{ scale, 0, 0, scale, tx, ty };
-                                            if (bitmap.height() < h || bitmap.width() < w)
-                                            {
-                                                bitmap = { w, h };
-                                            }
-                                            else
-                                            {
-                                                bitmap.clear(0);
-                                            }
-                                            element.render(bitmap, matrix); // Premultiplied ARGB32 pixel data.
-                                        };
-                                        render_bitmap(document_black_ptr, bitmaps[0]);
-                                        if (document_trans_ptr)
-                                        {
-                                            render_bitmap(document_trans_ptr, bitmaps[1]);
-                                            render_bitmap(document_white_ptr, bitmaps[2]);
-                                            draw_svg_to_canvas(canvas, bitmaps[0], bitmaps[1], bitmaps[2], glyph.b_box);
-                                        }
-                                        else
-                                        {
-                                            draw_svg_to_canvas(canvas, bitmaps[0], glyph.b_box);
-                                        }
+                                        auto svg_DOM = generate_DOM(svg_data);
+                                        svg_doc_iter = svg_cache.emplace(svg_doc_id, std::move(svg_DOM)).first;
                                     }
+                                    static thread_local auto glyph_id = text{};
+                                    glyph_id = "glyph" + std::to_string(glyph.index); // According to the OT-SVG standard, each glyph within a document must be contained within an element with id="glyph<index>".
+                                    rasterize_glyph_DOM(canvas, svg_doc_iter->second, glyph_id, glyph.b_box);
                                 }
                             }
                         }
@@ -2227,7 +2253,7 @@ namespace netxs::gui
             if (c.xy() == 0) return;
             auto code_iter = utf::cpit{ c.txt() };
             codepoints.clear();
-            auto flipandrotate = 0;
+            auto flip_swap = 0;
             auto monochromatic = faux;
             auto img_alignment = bind{ snap::none, snap::none };
             while (code_iter)
@@ -2237,11 +2263,11 @@ namespace netxs::gui
                 {
                          if (codepoint.cdpoint == utf::vs15_code) monochromatic = true;
                     else if (codepoint.cdpoint == utf::vs16_code) monochromatic = faux;
-                    else if (codepoint.cdpoint == utf::vs10_code) flipandrotate = (flipandrotate & 0b100) | ((flipandrotate + 0b001) & 0b011); // +90°  CCW
-                    else if (codepoint.cdpoint == utf::vs11_code) flipandrotate = (flipandrotate & 0b100) | ((flipandrotate + 0b010) & 0b011); // +180° CCW
-                    else if (codepoint.cdpoint == utf::vs12_code) flipandrotate = (flipandrotate & 0b100) | ((flipandrotate + 0b011) & 0b011); // +270° CCW
-                    else if (codepoint.cdpoint == utf::vs13_code) flipandrotate = (flipandrotate ^ 0b100) | ((flipandrotate + (flipandrotate & 1 ? 0b010 : 0)) & 0b011); // Hz flip
-                    else if (codepoint.cdpoint == utf::vs14_code) flipandrotate = (flipandrotate ^ 0b100) | ((flipandrotate + (flipandrotate & 1 ? 0 : 0b010)) & 0b011); // Vt flip
+                    else if (codepoint.cdpoint == utf::vs10_code) imagens::rotate_fx(flip_swap, imagens::ccw::r90 ); // Rotate 90° CCW
+                    else if (codepoint.cdpoint == utf::vs11_code) imagens::rotate_fx(flip_swap, imagens::ccw::r180); // Rotate 180° (=FlipX+FlipY)
+                    else if (codepoint.cdpoint == utf::vs12_code) imagens::rotate_fx(flip_swap, imagens::ccw::r270); // Rotate 270° CCW
+                    else if (codepoint.cdpoint == utf::vs13_code) imagens::mirror_fx(flip_swap, imagens::flips::hz); // Horizontal flip (FlipX)
+                    else if (codepoint.cdpoint == utf::vs14_code) imagens::mirror_fx(flip_swap, imagens::flips::vt); // Vertical flip (FlipY)
                     else if (codepoint.cdpoint == utf::vs04_code) img_alignment.x = snap::head;
                     else if (codepoint.cdpoint == utf::vs05_code) img_alignment.x = snap::center;
                     else if (codepoint.cdpoint == utf::vs06_code) img_alignment.x = snap::tail;
@@ -2280,7 +2306,8 @@ namespace netxs::gui
             auto grid_step = (fp32)cellsz.x;
             auto mtx = c.mtx();
             auto matrix = fp2d{ mtx * cellsz };
-            auto swapxy = flipandrotate & 1;
+            flip_swap = imagens::xlate[flip_swap & 7]; // Convert between the "pull-based" and the "push-based" renderer (we accumulate tranformations in "pull_based").
+            auto swapxy = flip_swap & 1;
             if (swapxy)
             {
                 std::swap(matrix.x, matrix.y);
@@ -2383,90 +2410,76 @@ namespace netxs::gui
             //auto src_bitmap = glyph_mask.raster<byte>();
             //auto bline = rect{base_line, { cellsz.x, 1 } };
             //netxs::onrect(src_bitmap, bline, [](auto& c){ c = std::min(255, c + 64); });
-            if (glyph_mask.area && flipandrotate)
-            {
-                static thread_local auto buffer = std::vector<ui32>{}; // Use ui32 for 4-byte alignment (aarch requirement).
-                static constexpr auto l0 = std::to_array({ 1, -1, -1,  1, -1, 1,  1, -1 });
-                static constexpr auto l1 = std::to_array({ 1,  1, -1, -1,  1, 1, -1, -1 });
-                buffer.assign(glyph_mask.bits.begin(), glyph_mask.bits.end());
-                auto xform = [&](auto elem)
-                {
-                    using type = decltype(elem);
-                    auto count = (size_t)glyph_mask.area.length();
-                    auto src = netxs::raster{ std::span{ (type*)buffer.data(), count }, glyph_mask.area };
-                    auto mx = glyph_mask.area.size.x;
-                    if (swapxy)
-                    {
-                        std::swap(glyph_mask.area.size.x, glyph_mask.area.size.y);
-                        std::swap(matrix.x, matrix.y); // Revert back.
-                    }
-                    auto dst = glyph_mask.raster<type>();
-                    auto s__dx = 1;
-                    auto s__dy = mx;
-                    auto dmx = glyph_mask.area.size.x;
-                    auto dmy = glyph_mask.area.size.y;
-                    auto sx = l0[flipandrotate];
-                    auto sy = l1[flipandrotate];
-                    auto d__dx = sx * ((flipandrotate & 0b1) ? dmx :   1);
-                    auto d__dy = sy * ((flipandrotate & 0b1) ? 1   : dmx);
-                    if (flipandrotate & 0b100) std::swap(sx, sy);
-                    auto d__px = (sy > 0 ? 0 : dmx - 1);
-                    auto d__py = (sx > 0 ? 0 : dmy - 1);
-                    auto s_beg = src.begin();
-                    auto s_eol = s_beg + mx - 1;
-                    auto s_end = s_beg + count - 1;
-                    auto d_beg = dst.begin() + (d__px + d__py * dmx);
-                    auto d_eol = d_beg + d__dx * (mx - 1);
-                    auto s_ptr = s_beg;
-                    auto d_ptr = d_beg;
-                    while (true)
-                    {
-                        *d_ptr = *s_ptr;
-                        if (s_ptr != s_eol) s_ptr += s__dx;
-                        else
-                        {
-                            if (s_ptr == s_end) break;
-                            s_beg += s__dy;
-                            s_ptr = s_beg;
-                            s_eol += s__dy;
-                        }
-                        if (d_ptr != d_eol) d_ptr += d__dx;
-                        else
-                        {
-                            d_beg += d__dy;
-                            d_ptr = d_beg;
-                            d_eol += d__dy;
-                        }
-                    }
-                };
-                glyph_mask.type == sprite::color ? xform(irgb{}) : xform(byte{});
-                static constexpr twod coeffs[8][5] =
-                { //  coor.x    coor.y    size.x    size.y    matrix
-                    {{ 1, 0 }, { 0, 1 }, { 0, 0 }, { 0, 0 }, { 0, 0 }}, // 0: 0° CCW
-                    {{ 0,-1 }, { 1, 0 }, { 0, 0 }, { 0,-1 }, { 0, 1 }}, // 1: 90°
-                    {{-1, 0 }, { 0,-1 }, {-1, 0 }, { 0,-1 }, { 1, 1 }}, // 2: 180°
-                    {{ 0, 1 }, {-1, 0 }, {-1, 0 }, { 0, 0 }, { 1, 0 }}, // 3: 270°
-                    {{-1, 0 }, { 0, 1 }, {-1, 0 }, { 0, 0 }, { 1, 0 }}, // 4: Hz Flip
-                    {{ 0, 1 }, { 1, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }}, // 5: Hz Flip + 90°
-                    {{ 1, 0 }, { 0,-1 }, { 0, 0 }, { 0,-1 }, { 0, 1 }}, // 6: Hz Flip + 180°
-                    {{ 0,-1 }, {-1, 0 }, {-1, 0 }, { 0,-1 }, { 1, 1 }}  // 7: Hz Flip + 270°
-                };
-                auto& r = glyph_mask.area;
-                auto& m = coeffs[flipandrotate];
-                r.coor = m[0] * r.coor.x
-                       + m[1] * r.coor.y
-                       + m[2] * r.size.x
-                       + m[3] * r.size.y
-                       + m[4] * matrix;
+            if (glyph_mask.area && flip_swap)
+            {
+                glyph_mask.transform<irgb>(flip_swap, matrix);
+            }
+        }
+        void rasterize_svg_document(imagens::image& image)
+        {
+            if (!image.dom[0])
+            {
+                image.dom = generate_DOM(image.document);
+            }
+            if (image.dom[0])
+            {
+                auto& image_dom = *image.dom[0];
+                auto original_doc_size_fpx = fp2d{ image_dom.width(), image_dom.height() }; // Original doc size (float).
+                auto final_doc_size_fpx = original_doc_size_fpx; // Rendered doc size (float).
+
+                auto attrs = std::array<fp32, imagens::attr_count>{};
+                for (auto i = 0; i < imagens::attr_count; i++)
+                {
+                    if (auto v = image.attrs[i]) attrs[i] = v.value();
+                }
+                auto width     = attrs[imagens::width    ];
+                auto height    = attrs[imagens::height   ];
+                auto scale     = attrs[imagens::scale    ];
+                auto transform = attrs[imagens::transform];
+                auto wh_fp = fp2d{ width, height };
+                auto bounding_rect_pixels = std::round(wh_fp * cellsz); // Document bounding box size in pixels.
+                if ((si32)transform & 1)
+                {
+                    std::swap(bounding_rect_pixels.x, bounding_rect_pixels.y);
+                }
+                auto ratio = bounding_rect_pixels / original_doc_size_fpx;
+                auto keep_ratio = true;
+                switch ((si32)scale)
+                {
+                    case scale_mode::none:    /*final_doc_size_fpx = final_doc_size_fpx;*/ break;
+                    case scale_mode::inside:  final_doc_size_fpx *= std::min(ratio.x, ratio.y); break;
+                    case scale_mode::outside: final_doc_size_fpx *= std::max(ratio.x, ratio.y); break;
+                    case scale_mode::stretch: final_doc_size_fpx = bounding_rect_pixels; keep_ratio = faux; /* matrix_pixels = matrix_pixels */ break;
+                }
+                // Apply system limits.
+                auto px_limits = std::max(dot_11, skin::globals().max_value * cellsz);
+                final_doc_size_fpx = std::clamp(final_doc_size_fpx, fp2d{ dot_11 }, fp2d{ px_limits });
+
+                auto matrix_pixels = twod{ std::ceil(final_doc_size_fpx) };
+                image.document_area = rect{ dot_00, matrix_pixels };
+                static thread_local auto full_doc_tmp_buffer = netxs::sprite{ *std::pmr::new_delete_resource() };
+                full_doc_tmp_buffer.set_area<irgb>(image.document_area);
+                auto tmp_document_block = full_doc_tmp_buffer.raster<irgb>();
+                tmp_document_block.zeroize();
+                rasterize_svg_DOM(tmp_document_block, image.dom, original_doc_size_fpx, image.sub_id, keep_ratio);
+                // Trim all transparent pixels.
+                auto nested_fragment_area = full_doc_tmp_buffer.get_minimal_non_transparent_area_for_pma<irgb>();
+                image.fragment.set_area<irgb>(nested_fragment_area);
+                if (nested_fragment_area)
+                {
+                    auto dst_fragment_block = image.fragment.raster<irgb>();
+                    netxs::onbody(tmp_document_block, dst_fragment_block, [](auto& src, auto& dst){ dst = src; });
+                }
             }
         }
-        void draw_glyph(auto& canvas, sprite& glyph_mask, twod offset, argb fgc)
+        void draw_glyph(auto& canvas, sprite& glyph_mask, twod offset, argb fgc, bool semi_transparent = faux)
         {
             auto box = glyph_mask.area.shift(offset);
             auto f_fgc = irgb::nonpma_srgb_to_pma_linear(fgc);
             if (glyph_mask.type == sprite::color)
             {
-                auto fx = [fgc, f_fgc](argb& dst, irgb src)
+                auto global_alpha = semi_transparent ? 0.5f : 1.0f; // Triggers on SGR 7 (reverse video). Makes emoji semi-transparent on selection.
+                auto fx = [f_fgc, global_alpha](argb& dst, irgb src) //todo unify: same code in draw_image()
                 {
                     if (src.a == 0.f) return;
                     auto f_dst = irgb::pma_srgb_to_pma_linear(dst);
@@ -2478,7 +2491,7 @@ namespace netxs::gui
                             f_dst.blend_pma(f_fgc, fgc_alpha);
                         }
                     }
-                    dst = irgb::pma_linear_to_pma_srgb(f_dst.blend_pma(src));
+                    dst = irgb::pma_linear_to_pma_srgb(f_dst.blend_pma(src * global_alpha));
                 };
                 auto raster = netxs::raster{ std::span{ (irgb*)glyph_mask.bits.data(), (size_t)glyph_mask.area.length() }, box };
                 netxs::onclip(canvas, raster, fx);
@@ -2502,35 +2515,126 @@ namespace netxs::gui
                 netxs::onclip(canvas, raster, fx);
             }
         }
+        void draw_image(auto& canvas, imagens::image& image, twod offset, argb fgc, bool semi_transparent, si32 xform)
+        {
+            auto& image_mask = image.fragment;
+            auto f_fgc = irgb::nonpma_srgb_to_pma_linear(fgc);
+            auto global_alpha = semi_transparent ? 0.5f : 1.0f; // Triggers on SGR 7 (reverse video).
+            assert(image_mask.type == sprite::color);
+            auto raster = netxs::raster{ std::span{ (irgb*)image_mask.bits.data(), (size_t)image_mask.area.length() }, image_mask.area };
+            auto fx = [f_fgc, global_alpha](argb& dst, irgb src) //todo unify: same code in draw_glyph()
+            {
+                if (src.a == 0.f) return;
+                auto f_dst = irgb::pma_srgb_to_pma_linear(dst);
+                if (src.has_extra_alpha())
+                {
+                    auto fgc_alpha = src.unpack_alpha();
+                    if (fgc_alpha > 0)
+                    {
+                        f_dst.blend_pma(f_fgc, fgc_alpha);
+                    }
+                }
+                dst = irgb::pma_linear_to_pma_srgb(f_dst.blend_pma(src * global_alpha));
+            };
+            // xform on write
+            auto canvas_clip = canvas.clip(); // Cell placeholder.
+            auto document_area = image.document_area.shift(offset); // Raster inside the document.
+            netxs::xform_render(canvas, canvas_clip, raster, document_area, xform, fx);
+        }
+        auto render_image(auto& canvas, rect placeholder, argb fgc, cell const& c)
+        {
+            if (auto image_index = c.get_image_index())
+            if (auto image_xy = c.get_image_xy(); image_xy.x != 0 && image_xy.y != 0)
+            {
+                auto image_align = c.get_image_align();
+                auto image_xform = c.get_image_xform();
+                auto images = cell::images(); // Lock.
+                if (auto image_ptr = images.exists(image_index)) //todo form all image requests on dtvt recv stage
+                {
+                    auto& image = *image_ptr;
+                    //todo diff by sizes
+                    if (image.fragment.type == sprite::undef)
+                    {
+                        rasterize_svg_document(image);
+                    }
+                    if (image.fragment.area)
+                    {
+                        auto& _dx = image.attrs[imagens::dx];
+                        auto& _dy = image.attrs[imagens::dy];
+                        auto dxy = twod{ _dx ? std::round(cellsz.x * _dx.value()) : 0,
+                                         _dy ? std::round(cellsz.y * _dy.value()) : 0 };
+                        // Alignment.
+                        auto width  = image.attrs[imagens::width ].value();
+                        auto height = image.attrs[imagens::height].value();
+                        auto wh_fp = fp2d{ width, height };
+                        auto cellcanvas_size = twod{ std::ceil(wh_fp) * cellsz }; // Cellrect in pixels (outer rect).
+
+                        //auto get_factor = [](auto align)
+                        //{
+                        //    if (align == (si32)bias::center || !align) return 0.5f;
+                        //    if (align == (si32)bias::right)            return 1.0f;
+                        //    return 0.0f;
+                        //};
+                        //auto factors = fp2d{ get_factor(image_align & 0b0011), get_factor(image_align >> 2) };
+                        //auto fragment_area_coor = image.fragment.area.coor + (cellcanvas_size - image.document_area.size) * factors;
+
+                        auto get_off = [](auto align, auto diff)
+                        {
+                            return (align == (si32)bias::right)            ? diff
+                                 : (align == (si32)bias::center || !align) ? diff / 2
+                                                                           : 0;
+                        };
+                        auto fragment_area_coor = image.fragment.area.coor + twod{ get_off(image_align & 0b0011, cellcanvas_size.x - image.document_area.size.x),
+                                                                                   get_off(image_align >> 2,     cellcanvas_size.y - image.document_area.size.y) };
+
+                        // Rendering.
+                        image_xy = (image_xy - dot_11) * cellsz;
+                        auto offset = placeholder.coor - image_xy + dxy + fragment_area_coor;
+                        draw_image(canvas, image, offset, fgc, c.inv(), image_xform);
+                    }
+                }
+            }
+        }
+        void draw_shadows(auto& canvas, rect placeholder, cell const& c)
+        {
+            if (auto shadow = c.dim()) // Render shadow if it is.
+            {
+                auto& shadow_raster = cgi_shadow[shadow];
+                auto offset = placeholder.coor;
+                draw_glyph(canvas, shadow_raster, offset, argb{ tint::pureblack });
+            }
+        }
         template<class T = noop>
         void draw_cell(auto& canvas, rect placeholder, cell const& c, T&& blink_canvas = {})
         {
+            static constexpr auto blink_canvas_specified = !std::is_same_v<std::decay_t<T>, noop>;
             placeholder.trimby(canvas.area());
             if (!placeholder) return;
+            auto image_ontop = c.get_image_ontop();
+            auto blinking = blink_canvas_specified && c.blk() && !c.hid();
             auto fgc = c.fgc();
             auto bgc = c.bgc();
             if (c.inv()) std::swap(fgc, bgc);
+
+            // Build background.
             canvas.clip(placeholder);
             auto target_ptr = &canvas;
-            if constexpr (std::is_same_v<std::decay_t<T>, noop>)
+            netxs::onrect(canvas, placeholder, cell::shaders::full(bgc));
+            if (!image_ontop)
             {
-                netxs::onrect(canvas, placeholder, cell::shaders::full(bgc));
+                render_image(canvas, placeholder, fgc, c);
             }
-            else
+            if constexpr (blink_canvas_specified)
+            if (blinking) // Copy background to the the blinking layer to fix DWM that doesn't take gamma into account during layered window blending.
             {
-                if (c.blk() && !c.hid())
-                {
-                    target_ptr = &blink_canvas;
-                    blink_canvas.clip(placeholder);
-                    // Fill the blinking layer's background to fix DWM that doesn't take gamma into account during layered window blending.
-                    netxs::onclip(canvas, blink_canvas, [&](auto& dst, auto& src){ dst = bgc; src = bgc; });
-                }
-                else netxs::onrect(canvas, placeholder, cell::shaders::full(bgc));
+                target_ptr = &blink_canvas;
+                blink_canvas.clip(placeholder);
+                netxs::onclip(canvas, blink_canvas, [&](auto& dst, auto& src){ src = dst; });
             }
 
+            auto& target = *target_ptr;
             while (!c.hid()) // Render visible glyph.
             {
-                auto& target = *target_ptr;
                 if (auto u = c.und())
                 {
                     auto index = c.unc();
@@ -2642,21 +2746,43 @@ namespace netxs::gui
                         //    draw_glyph(target, glyph_mask, offset - dot_01 + dot_10, blk);
                         //    draw_glyph(target, glyph_mask, offset + dot_01 - dot_10, blk);
                         //}
-                        draw_glyph(target, glyph_mask, offset, fgc);
+                        draw_glyph(target, glyph_mask, offset, fgc, c.inv());
                     }
                 }
-                if (bgc.alpha()< 2 && fgc == argb{ purewhite })
-                {
-                    //edge
-                }
+                //if (bgc.alpha()< 2 && fgc == argb{ purewhite })
+                //{
+                //    // hilight glyph edges
+                //}
                 break;
             }
 
-            if (auto shadow = c.dim()) // Render shadow if it is.
+            if (image_ontop)
             {
-                auto& shadow_raster = cgi_shadow[shadow];
-                auto offset = placeholder.coor;
-                draw_glyph(canvas, shadow_raster, offset, argb{ pureblack });
+                if (blinking)
+                {
+                    if constexpr (blink_canvas_specified)
+                    {
+                        render_image(canvas, placeholder, bgc, c);
+                        draw_shadows(canvas, placeholder, c);
+
+                        render_image(target, placeholder, fgc, c);
+                        draw_shadows(target, placeholder, c);
+                    }
+                }
+                else
+                {
+                    render_image(canvas, placeholder, fgc, c);
+                    draw_shadows(canvas, placeholder, c);
+                }
+            }
+            else
+            {
+                draw_shadows(canvas, placeholder, c);
+                if constexpr (blink_canvas_specified)
+                if (blinking)
+                {
+                    draw_shadows(target, placeholder, c);
+                }
             }
         }
     };
diff --git a/src/netxs/desktopio/input.hpp b/src/netxs/desktopio/input.hpp
index 52055ae681..06078f079d 100644
--- a/src/netxs/desktopio/input.hpp
+++ b/src/netxs/desktopio/input.hpp
@@ -520,7 +520,7 @@ namespace netxs::input
                 auto take = [](qiew& chord)
                 {
                     auto k = key_t{};
-                    utf::trim(chord, ' ');
+                    utf::trim(chord, netxs::whitespaces);
                     if (chord.empty()) return k;
                     if (auto pos = chord.find("::"); pos != text::npos) // Environment event.
                     {
@@ -534,7 +534,7 @@ namespace netxs::input
                         {
                             auto event_str = chord;
                             event_str.remove_prefix(tier::str[event_tier].size());
-                            utf::trim(event_str, ": ");
+                            utf::trim(event_str, netxs::whitespaces_and<':'>);
                             auto& rtti = netxs::events::rtti();
                             auto iter = rtti.find(event_str);
                             if (iter != rtti.end())
@@ -555,7 +555,7 @@ namespace netxs::input
                     if (chord.starts_with(tier::str[tier::preview])) // Drop the "preview:" prefix (it is not used here).
                     {
                         chord.remove_prefix(tier::str[tier::preview].size());
-                        utf::trim_front(chord, ": ");
+                        utf::trim_front(chord, netxs::whitespaces_and<':'>);
                     }
                     auto c = chord.front();
                     if (c != '-') // Is pressed.
@@ -563,7 +563,7 @@ namespace netxs::input
                         if (c == '+')
                         {
                             chord.pop_front(); // Pop '+'.
-                            utf::trim(chord, ' ');
+                            utf::trim(chord, netxs::whitespaces);
                             if (chord.empty()) return k;
                             c = chord.front();
                         }
@@ -572,11 +572,11 @@ namespace netxs::input
                     {
                         k.sign |= input::key::unpressed_sign;
                         chord.pop_front(); // Pop '-'.
-                        utf::trim(chord, ' ');
+                        utf::trim(chord, netxs::whitespaces);
                         if (chord.empty()) return k;
                         c = chord.front();
                     }
-                    utf::trim(chord, ' ');
+                    utf::trim(chord, netxs::whitespaces);
                     if (chord.empty()) return k;
                     if (auto isscancode = chord.starts_with("0x") || chord.starts_with("0X"); isscancode)
                     {
@@ -641,7 +641,7 @@ namespace netxs::input
                             k.code2 = n2 ? code + 1 : 0;
                         }
                     }
-                    utf::trim(chord, ' ');
+                    utf::trim(chord, netxs::whitespaces);
                     return k;
                 };
                 // Split.
diff --git a/src/netxs/desktopio/intmath.hpp b/src/netxs/desktopio/intmath.hpp
index b7a7318053..e790385923 100644
--- a/src/netxs/desktopio/intmath.hpp
+++ b/src/netxs/desktopio/intmath.hpp
@@ -43,6 +43,17 @@
 #include <variant>
 #include <vector>
 
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TRUETYPE_TABLES_H
+#include FT_MULTIPLE_MASTERS_H
+#include FT_SFNT_NAMES_H
+#include FT_COLOR_H
+#include FT_OTSVG_H
+
+#include <hb-ft.h>
+#include <lunasvg.h>
+
 #ifndef faux
     #define faux (false)
 #endif
@@ -186,6 +197,18 @@ namespace netxs
         }
         return n;
     }
+    template<ui64 FieldMask>
+    void set_field(si32 v, auto& token)
+    {
+        using TType = std::decay_t<decltype(token)>;
+        token &= static_cast<TType>(~FieldMask);
+        token |= ((TType)(std::make_unsigned_t<decltype(v)>)v << netxs::field_offset<FieldMask>());
+    }
+    template<ui64 FieldMask>
+    auto get_field(auto token)
+    {
+        return (si32)((token & FieldMask) >> netxs::field_offset<FieldMask>());
+    }
     // intmath: Set a single p-bit to v.
     template<sz_t P, class T>
     void set_bit(T&& n, bool v)
@@ -788,15 +811,15 @@ namespace netxs
 
     // intmath: Project bitmap_view to the canvas_view (with nearest-neighbor interpolation and negative bitmap_size support for mirroring).
     template<class NewlineFx = noop>
-    void xform_scale(auto&& canvas, auto canvas_rect, auto clip_rect, auto const& bitmap, auto bitmap_rect, auto handle, NewlineFx online = {})
+    void xform_scale(auto&& canvas, auto canvas_rect, auto clip_rect_on_canvas, auto const& bitmap, auto rect_in_bitmap, auto handle, NewlineFx online = {})
     {
         auto dst_size = canvas.size();
         auto src_size = bitmap.size();
-        clip_rect.coor -= canvas.coor();
+        clip_rect_on_canvas.coor -= canvas.coor();
         canvas_rect.coor -= canvas.coor();
-        bitmap_rect.coor -= bitmap.coor();
-        auto dst_view = canvas_rect.trim(clip_rect).trunc(dst_size);
-        auto src_view = bitmap_rect.trunc(src_size);
+        rect_in_bitmap.coor -= bitmap.coor();
+        auto dst_view = canvas_rect.trim(clip_rect_on_canvas).trunc(dst_size);
+        auto src_view = rect_in_bitmap.trunc(src_size);
 
         if (dst_view.size.x == 0 || dst_view.size.y == 0
          || src_view.size.x == 0 || src_view.size.y == 0) return;
@@ -804,7 +827,7 @@ namespace netxs
         auto s_00 = src_view.coor.x + src_view.coor.y * src_size.x;
         auto sptr = bitmap.begin();
         auto dptr = canvas.begin() + dst_view.coor.x + dst_view.coor.y * dst_size.x;
-        auto step = (bitmap_rect.size * 65536) / canvas_rect.size;
+        auto step = (rect_in_bitmap.size * 65536) / canvas_rect.size;
         auto half = step * abs(canvas_rect.coor - dst_view.coor) + step / 2; // Centrify by pixel half.
         dst_view.size -= 1;
         auto tail = dptr + dst_view.size.x;
@@ -830,32 +853,36 @@ namespace netxs
         }
     }
 
-    // intmath: Project bitmap_rect to the canvas_rect_coor (with nearest-neighbor interpolation and support for negative bitmap_rect.size to mirroring/flipping).
+    // intmath: Project rect_in_bitmap to the insertion_point_on_canvas (with support for negative rect_in_bitmap.size to mirroring/flipping).
     template<class NewlineFx = noop>
-    void xform_mirror(auto&& canvas, auto clip_rect, auto canvas_rect_coor, auto const& bitmap, auto bitmap_rect, auto handle, NewlineFx online = {})
+    void xform_mirror(auto&& canvas, auto clip_rect_on_canvas, auto insertion_point_on_canvas, auto const& bitmap, auto rect_in_bitmap, auto handle, NewlineFx online = {})
     {
         auto dst_size = canvas.size();
         auto src_size = bitmap.size();
-        clip_rect.coor -= canvas.coor();
-        canvas_rect_coor -= canvas.coor();
-        bitmap_rect.coor -= bitmap.coor();
-        auto src_view = bitmap_rect.trunc(src_size);
-        bitmap_rect.coor = canvas_rect_coor;
-        auto dst_area = bitmap_rect.normalize();
-        auto dst_view = dst_area.trim(clip_rect).trunc(dst_size);
+        // Reduction to local coordinates.
+        clip_rect_on_canvas.coor  -= canvas.coor();
+        insertion_point_on_canvas -= canvas.coor();
+        rect_in_bitmap.coor       -= bitmap.coor();
+        // Preparing viewports.
+        auto src_view = rect_in_bitmap.trunc(src_size);
+        rect_in_bitmap.coor = insertion_point_on_canvas;
+        auto dst_area = rect_in_bitmap.normalize(); // Make rect with top-left orientation.
+        auto dst_view = dst_area.trim(clip_rect_on_canvas).trunc(dst_size);
+        // Synchronous source trimming.
         src_view -= dst_area - dst_view; // Cut invisible sides.
-
-        if (dst_view.size.x == 0 || dst_view.size.y == 0
+        // Checking for emptiness.
+        if (dst_view.size.x <= 0 || dst_view.size.y <= 0
          || src_view.size.x == 0 || src_view.size.y == 0) return;
-
+        // Calculation of steps and starting points.
         auto dx = 1;
         auto dy = std::abs(src_size.x);
         if (src_view.size.x < 0) { dx = -dx; src_view.coor.x -= 1; }
         if (src_view.size.y < 0) { dy = -dy; src_view.coor.y -= 1; }
-
-        dst_view.size -= 1;
+        // Initializing iterators.
         auto sptr = bitmap.begin() + (src_view.coor.x + src_view.coor.y * src_size.x);
         auto dptr = canvas.begin() + (dst_view.coor.x + dst_view.coor.y * dst_size.x);
+        // Cycle controls.
+        dst_view.size -= 1;
         auto tail = dptr + dst_view.size.x;
         auto stop = tail + dst_view.size.y * dst_size.x;
         while (true)
@@ -869,12 +896,72 @@ namespace netxs
                 xptr += dx;
             }
             online();
-            if (dptr == stop) break;
+            if (tail == stop) break;
             sptr += dy;
             tail += dst_size.x;
             dptr = tail - dst_view.size.x;
         }
     }
+    // intmath: Project sprite to the canvas (with transforms 0b[FlipY][FlipX][SwapXY]).
+    //          We stick to a "pull-based" rendering (iterating linearly over the destination).
+    //          Linear memory writes are significantly more cache-friendly and performant than
+    //          scattered writes, especially when dealing with large framebuffers or video memory.
+    //          This allows the CPU to utilize Write Combining and avoid frequent Cache Line
+    //          bouncing (RFO). To maintain compatibility with the "push-based" raster
+    //          transformation logic, the imagens::xlate conjugation table may be used.
+    template<class rect, class NewlineFx = noop>
+    void xform_render(auto& canvas, rect canvas_clip,   // canvas and canvas_clip are in global coords.
+                      auto& sprite, rect document_area, // sprite is hosted inside the document area which is in global coords.
+                      si32 xform, auto fx, NewlineFx online_fx = {}) // xform: document's D4 transformations.
+    {
+        auto canvas_area = canvas.area(); // Global coordinates.
+        auto sprite_area = sprite.area(); // Local coordinates relative to document_area.
+        auto global_sprite_area = document_area.transform(sprite_area, xform);
+        auto dst_rect = canvas_area.trim(canvas_clip).trim(global_sprite_area); // Global dst rect.
+        if (dst_rect.size.x <= 0 || dst_rect.size.y <= 0) return;
+
+        auto src_rect = document_area.untransform(dst_rect, xform); // Make dst_rect local to untransformed document_area.
+        dst_rect.coor -= canvas_area.coor; // Make it relative to canvas.
+        src_rect.coor -= sprite_area.coor; // Make it relative to sprite.
+
+        auto src_dx = 1;
+        auto src_dy = sprite.size().x;
+        auto dst_dy = canvas.size().x;
+        auto s_ptr = sprite.begin() + src_rect.coor.y * src_dy + src_rect.coor.x;
+        auto d_ptr = canvas.begin() + dst_rect.coor.y * dst_dy + dst_rect.coor.x;
+        if (xform & 0b001) // SwapXY
+        {
+            std::swap(src_dx, src_dy);
+        }
+        if (xform & 0b010) // FlipX
+        {
+            s_ptr += (dst_rect.size.x - 1) * src_dx;
+            src_dx = -src_dx;
+        }
+        if (xform & 0b100) // FlipY
+        {
+            s_ptr += (dst_rect.size.y - 1) * src_dy;
+            src_dy = -src_dy;
+        }
+        auto h = dst_rect.size.y;
+        while (true)
+        {
+            auto w = dst_rect.size.x;
+            auto dst_ptr = d_ptr;
+            auto src_ptr = s_ptr;
+            while (true)
+            {
+                fx(*dst_ptr, *src_ptr);
+                if (--w == 0) break;
+                dst_ptr++; // We walk along a huge canvas.
+                src_ptr += src_dx;
+            }
+            online_fx();
+            if (--h == 0) break;
+            d_ptr += dst_dy;
+            s_ptr += src_dy;
+        }
+    }
 
     // intmath: Copy the bitmap to the bitmap by invoking
     //          handle(sprite1_element, sprite2_element) for each elem.
@@ -934,45 +1021,6 @@ namespace netxs
         }
     }
 
-    // intmath: Generic bitmap.
-    template<class T, class Rect>
-    struct raster
-    {
-        using base = T;
-        base _data;
-        Rect _area;
-        Rect _clip;
-        auto length() const { return _data.length(); }
-        auto  begin()       { return _data.begin();  }
-        auto  begin() const { return _data.begin();  }
-        auto   data()       { return _data.data();   }
-        auto   data() const { return _data.data();   }
-        auto    end()       { return _data.end();    }
-        auto    end() const { return _data.end();    }
-        auto&  clip()       { return _clip;          }
-        auto&  clip() const { return _clip;          }
-        auto&  area()       { return _area;          }
-        auto&  area() const { return _area;          }
-        auto   clip(auto c) { _clip = c;             }
-        void   step(auto s) { _area.coor += s;       }
-        void   move(auto p) { _area.coor = p;        }
-        auto&  size()       { return _area.size;     }
-        auto&  size() const { return _area.size;     }
-        auto&  coor()       { return _area.coor;     }
-        auto&  coor() const { return _area.coor;     }
-        auto& operator [] (auto p) { return *(begin() + p.x + p.y * _area.size.x); }
-        void size(auto new_size, auto... filler)
-        {
-            _area.size = new_size;
-            _data.resize(new_size.x * new_size.y, filler...);
-        }
-        raster() = default;
-        raster(T data, Rect area)
-            : _data{ data },
-              _area{ area }
-        { }
-    };
-
     // intmath: Intersect two sprites and invoke handle(sprite1_element, sprite2_element) for each elem in the intersection.
     template<class NewlineFx = noop>
     void onbody(auto&& canvas, auto&& bitmap, auto handle, NewlineFx online = {})
diff --git a/src/netxs/desktopio/lixx.hpp b/src/netxs/desktopio/lixx.hpp
index db6848fcab..8e32c359f1 100644
--- a/src/netxs/desktopio/lixx.hpp
+++ b/src/netxs/desktopio/lixx.hpp
@@ -5228,7 +5228,7 @@ namespace netxs::lixx // li++, libinput++.
                     auto s = strv[idx].data();
                     auto c = *s++;
                     auto enable = faux;
-                            if (c == '+') enable = true;
+                         if (c == '+') enable = true;
                     else if (c == '-') enable = faux;
                     else
                     {
@@ -5251,9 +5251,9 @@ namespace netxs::lixx // li++, libinput++.
                         auto consumed = 0;
                         char stype[13] = {}; // EV_FF_STATUS + '\0'.
                         if (::sscanf(s, "%12[A-Z_]:%x%n", stype, &code, &consumed) != 2
-                            || ::strlen(s) != (ui64)consumed
-                            || (type = libevdev_event_type_from_name(stype)) == -1
-                            || code < 0 || code > libevdev_event_type_get_max(type))
+                         || ::strlen(s) != (ui64)consumed
+                         || (type = libevdev_event_type_from_name(stype)) == -1
+                         || code < 0 || code > libevdev_event_type_get_max(type))
                         {
                             rc = faux;
                             break;
@@ -5289,7 +5289,7 @@ namespace netxs::lixx // li++, libinput++.
                     auto c = *s++;
                     auto prop = 0u;
                     auto enable = faux;
-                            if (c == '+') enable = true;
+                         if (c == '+') enable = true;
                     else if (c == '-') enable = faux;
                     else
                     {
@@ -5498,7 +5498,7 @@ namespace netxs::lixx // li++, libinput++.
                 auto value = strv[1];
                 if (key.size() && value.size() && value[0] != '"' && value[0] != '\'') // The value is not supposed to be in quotes.
                 {
-                            if (key.starts_with("Match")) rc = parse_match(s, key, value);
+                         if (key.starts_with("Match")) rc = parse_match(s, key, value);
                     else if (key.starts_with("Model")) rc = parse_model(s, key, value);
                     else if (key.starts_with("Attr") ) rc = parse_attr( s, key, value);
                     else log("Unknown value prefix %s%", line);
diff --git a/src/netxs/desktopio/terminal.hpp b/src/netxs/desktopio/terminal.hpp
index 93bdc2e1d0..da563638a6 100644
--- a/src/netxs/desktopio/terminal.hpp
+++ b/src/netxs/desktopio/terminal.hpp
@@ -1205,6 +1205,8 @@ namespace netxs::ui
                 vt.oscer[osc_clipboard  ] = V{ p->owner.forward_clipboard(q);           };
                 vt.oscer[osc_term_notify] = V{ p->owner.osc_notify(q);                  };
                 vt.oscer[osc_semantic_fx] = V{ p->owner.osc_marker(q);                  };
+                vt.oscer[osc_glyph      ] = V{ p->owner.osc_glyphs(q);                  };
+                vt.oscer[osc_app        ] = V{ p->owner.osc_images(q);                  };
                 #undef V
 
                 // Log all unimplemented CSI commands.
@@ -7189,8 +7191,57 @@ namespace netxs::ui
         bool       bottom_anchored; // term: Anchor scrollback content when resizing (default is anchor at bottom).
         ui32       event_sources; // term: vt-input-mode event reporting bit-field.
         ui64       session_token; // term: Interactive session token.
+        utf::unordered_map<text, netxs::sptr<imagens::image>> image_cache; // term: Image cache.
+        face                                                  image_buffer; // term: Image temporary buffer.
         vtty       ipccon; // term: IPC connector. Should be destroyed first.
 
+        // term: Print the block to the scrollback buffer with scroll.
+        template<class S, class P>
+        auto print_block(S& scrollback, core const& block, twod trim_by_viewport, P fuse)
+        {
+            auto size = block.size();
+            auto head = block.begin();
+            auto tail = block.end();
+            auto coor = scrollback.coord;
+            auto step = size.x;
+            if (trim_by_viewport)
+            {
+                auto crop = std::min(trim_by_viewport, coor + size) - coor;
+                if (crop.x <= 0 || crop.y <= 0) return;
+                step = crop.x;
+                tail = head + size.x * crop.y;
+            }
+            auto rest = size.x - step;
+            while (true)
+            {
+                auto next = head + step;
+                auto line = std::span(head, next);
+                scrollback.template _data<true>(step, line, fuse);
+                head = next + rest;
+                if (head != tail)
+                {
+                    scrollback.chx0(coor.x);
+                    scrollback._lf(1);
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+        // term: Print specified block (scroll/wrap in normal; crop by the altbuf viewport).
+        auto draw_block(core const& image_buffer, auto fx)
+        {
+            if (target == &normal)
+            {
+                print_block(normal, image_buffer, {}, fx);
+            }
+            else
+            {
+                auto& target_buffer = *(alt_screen*)target;
+                print_block(target_buffer, image_buffer, target->panel, fx);
+            }
+        }
         // term: Place rectangle block to the scrollback buffer.
         template<class S, class P>
         auto write_block(S& scrollback, core const& block, twod coor, rect trim, P fuse)
@@ -7298,6 +7349,270 @@ namespace netxs::ui
                 }
             }
         }
+        // term: Dynamic Glyph Redefinition.
+        void osc_glyphs(view /*data*/)
+        {
+            //todo implement
+            log("%%Dynamic Glyph Redefinition is not implemented yet", prompt::term);
+        }
+        // term: Embedded Object Protocol.
+        void osc_images(qiew attrs_str)
+        {
+            auto& console = *target;
+            console.flush();
+            utf::trim(attrs_str, netxs::whitespaces);
+            if (!attrs_str) return;
+            auto id_str     = qiew{};
+            auto sub_id_str = qiew{};
+            auto gc_str     = qiew{};
+            auto doc_str    = qiew{};
+            auto unregister = faux;
+            auto new_attrs = imagens::image::attrs_t{};
+            // data: " id + attrs + doc"              Find by id and update/register and print.
+            //       " [attrs] + doc "                Register empty id.
+            //       " [id] "                         Find by id and print.
+            //       " [id] + attrs "                 Find by id and print applying new attrs.
+            //       " [id] + explicite-empty-doc "   Find by id and unregister. (doc=<tag></tag>)
+            while (attrs_str)
+            {
+                if (attrs_str.front() == '<') // Extract document body <tag1 ...> ... </tag2>
+                {
+                    auto closing_bracket_pos = attrs_str.rfind('>'); // Fing the last '>' in the string.
+                    doc_str = attrs_str.substr(0, closing_bracket_pos + 1);
+                    attrs_str.remove_prefix(doc_str.size());
+                    // Check if document is empty.
+                    auto tmp = doc_str;
+                    tmp.pop_front(); // Pop  '<'.
+                    if (auto tag = utf::take_front<faux>(tmp, netxs::whitespaces_and<'>'>)) // 'tag>' or 'tag ...'
+                    {
+                        auto degenerate_doc = text{};
+                        degenerate_doc.reserve(5 + tag.size() * 2); // "<" + tag + "></" + tag + ">"
+                        degenerate_doc += '<';
+                        degenerate_doc += tag;
+                        degenerate_doc += "></";
+                        degenerate_doc += tag;
+                        degenerate_doc += '>';
+                        unregister = doc_str == degenerate_doc;
+                        if (unregister) doc_str = {};
+                    }
+                    else
+                    {
+                        if (io_log) log("%%Broken 'OSC object' document (invalid structure)", prompt::term);
+                    }
+                }
+                else // Parse attributes.
+                {
+                    auto [attr_str, value_str] = utf::get_pair<'='>(attrs_str, netxs::whitespaces_and<'='>, netxs::whitespaces_and<' ', '<'>); // "... key=val<svg...>...</svg>"
+                    //todo sub-id: id=qqq/www
+                    if (attr_str == "id") // id="string/string".
+                    {
+                        id_str = utf::take_front<faux>(value_str, " /\\");
+                        utf::trim_front(value_str, " /\\");
+                        sub_id_str = value_str;
+                    }
+                    else if (attr_str == "gc") // gc="string". Grapheme cluster used to fill image area.
+                    {
+                        gc_str = value_str;
+                    }
+                    else // Regular attributes (si32 or dict).
+                    {
+                        //log(" attr_str=%%, value_str=%%", attr_str, value_str);
+                        if (auto p = imagens::parse_pair(attr_str, value_str))
+                        {
+                            auto [i, v] = p.value();
+                            //log("  new_attrs[%%]=%%", i, v);
+                            auto& xform_ref = new_attrs[imagens::transform];
+                            switch (i) // Accumulate transforms if specified.
+                            {
+                                case imagens::flip:
+                                    if (!xform_ref) xform_ref = 0.f;
+                                    imagens::mirror_fx(xform_ref.value(), v);
+                                    break;
+                                case imagens::rotate:
+                                    if (!xform_ref) xform_ref = 0.f;
+                                    imagens::rotate_fx(xform_ref.value(), v);
+                                    break;
+                                case imagens::transform:
+                                    xform_ref = std::clamp(v, 0.f, 7.f);
+                                    break;
+                                default:
+                                    new_attrs[i] = v;
+                                    break;
+                            }
+                        }
+                    }
+                }
+                utf::trim_front(attrs_str, netxs::whitespaces);
+            }
+            auto images = cell::images(); // Lock.
+            if (unregister)
+            {
+                if (auto iter = image_cache.find(id_str); iter != image_cache.end())
+                {
+                    auto image_ptr = iter->second;
+                    //log("unregistered ", image_ptr->id);
+                    image_cache.erase(iter);
+                    images.remove(image_ptr->index);
+                    if (io_log) log("%%Embedded object '%%' successfully unregistered", prompt::term, image_ptr->id);
+                }
+            }
+            else
+            {
+                auto iter = image_cache.find(id_str);
+                // Merge with existing attributes.
+                if (iter != image_cache.end() && doc_str.empty())
+                {
+                    //log("image_ptr found");
+                    auto image_ptr = iter->second;
+                    auto& old_attrs = image_ptr->attrs;
+                    for (auto i = 0u; i < new_attrs.size(); i++)
+                    {
+                        if (i == imagens::align
+                         || i == imagens::flip
+                         || i == imagens::transform
+                         || i == imagens::rotate
+                         || i == imagens::row
+                         || i == imagens::column
+                         || i == imagens::ontop) // Skip local attributes.
+                        {
+                            continue;
+                        }
+                        auto& new_attr = new_attrs[i];
+                        auto& old_attr = old_attrs[i];
+                        if (!new_attr)
+                        {
+                            new_attr = old_attr;
+                        }
+                        //else if (old_attr)
+                        //{
+                        //    if (i == imagens::align)
+                        //    {
+                        //        new_attr = imagens::combine_align_fx(old_attr.value(), new_attr.value());
+                        //    }
+                        //    else if (i == imagens::transform)
+                        //    {
+                        //        new_attr = imagens::combine_transform_fx(old_attr.value(), new_attr.value());
+                        //    }
+                        //}
+                    }
+                }
+                // Clamp sizes.
+                auto max_size = skin::globals().max_value;
+                auto& _w = new_attrs[imagens::width ];
+                auto& _h = new_attrs[imagens::height];
+                auto& _x = new_attrs[imagens::column];
+                auto& _y = new_attrs[imagens::row   ];
+                if (_w) _w = std::clamp(_w.value(), 1.f, (fp32)max_size.x); else _w = (fp32)target->panel.x;
+                if (_h) _h = std::clamp(_h.value(), 1.f, (fp32)max_size.y); else _h = (fp32)target->panel.y;
+                if (_x) _x = std::clamp(_x.value(), 0.f, std::ceil(_w.value())); else _x = 0.f;
+                if (_y) _y = std::clamp(_y.value(), 0.f, std::ceil(_h.value())); else _y = 0.f;
+                auto w = (si32)std::ceil(_w.value());
+                auto h = (si32)std::ceil(_h.value());
+                auto x = (si32)_x.value();
+                auto y = (si32)_y.value();
+                auto c = cell{ target->brush }.txt(gc_str, 1, 1, 1, 1);
+                auto print_image_buffer = [&]
+                {
+                    gc_str ? draw_block(image_buffer, cell::shaders::full)
+                           : draw_block(image_buffer, cell::shaders::image);
+                };
+                //todo revise cache logic (it is just a test)
+                auto different_image_size = [&]
+                {
+                    auto& image = *iter->second;
+                    auto ret = image.attrs[imagens::width ] != new_attrs[imagens::width ]
+                            || image.attrs[imagens::height] != new_attrs[imagens::height]
+                            || image.attrs[imagens::scale ] != new_attrs[imagens::scale ];
+                    if (ret) doc_str = image.document;
+                    return ret;
+                };
+                // Register image.
+                if (iter == image_cache.end() && (doc_str || different_image_size()))
+                {
+                    //todo group by id
+                    auto image_ptr = ptr::shared(imagens::image{ .id       = id_str,
+                                                                 .sub_id   = sub_id_str,
+                                                                 .document = doc_str,
+                                                                 .attrs    = new_attrs });
+                    if (auto image_index = images.set(image_ptr))
+                    {
+                        image_ptr->index = image_index;
+                        iter = image_cache.emplace(id_str, image_ptr).first;
+                    }
+                    else
+                    {
+                        log("%%The limit on the number of embedded objects has been reached", prompt::term);
+                    }
+                }
+                else if (doc_str) // Replace existing image.
+                {
+                    //log("%%Object with id='%%' updated", prompt::term, id_str ? id_str : "<empty string>");
+                    auto& image = *iter->second;
+                    if (image.document != doc_str)
+                    {
+                        image.document = doc_str;
+                        image.attrs[imagens::width] = new_attrs[imagens::width];
+                        image.attrs[imagens::height] = new_attrs[imagens::height];
+                        image.attrs[imagens::scale] = new_attrs[imagens::scale];
+                        //todo notify all gates
+                        //signal(release, ..., gate)
+                        //       scan all gate rasters and looking for the image_index reference in their cells and submit a forward notification if something found
+                    }
+                }
+                if (iter != image_cache.end())
+                {
+                    auto& image = *iter->second;
+                    c.set_image_attrs(image, new_attrs);
+                }
+                else // Image id is not registered. Just erase the specified region.
+                {
+                    if (io_log) log("%%Erase the specified region. Object with id='%%' is not registered", prompt::term, id_str ? id_str : "<empty string>");
+                }
+                // Print image rectangle.
+                if (!x && !y) // Print full raster.
+                {
+                    auto size = twod{ w, h };
+                    image_buffer.core::size<true>(size, c);
+                    auto head = image_buffer.begin();
+                    for (y = 1; y <= h; y++)
+                    {
+                        for (x = 1; x <= w; x++)
+                        {
+                            (*head++).set_image_xy(x, y);
+                        }
+                    }
+                    print_image_buffer();
+                }
+                else if (!y) // Print vertical slice.
+                {
+                    auto size = twod{ 1, h };
+                    image_buffer.core::size<true>(size, c);
+                    auto head = image_buffer.begin();
+                    for (y = 1; y <= h; y++)
+                    {
+                        (*head++).set_image_xy(x, y);
+                    }
+                    print_image_buffer();
+                }
+                else if (!x) // Print horizontal slice.
+                {
+                    auto size = twod{ w, 1 };
+                    image_buffer.core::size<true>(size, c);
+                    auto head = image_buffer.begin();
+                    for (x = 1; x <= w; x++)
+                    {
+                        (*head++).set_image_xy(x, y);
+                    }
+                    print_image_buffer();
+                }
+                else // if (x && y) // Print a single cell.
+                {
+                    auto size = twod{ 1, 1 };
+                    image_buffer.core::size<true>(size, c);
+                    print_image_buffer();
+                }
+            }
+        }
         // term: Forward clipboard data (OSC 52).
         void forward_clipboard(view data)
         {
diff --git a/src/netxs/desktopio/utf.hpp b/src/netxs/desktopio/utf.hpp
index 63730670e4..310282a3c6 100644
--- a/src/netxs/desktopio/utf.hpp
+++ b/src/netxs/desktopio/utf.hpp
@@ -18,13 +18,18 @@ namespace netxs
     using txts = std::vector<text>;
     using namespace std::literals;
 
-    static constexpr auto whitespaces = " \t\r\n\v\f"sv;
+    template<auto ...c>
+    static constexpr auto _ws_bytes = std::to_array({ ' ', '\t', '\r', '\n', '\v', '\f', c... });
+    template<auto ...c>
+    static constexpr auto whitespaces_and = view{ _ws_bytes<c...>.data(), _ws_bytes<c...>.size() };
+    static constexpr auto whitespaces = whitespaces_and<>;
     static constexpr auto onlydigits  = "0123456789"sv;
     static constexpr auto sharpdigit  = "0123456789#-"sv;
     static constexpr auto alphabetic  = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"sv;
     static constexpr auto base64code  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     static constexpr auto whitespace  = ' '; // '.';
     static constexpr auto emptyspace  = "\0"sv; //"\xC0\x80"sv; // In Modified UTF-8, the null character (U+0000) uses the two-byte overlong encoding 11000000 10000000 (hexadecimal C0 80), instead of 00000000 (hexadecimal 00).
+    static constexpr auto zwsp  = "​"sv; // U+200B.
     static consteval auto make_ui32(view four_bytes){ return ((ui32)four_bytes[0] << 24)
                                                            | ((ui32)four_bytes[1] << 16)
                                                            | ((ui32)four_bytes[2] << 8)
@@ -991,33 +996,49 @@ namespace netxs::utf
         {
             if (ascii.starts_with("0x") || ascii.starts_with("0X")) ascii.remove_prefix(2);
         }
-        auto top = ascii.data();
-        auto end = top + ascii.length();
         if constexpr (std::is_floating_point_v<A>)
         {
             //todo neither clang nor apple clang support from_chars with floating point (ver < 15.0)
             //if (auto [pos, err] = std::from_chars(top, end, num); err == std::errc())
+            auto sign = (A)1.0;
+            if (!ascii.empty() && ascii.front() == '-')
+            {
+                sign = (A)-1.0;
+                ascii.remove_prefix(1);
+            }
+            auto top = ascii.data();
+            auto end = top + ascii.length();
+            auto parsed_something = faux;
             auto integer = si64{};
-            if (auto [pos, err] = std::from_chars(top, end, integer, Base); err == std::errc())
+            if (auto [pos, err] = std::from_chars(top, end, integer, Base); err == std::errc()) // Integral part.
             {
-                ascii.remove_prefix(pos - top);
                 num = (A)integer;
-                if (ascii.size() && ascii.front() == '.')
+                ascii.remove_prefix(pos - top);
+                parsed_something = true;
+            }
+            if (!ascii.empty() && ascii.front() == '.') // Fractional part.
+            {
+                ascii.remove_prefix(1);
+                top = ascii.data();
+                end = top + ascii.length();
+                if (auto [mpos, merr] = std::from_chars(top, end, integer, Base); merr == std::errc())
                 {
-                    ascii.pop_front();
-                    top = ascii.data();
-                    if (auto [mpos, merr] = std::from_chars(top, end, integer, Base); merr == std::errc())
-                    {
-                        auto len = mpos - top;
-                        num += (A)(integer * std::pow(10, -len));
-                        ascii.remove_prefix(len);
-                    }
+                    auto len = mpos - top;
+                    num += (A)(integer * std::pow(Base, -(fp64)len));
+                    ascii.remove_prefix(len);
+                    parsed_something = true;
+                }
+                else if (!parsed_something) // "-."
+                {
+                    return std::nullopt;
                 }
-                return num;
             }
+            if (parsed_something) return num * sign;
         }
         else
         {
+            auto top = ascii.data();
+            auto end = top + ascii.length();
             if (auto [pos, err] = std::from_chars(top, end, num, Base); err == std::errc())
             {
                 ascii.remove_prefix(pos - top);
@@ -2452,10 +2473,35 @@ namespace netxs::utf
         }
         return utf8;
     }
+    // utf: Take key,val from key=val    [whitespaces]key[int_delimiters]val[ext_delimiters]
+    template<char EqualSign = '='>
+    auto get_pair(auto& utf8, view int_delimiters = netxs::whitespaces_and<EqualSign>, view ext_delimiters = netxs::whitespaces)
+    {
+        auto key = utf::take_front<faux>(utf8, int_delimiters); // " ="
+        auto val = decltype(key){};
+        utf::trim_front(utf8, netxs::whitespaces);
+        if (utf8.size() && utf8.front() == EqualSign) // '='
+        {
+            utf::trim_front(utf8, int_delimiters);
+            if (utf8)
+            {
+                auto c = utf8.view::front();
+                if (c == '\'' || c == '\"')
+                {
+                    val = utf::take_quote(utf8, c);
+                }
+                else
+                {
+                    val = utf::take_front<faux>(utf8, ext_delimiters); // ' '
+                }
+            }
+        }
+        return std::pair{ key, val };
+    }
     // utf: Split text line into quoted tokens.
     auto tokenize(view utf8, auto&& args)
     {
-        utf::trim(utf8, ' ');
+        utf::trim(utf8, netxs::whitespaces);
         while (utf8.size())
         {
             auto c = utf8.front();
diff --git a/src/vtm.xml b/src/vtm.xml
index 2e29171133..acaa7f0f5a 100644
--- a/src/vtm.xml
+++ b/src/vtm.xml
@@ -186,12 +186,12 @@ R"==(
             <default fgc=whitedk bgc=pureblack/>  <!-- Default terminal colors (SGR 39/49, set by OSC 10/11). -->
             <match fx="color" fgc=whitelt bgc= #007F00/>  <!-- Appearance of selected text matches. Available shaders (fx): "xlight", "color", "invert", "reverse". -->
             <selection>
-                <text      fx="color"  fgc=whitelt bgc=bluelt/>  <!-- Selection highlighting for plaintext clipboard mode. -->
-                <protected fx="color"  fgc=whitelt bgc=bluelt/>  <!-- Note: bgc and fgc attributes only apply when fx="color". -->
-                <ansi      fx="xlight" fgc=whitelt bgc=bluelt/>
-                <rich      fx="xlight" fgc=whitelt bgc=bluelt/>
-                <html      fx="xlight" fgc=whitelt bgc=bluelt/>
-                <none      fx="color"  fgc=whitedk bgc=blacklt/>  <!-- Appearance of an inactive selection. -->
+                <text      fx="color" inv=true bgc=whitelt fgc=bluelt/>  <!-- Selection highlighting for plaintext clipboard mode. -->
+                <protected fx="color" inv=true bgc=whitelt fgc=bluelt/>  <!-- Notes: -->
+                <ansi      fx="color" inv=true bgc=whitelt fgc=bluelt/>  <!--   - inv=true ensures that the embedded image becomes translucent (see AnyPlex Protocol). -->
+                <rich      fx="color" inv=true bgc=whitelt fgc=bluelt/>  <!--   - bgc and fgc attributes only apply when fx="color".            -->
+                <html      fx="color" inv=true bgc=whitelt fgc=bluelt/>
+                <none      fx="color" inv=true bgc=whitedk fgc=blacklt/>  <!-- Appearance of an inactive selection. -->
             </selection>
             <names=/X11ColorNames>  <!-- Color name mappings for OSC 4, 10-12. -->
                 <!--  <name="New Dark Orange" rgb= #FF8C00 /> -->