From ebe6e01a83f13288b0c31d225ceed1974a7122ed Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 18:51:24 +0200
Subject: [PATCH 01/55] Add collapsible sections shorthand and tabs support
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- normalizeBlockFields() translates collapsible/collapsed YAML shorthands
  on section fields into containerAttributes so the WinterCMS form widget's
  bindCollapsibleSections JS picks them up:
    collapsible: true         → data-field-collapsible attribute
    collapsed: true (default) → starts collapsed (core JS behaviour)
    collapsed: false          → starts open (handled by collapsible.js)

- collapsible.js re-opens sections marked data-field-collapsible-open after
  the core form widget collapses them all on init; also fires on ajaxSuccess
  for dynamically added repeater items

- getGroupFormFieldConfig() override passes tabs and secondaryTabs from the
  block definition through to Backend\Widgets\Form, enabling native WinterCMS
  tab syntax in .block files

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 assets/dist/js/collapsible.js | 30 ++++++++++++++
 formwidgets/Blocks.php        | 78 ++++++++++++++++++++++++++++++++---
 2 files changed, 102 insertions(+), 6 deletions(-)
 create mode 100644 assets/dist/js/collapsible.js

diff --git a/assets/dist/js/collapsible.js b/assets/dist/js/collapsible.js
new file mode 100644
index 0000000..fa2a82a
--- /dev/null
+++ b/assets/dist/js/collapsible.js
@@ -0,0 +1,30 @@
+/**
+ * Reopens collapsible sections that carry data-field-collapsible-open.
+ *
+ * WinterCMS's core form widget collapses ALL data-field-collapsible sections on
+ * init. This script runs after that and re-opens the ones marked as open by default.
+ */
+(function () {
+    function openMarkedSections(root) {
+        (root || document).querySelectorAll(
+            '.section-field[data-field-collapsible][data-field-collapsible-open]'
+        ).forEach(function (section) {
+            section.classList.remove('collapsed');
+            var el = section.nextElementSibling;
+            while (el && !el.classList.contains('section-field')) {
+                el.style.display = '';
+                el = el.nextElementSibling;
+            }
+        });
+    }
+
+    // Run after the form widget has initialised (it uses $(document).ready internally)
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', function () { openMarkedSections(); });
+    } else {
+        setTimeout(openMarkedSections, 0);
+    }
+
+    // Also handle dynamically added repeater items
+    document.addEventListener('ajaxSuccess', function () { openMarkedSections(); });
+})();
diff --git a/formwidgets/Blocks.php b/formwidgets/Blocks.php
index 04b2391..4899d02 100644
--- a/formwidgets/Blocks.php
+++ b/formwidgets/Blocks.php
@@ -53,6 +53,7 @@ protected function loadAssets()
     {
         $this->addCss('css/blocks.css', 'Winter.Blocks');
         $this->addJs('js/blocks.js', 'Winter.Blocks');
+        $this->addJs('js/collapsible.js', 'Winter.Blocks');
     }
 
     /**
@@ -203,12 +204,14 @@ protected function processGroupMode(): void
             }
 
             $definitions[$code] = [
-                'code' => $code,
-                'name' => array_get($config, 'name'),
-                'icon' => array_get($config, 'icon', 'icon-square-o'),
-                'description' => array_get($config, 'description'),
-                'fields' => array_get($config, 'fields'),
-                'config' => array_get($config, 'config', null),
+                'code'          => $code,
+                'name'          => array_get($config, 'name'),
+                'icon'          => array_get($config, 'icon', 'icon-square-o'),
+                'description'   => array_get($config, 'description'),
+                'fields'        => $this->normalizeBlockFields((array) array_get($config, 'fields', [])),
+                'tabs'          => array_get($config, 'tabs'),
+                'secondaryTabs' => array_get($config, 'secondaryTabs'),
+                'config'        => array_get($config, 'config', null),
             ];
         }
 
@@ -219,6 +222,69 @@ protected function processGroupMode(): void
         $this->useGroups = true;
     }
 
+    /**
+     * Translates block YAML shorthands before the fields are handed to the form widget.
+     *
+     * Supported shorthands on `type: section` fields:
+     *   collapsible: true          — makes the section click-to-collapse
+     *   collapsed: true|false      — initial state (true = start collapsed, false = start open)
+     *                                defaults to true when collapsible is set
+     */
+    protected function normalizeBlockFields(array $fields): array
+    {
+        foreach ($fields as &$field) {
+            if (($field['type'] ?? '') !== 'section') {
+                continue;
+            }
+
+            if (!array_key_exists('collapsible', $field)) {
+                continue;
+            }
+
+            if ($field['collapsible']) {
+                $startCollapsed = $field['collapsed'] ?? true;
+
+                $field['containerAttributes'] = array_merge(
+                    $field['containerAttributes'] ?? [],
+                    ['data-field-collapsible' => 1]
+                );
+
+                if (!$startCollapsed) {
+                    $field['containerAttributes']['data-field-collapsible-open'] = 1;
+                }
+            }
+
+            unset($field['collapsible'], $field['collapsed']);
+        }
+
+        return $fields;
+    }
+
+    /**
+     * Extends the parent config to pass tabs and secondaryTabs from the block
+     * definition through to the Backend Form widget.
+     */
+    protected function getGroupFormFieldConfig($code): ?array
+    {
+        $config = parent::getGroupFormFieldConfig($code);
+
+        if ($config === null) {
+            return null;
+        }
+
+        $def = $this->groupDefinitions[$code] ?? [];
+
+        if (!empty($def['tabs'])) {
+            $config['tabs'] = $def['tabs'];
+        }
+
+        if (!empty($def['secondaryTabs'])) {
+            $config['secondaryTabs'] = $def['secondaryTabs'];
+        }
+
+        return $config;
+    }
+
     /**
      * Determines if a block is allowed according to the widget's ignore/allow list.
      */

From 4b1afddffb75facab341032351b2a2a4ad23b60e Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 19:12:13 +0200
Subject: [PATCH 02/55] Add collapsible sections and tabs documentation

Documents the collapsible/collapsed YAML shorthand and tabs/secondaryTabs
block-level support added in this fork.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 README.md | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/README.md b/README.md
index ba775ce..9f6c62f 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,8 @@ Provides a "block based" content management experience in Winter CMS
 
 >**NOTE:** This plugin is still in development and is likely to undergo changes. Do not use in production environments without using a version constraint in your composer.json file and carefully monitoring for breaking changes.
 
+> **Fork note:** This is a fork of [wintercms/wn-blocks-plugin](https://github.com/wintercms/wn-blocks-plugin) that adds **collapsible sections** and **tabs/secondaryTabs** support in block definitions. See [Collapsible Sections](#collapsible-sections) and [Tabs](#tabs) below.
+
 ## Installation
 
 This plugin is available for installation via [Composer](http://getcomposer.org/).
@@ -144,6 +146,81 @@ config:
 </{{ config.size }}>
 ```
 
+## Collapsible Sections
+
+Block fields that use `type: section` can be made collapsible directly in the block YAML — no `containerAttributes` required.
+
+```yaml
+fields:
+    section_advanced:
+        label: Advanced settings
+        type: section
+        collapsible: true        # makes the section click-to-collapse
+        collapsed: true          # initial state: true = start collapsed (default), false = start open
+    some_field:
+        label: Some field
+        type: text
+```
+
+**Shorthand rules:**
+
+| Key | Type | Default | Description |
+|---|---|---|---|
+| `collapsible` | bool | — | Set to `true` to enable the collapse toggle |
+| `collapsed` | bool | `true` | Initial state. `false` = section starts open |
+
+When `collapsible: true` is set, the section header becomes a click target. Sections start collapsed by default; set `collapsed: false` to have the section open on first load.
+
+> **Note:** `collapsed: false` requires the `collapsible.js` asset that is bundled with this fork. It runs after WinterCMS's core form JS (which collapses all collapsible sections) and re-opens any section marked `collapsed: false`.
+
+---
+
+## Tabs
+
+Block definitions can include `tabs` and/or `secondaryTabs` at the top level. These are passed through to the WinterCMS `Backend\Widgets\Form` widget exactly as they would be in a standard `fields.yaml` file.
+
+```yaml
+name: My Block
+description: A block with tabs
+icon: icon-th
+
+tabs:
+    cssClass: master-tabs
+    fields:
+        content:
+            label: Content
+            type: textarea
+            tab: Content
+
+        title:
+            label: Title
+            type: text
+            tab: Content
+
+        meta_title:
+            label: Meta title
+            type: text
+            tab: SEO
+
+        meta_description:
+            label: Meta description
+            type: textarea
+            tab: SEO
+
+secondaryTabs:
+    fields:
+        is_active:
+            label: Active
+            type: checkbox
+            tab: Settings
+==
+<div>{{ content }}</div>
+```
+
+Fields declared under `tabs` / `secondaryTabs` are placed in the tabbed area of the form widget. You can combine `tabs`, `secondaryTabs`, and the top-level `fields` array in the same block.
+
+---
+
 ## Using the `blocks` FormWidget
 
 In order to provide an interface for managing block-based content, this plugin provides the `blocks` FormWidget. This widget can be used in the backend as a form field to manage blocks.

From 4d755b8d8ee2626bfd2c1e9e44a6615a3cf033a2 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 19:21:57 +0200
Subject: [PATCH 03/55] Minor README wording cleanup

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9f6c62f..01f8e39 100644
--- a/README.md
+++ b/README.md
@@ -148,7 +148,7 @@ config:
 
 ## Collapsible Sections
 
-Block fields that use `type: section` can be made collapsible directly in the block YAML — no `containerAttributes` required.
+Block fields that use `type: section` can be made collapsible directly in the block YAML.
 
 ```yaml
 fields:

From 648eb9ab6e54b9be5838472bb37facbbed510290 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 19:37:33 +0200
Subject: [PATCH 04/55] Fix repeater stall inside manually-uncollapsed sections

WinterCMS calls bindCollapsibleSections() after every ajaxSuccess, which
re-collapses all collapsible sections including ones the user manually opened.
Track user-toggled open state via data-user-opened on the element and restore
it after each ajaxSuccess alongside the configured-open sections.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 assets/dist/js/collapsible.js | 50 ++++++++++++++++++++++++++++-------
 1 file changed, 40 insertions(+), 10 deletions(-)

diff --git a/assets/dist/js/collapsible.js b/assets/dist/js/collapsible.js
index fa2a82a..9e8e69d 100644
--- a/assets/dist/js/collapsible.js
+++ b/assets/dist/js/collapsible.js
@@ -1,13 +1,23 @@
 /**
- * Reopens collapsible sections that carry data-field-collapsible-open.
+ * Manages collapsible section state for block form widgets.
  *
- * WinterCMS's core form widget collapses ALL data-field-collapsible sections on
- * init. This script runs after that and re-opens the ones marked as open by default.
+ * WinterCMS's core form widget calls bindCollapsibleSections() after every
+ * ajaxSuccess event, which re-collapses all [data-field-collapsible] sections.
+ * This script counters that in two ways:
+ *
+ *  1. Sections configured with collapsed: false (data-field-collapsible-open)
+ *     are always re-opened after each ajaxSuccess.
+ *
+ *  2. Sections the user has manually opened are tracked via data-user-opened
+ *     on the element itself. That attribute survives the re-collapse (WinterCMS
+ *     only touches the CSS class and display style, not our attribute), so we
+ *     can restore those sections too.
  */
 (function () {
-    function openMarkedSections(root) {
+    function openSections(root) {
         (root || document).querySelectorAll(
-            '.section-field[data-field-collapsible][data-field-collapsible-open]'
+            '.section-field[data-field-collapsible][data-field-collapsible-open],' +
+            '.section-field[data-field-collapsible][data-user-opened]'
         ).forEach(function (section) {
             section.classList.remove('collapsed');
             var el = section.nextElementSibling;
@@ -18,13 +28,33 @@
         });
     }
 
-    // Run after the form widget has initialised (it uses $(document).ready internally)
+    // Track which sections the user opens or closes via click.
+    // Uses event delegation so it catches sections inside dynamically added repeater items.
+    // setTimeout defers the state check until after WinterCMS has toggled the collapsed class.
+    document.addEventListener('click', function (e) {
+        var section = e.target.closest('.section-field[data-field-collapsible]');
+        if (!section) return;
+
+        setTimeout(function () {
+            if (section.classList.contains('collapsed')) {
+                section.removeAttribute('data-user-opened');
+            } else {
+                section.setAttribute('data-user-opened', '1');
+            }
+        }, 0);
+    });
+
+    // Initial pass after the form widget has initialised.
     if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', function () { openMarkedSections(); });
+        document.addEventListener('DOMContentLoaded', function () { openSections(); });
     } else {
-        setTimeout(openMarkedSections, 0);
+        setTimeout(openSections, 0);
     }
 
-    // Also handle dynamically added repeater items
-    document.addEventListener('ajaxSuccess', function () { openMarkedSections(); });
+    // Restore open sections after any AJAX call (repeater add/remove triggers
+    // bindCollapsibleSections which re-collapses everything).
+    // setTimeout ensures we run after WinterCMS's own ajaxSuccess handler.
+    document.addEventListener('ajaxSuccess', function () {
+        setTimeout(openSections, 0);
+    });
 })();

From c292d6518cbe8b65005dc9206ee26167231798a1 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 19:40:13 +0200
Subject: [PATCH 05/55] Fix section re-collapse flicker on repeater AJAX using
 MutationObserver
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

setTimeout was unreliable — the repeater's post-AJAX init could trigger
another bindCollapsibleSections() call after our timeout, causing a visible
"briefly shows then collapses" flicker.

Switch to a MutationObserver that immediately undoes programmatic re-collapses
of user-opened (data-user-opened) sections. A userTogglingSection flag
suppresses the observer during genuine user click-to-collapse so the user
can still close sections normally.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 assets/dist/js/collapsible.js | 89 +++++++++++++++++++++++------------
 1 file changed, 58 insertions(+), 31 deletions(-)

diff --git a/assets/dist/js/collapsible.js b/assets/dist/js/collapsible.js
index 9e8e69d..e843e33 100644
--- a/assets/dist/js/collapsible.js
+++ b/assets/dist/js/collapsible.js
@@ -1,41 +1,48 @@
 /**
  * Manages collapsible section state for block form widgets.
  *
- * WinterCMS's core form widget calls bindCollapsibleSections() after every
- * ajaxSuccess event, which re-collapses all [data-field-collapsible] sections.
- * This script counters that in two ways:
+ * WinterCMS calls bindCollapsibleSections() after every ajaxSuccess, which
+ * re-collapses all [data-field-collapsible] sections — including ones the user
+ * manually opened. A setTimeout race is unreliable because the repeater widget
+ * may trigger further post-AJAX initialization that collapses again after our
+ * timeout fires (visible as a "briefly shows then collapses" flicker).
  *
- *  1. Sections configured with collapsed: false (data-field-collapsible-open)
- *     are always re-opened after each ajaxSuccess.
- *
- *  2. Sections the user has manually opened are tracked via data-user-opened
- *     on the element itself. That attribute survives the re-collapse (WinterCMS
- *     only touches the CSS class and display style, not our attribute), so we
- *     can restore those sections too.
+ * Strategy:
+ *  - User-opened sections are tracked via data-user-opened on the element.
+ *  - A MutationObserver watches for the collapsed class being re-added to any
+ *    data-user-opened section and removes it immediately — no visible flicker.
+ *  - A userTogglingSection flag suppresses the observer during genuine user
+ *    clicks so the user can still collapse sections normally.
+ *  - Sections configured with collapsed: false (data-field-collapsible-open)
+ *    are handled separately via setTimeout after ajaxSuccess (existing behaviour).
  */
 (function () {
-    function openSections(root) {
+    var userTogglingSection = false;
+
+    function openSection(section) {
+        section.classList.remove('collapsed');
+        var el = section.nextElementSibling;
+        while (el && !el.classList.contains('section-field')) {
+            el.style.display = '';
+            el = el.nextElementSibling;
+        }
+    }
+
+    // Re-open sections configured with collapsed: false
+    function openConfiguredSections(root) {
         (root || document).querySelectorAll(
-            '.section-field[data-field-collapsible][data-field-collapsible-open],' +
-            '.section-field[data-field-collapsible][data-user-opened]'
-        ).forEach(function (section) {
-            section.classList.remove('collapsed');
-            var el = section.nextElementSibling;
-            while (el && !el.classList.contains('section-field')) {
-                el.style.display = '';
-                el = el.nextElementSibling;
-            }
-        });
+            '.section-field[data-field-collapsible][data-field-collapsible-open]'
+        ).forEach(openSection);
     }
 
-    // Track which sections the user opens or closes via click.
-    // Uses event delegation so it catches sections inside dynamically added repeater items.
-    // setTimeout defers the state check until after WinterCMS has toggled the collapsed class.
+    // Track user click intent so the MutationObserver knows not to fight it
     document.addEventListener('click', function (e) {
         var section = e.target.closest('.section-field[data-field-collapsible]');
         if (!section) return;
 
+        userTogglingSection = true;
         setTimeout(function () {
+            userTogglingSection = false;
             if (section.classList.contains('collapsed')) {
                 section.removeAttribute('data-user-opened');
             } else {
@@ -44,17 +51,37 @@
         }, 0);
     });
 
-    // Initial pass after the form widget has initialised.
+    // Immediately undo any programmatic re-collapse of a user-opened section.
+    // Fires synchronously (as a microtask) after the DOM change, before any
+    // setTimeout callbacks, so there is no visible flicker.
+    var observer = new MutationObserver(function (mutations) {
+        if (userTogglingSection) return;
+        mutations.forEach(function (mutation) {
+            var section = mutation.target;
+            if (
+                section.hasAttribute('data-user-opened') &&
+                section.classList.contains('collapsed')
+            ) {
+                openSection(section);
+            }
+        });
+    });
+
+    observer.observe(document.body, {
+        attributes: true,
+        attributeFilter: ['class'],
+        subtree: true,
+    });
+
+    // Initial pass after form widget init
     if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', function () { openSections(); });
+        document.addEventListener('DOMContentLoaded', function () { openConfiguredSections(); });
     } else {
-        setTimeout(openSections, 0);
+        setTimeout(openConfiguredSections, 0);
     }
 
-    // Restore open sections after any AJAX call (repeater add/remove triggers
-    // bindCollapsibleSections which re-collapses everything).
-    // setTimeout ensures we run after WinterCMS's own ajaxSuccess handler.
+    // Restore configured-open sections after AJAX (new repeater items etc.)
     document.addEventListener('ajaxSuccess', function () {
-        setTimeout(openSections, 0);
+        setTimeout(openConfiguredSections, 0);
     });
 })();

From 448537f82dcc96899e796bb92be5077145b10e31 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 19:45:33 +0200
Subject: [PATCH 06/55] Fix collapsible section re-collapse by shielding during
 AJAX

Reactive approaches (MutationObserver, setTimeout) lose the race because
the repeater's post-AJAX widget init can trigger another bindCollapsibleSections
pass after our correction fires.

Instead, prevent the problem: on ajaxBeforeSend, strip data-field-collapsible
from user-opened sections so bindCollapsibleSections() cannot select them.
Restore the attribute on ajaxComplete. Keep MutationObserver as backup.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 assets/dist/js/collapsible.js | 105 +++++++++++++++++++++-------------
 1 file changed, 66 insertions(+), 39 deletions(-)

diff --git a/assets/dist/js/collapsible.js b/assets/dist/js/collapsible.js
index e843e33..cbd01bd 100644
--- a/assets/dist/js/collapsible.js
+++ b/assets/dist/js/collapsible.js
@@ -1,20 +1,24 @@
 /**
  * Manages collapsible section state for block form widgets.
  *
- * WinterCMS calls bindCollapsibleSections() after every ajaxSuccess, which
- * re-collapses all [data-field-collapsible] sections — including ones the user
- * manually opened. A setTimeout race is unreliable because the repeater widget
- * may trigger further post-AJAX initialization that collapses again after our
- * timeout fires (visible as a "briefly shows then collapses" flicker).
+ * WinterCMS calls bindCollapsibleSections() after every AJAX call, re-collapsing
+ * all [data-field-collapsible] sections. Reacting after the fact (MutationObserver,
+ * setTimeout) is unreliable because the repeater's post-AJAX widget initialisation
+ * may trigger further collapse passes after our correction fires.
  *
- * Strategy:
- *  - User-opened sections are tracked via data-user-opened on the element.
- *  - A MutationObserver watches for the collapsed class being re-added to any
- *    data-user-opened section and removes it immediately — no visible flicker.
- *  - A userTogglingSection flag suppresses the observer during genuine user
- *    clicks so the user can still collapse sections normally.
- *  - Sections configured with collapsed: false (data-field-collapsible-open)
- *    are handled separately via setTimeout after ajaxSuccess (existing behaviour).
+ * Primary strategy — prevent, not fix:
+ *   Before each AJAX request (ajaxBeforeSend), temporarily strip data-field-collapsible
+ *   from any section the user has manually opened. bindCollapsibleSections() cannot
+ *   find what it cannot select. After the request completes (ajaxComplete), the
+ *   attribute is restored.
+ *
+ * Backup — MutationObserver:
+ *   Catches any programmatic re-collapse that slips through (e.g. from non-AJAX
+ *   widget initialisation). A userTogglingSection flag prevents it from fighting
+ *   genuine user click-to-collapse actions.
+ *
+ * User open/close state is stored as data-user-opened on the element itself so it
+ * survives across AJAX calls and DOM updates.
  */
 (function () {
     var userTogglingSection = false;
@@ -35,7 +39,8 @@
         ).forEach(openSection);
     }
 
-    // Track user click intent so the MutationObserver knows not to fight it
+    // Track whether the current click is a user-initiated section toggle so the
+    // MutationObserver knows not to undo it.
     document.addEventListener('click', function (e) {
         var section = e.target.closest('.section-field[data-field-collapsible]');
         if (!section) return;
@@ -51,37 +56,59 @@
         }, 0);
     });
 
-    // Immediately undo any programmatic re-collapse of a user-opened section.
-    // Fires synchronously (as a microtask) after the DOM change, before any
-    // setTimeout callbacks, so there is no visible flicker.
-    var observer = new MutationObserver(function (mutations) {
-        if (userTogglingSection) return;
-        mutations.forEach(function (mutation) {
-            var section = mutation.target;
-            if (
-                section.hasAttribute('data-user-opened') &&
-                section.classList.contains('collapsed')
-            ) {
-                openSection(section);
-            }
-        });
+    // --- Primary fix: shield user-opened sections from bindCollapsibleSections ---
+
+    // Before any AJAX call, hide user-opened sections from WinterCMS by removing
+    // data-field-collapsible so bindCollapsibleSections() cannot select them.
+    document.addEventListener('ajaxBeforeSend', function () {
+        document.querySelectorAll('.section-field[data-field-collapsible][data-user-opened]')
+            .forEach(function (s) {
+                s.removeAttribute('data-field-collapsible');
+                s.setAttribute('data-fc-suspended', '1');
+            });
     });
 
-    observer.observe(document.body, {
-        attributes: true,
-        attributeFilter: ['class'],
-        subtree: true,
+    // After the AJAX call (success or failure), restore the attribute.
+    document.addEventListener('ajaxComplete', function () {
+        document.querySelectorAll('.section-field[data-fc-suspended]')
+            .forEach(function (s) {
+                s.setAttribute('data-field-collapsible', '1');
+                s.removeAttribute('data-fc-suspended');
+            });
+        // Also re-open any collapsed: false sections in newly injected HTML
+        setTimeout(openConfiguredSections, 0);
     });
 
-    // Initial pass after form widget init
+    // --- Backup: MutationObserver for non-AJAX re-collapses ---
+
+    function setupObserver() {
+        var observer = new MutationObserver(function (mutations) {
+            if (userTogglingSection) return;
+            mutations.forEach(function (mutation) {
+                var section = mutation.target;
+                if (
+                    section.hasAttribute('data-user-opened') &&
+                    section.classList.contains('collapsed')
+                ) {
+                    openSection(section);
+                }
+            });
+        });
+        observer.observe(document.body, {
+            attributes: true,
+            attributeFilter: ['class'],
+            subtree: true,
+        });
+    }
+
+    // Initial open pass + observer setup after the form widget has initialised
     if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', function () { openConfiguredSections(); });
+        document.addEventListener('DOMContentLoaded', function () {
+            openConfiguredSections();
+            setupObserver();
+        });
     } else {
         setTimeout(openConfiguredSections, 0);
+        setupObserver();
     }
-
-    // Restore configured-open sections after AJAX (new repeater items etc.)
-    document.addEventListener('ajaxSuccess', function () {
-        setTimeout(openConfiguredSections, 0);
-    });
 })();

From f109fe8800749f072cb78bcc406c5c1750828f04 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 19:58:09 +0200
Subject: [PATCH 07/55] Fully own collapsible sections to fix repeater stall
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Root cause: core FormWidget.bindCollapsibleSections() runs on every widget
init scoped to the closest form. Adding a nested repeater item inits a new
FormWidget, which re-collapses all data-field-collapsible sections in the
shared form and binds a SECOND click handler to each — the doubled handler
made "Add item" appear to stall and snapped open sections shut.

Fix: emit data-block-collapsible (core's JS ignores it) and handle collapse
entirely in collapsible.js with a one-time per-section init guard and a single
delegated click handler that cannot double-bind. Reuses core's is-collapsible
/ collapsed CSS classes so styling is unchanged.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 README.md                     |   2 +-
 assets/dist/js/collapsible.js | 148 ++++++++++++++--------------------
 formwidgets/Blocks.php        |  10 ++-
 3 files changed, 68 insertions(+), 92 deletions(-)

diff --git a/README.md b/README.md
index 01f8e39..3eccf0d 100644
--- a/README.md
+++ b/README.md
@@ -171,7 +171,7 @@ fields:
 
 When `collapsible: true` is set, the section header becomes a click target. Sections start collapsed by default; set `collapsed: false` to have the section open on first load.
 
-> **Note:** `collapsed: false` requires the `collapsible.js` asset that is bundled with this fork. It runs after WinterCMS's core form JS (which collapses all collapsible sections) and re-opens any section marked `collapsed: false`.
+> **Note:** Collapsible behaviour is handled entirely by the `collapsible.js` asset bundled with this fork (via the `data-block-collapsible` attribute), independent of WinterCMS's core collapsible-section JS. This is deliberate: core re-collapses and re-binds every section on each form-widget init — including when a nested repeater adds an item — which broke manually-opened sections and stalled repeater "Add item" clicks. Owning the behaviour avoids that entirely, so collapsible sections work correctly even with repeater fields nested inside them.
 
 ---
 
diff --git a/assets/dist/js/collapsible.js b/assets/dist/js/collapsible.js
index cbd01bd..d2f9820 100644
--- a/assets/dist/js/collapsible.js
+++ b/assets/dist/js/collapsible.js
@@ -1,114 +1,84 @@
 /**
- * Manages collapsible section state for block form widgets.
+ * Self-contained collapsible sections for block form widgets.
  *
- * WinterCMS calls bindCollapsibleSections() after every AJAX call, re-collapsing
- * all [data-field-collapsible] sections. Reacting after the fact (MutationObserver,
- * setTimeout) is unreliable because the repeater's post-AJAX widget initialisation
- * may trigger further collapse passes after our correction fires.
+ * Why this exists instead of reusing core's data-field-collapsible:
  *
- * Primary strategy — prevent, not fix:
- *   Before each AJAX request (ajaxBeforeSend), temporarily strip data-field-collapsible
- *   from any section the user has manually opened. bindCollapsibleSections() cannot
- *   find what it cannot select. After the request completes (ajaxComplete), the
- *   attribute is restored.
+ *   WinterCMS's FormWidget.bindCollapsibleSections() runs on EVERY FormWidget
+ *   init(), scoped to the closest <form>. When a nested repeater adds an item,
+ *   a new FormWidget initialises, finds the shared parent form, and re-collapses
+ *   ALL data-field-collapsible sections in it while binding a SECOND click
+ *   handler to each. The doubled handler is why adding a repeater item appeared
+ *   to "stall" (two toggles cancel out) and why manually-opened sections snapped
+ *   shut again.
  *
- * Backup — MutationObserver:
- *   Catches any programmatic re-collapse that slips through (e.g. from non-AJAX
- *   widget initialisation). A userTogglingSection flag prevents it from fighting
- *   genuine user click-to-collapse actions.
- *
- * User open/close state is stored as data-user-opened on the element itself so it
- * survives across AJAX calls and DOM updates.
+ * Solution:
+ *   Blocks.php emits data-block-collapsible (and data-block-collapsible-open),
+ *   which core's JS never selects, so core never collapses or binds these.
+ *   This file owns everything:
+ *     - one-time init per section (guarded by .block-collapsible-ready)
+ *     - a single delegated click handler on document (cannot double-bind)
+ *   It reuses core's .is-collapsible / .collapsed CSS classes so the visual
+ *   styling (chevron, hover) is identical to native collapsible sections.
  */
 (function () {
-    var userTogglingSection = false;
+    var READY_CLASS = 'block-collapsible-ready';
 
-    function openSection(section) {
-        section.classList.remove('collapsed');
+    // Collect the fields that follow a section header up to the next section.
+    function followingFields(section) {
+        var els = [];
         var el = section.nextElementSibling;
         while (el && !el.classList.contains('section-field')) {
-            el.style.display = '';
+            els.push(el);
             el = el.nextElementSibling;
         }
+        return els;
     }
 
-    // Re-open sections configured with collapsed: false
-    function openConfiguredSections(root) {
-        (root || document).querySelectorAll(
-            '.section-field[data-field-collapsible][data-field-collapsible-open]'
-        ).forEach(openSection);
+    function setCollapsed(section, collapsed) {
+        section.classList.toggle('collapsed', collapsed);
+        followingFields(section).forEach(function (el) {
+            el.style.display = collapsed ? 'none' : '';
+        });
     }
 
-    // Track whether the current click is a user-initiated section toggle so the
-    // MutationObserver knows not to undo it.
-    document.addEventListener('click', function (e) {
-        var section = e.target.closest('.section-field[data-field-collapsible]');
-        if (!section) return;
-
-        userTogglingSection = true;
-        setTimeout(function () {
-            userTogglingSection = false;
-            if (section.classList.contains('collapsed')) {
-                section.removeAttribute('data-user-opened');
-            } else {
-                section.setAttribute('data-user-opened', '1');
-            }
-        }, 0);
-    });
+    // One-time setup for any not-yet-initialised collapsible section.
+    function initSections(root) {
+        (root || document)
+            .querySelectorAll('.section-field[data-block-collapsible]:not(.' + READY_CLASS + ')')
+            .forEach(function (section) {
+                section.classList.add(READY_CLASS);
 
-    // --- Primary fix: shield user-opened sections from bindCollapsibleSections ---
+                // Apply core's styling hook for the chevron + pointer cursor.
+                var header = section.querySelector('.field-section');
+                if (header) {
+                    header.classList.add('is-collapsible');
+                }
 
-    // Before any AJAX call, hide user-opened sections from WinterCMS by removing
-    // data-field-collapsible so bindCollapsibleSections() cannot select them.
-    document.addEventListener('ajaxBeforeSend', function () {
-        document.querySelectorAll('.section-field[data-field-collapsible][data-user-opened]')
-            .forEach(function (s) {
-                s.removeAttribute('data-field-collapsible');
-                s.setAttribute('data-fc-suspended', '1');
+                // Initial state: collapsed unless explicitly marked open.
+                var startOpen = section.hasAttribute('data-block-collapsible-open');
+                setCollapsed(section, !startOpen);
             });
-    });
+    }
 
-    // After the AJAX call (success or failure), restore the attribute.
-    document.addEventListener('ajaxComplete', function () {
-        document.querySelectorAll('.section-field[data-fc-suspended]')
-            .forEach(function (s) {
-                s.setAttribute('data-field-collapsible', '1');
-                s.removeAttribute('data-fc-suspended');
-            });
-        // Also re-open any collapsed: false sections in newly injected HTML
-        setTimeout(openConfiguredSections, 0);
+    // Single delegated click handler — never doubles regardless of widget inits.
+    document.addEventListener('click', function (e) {
+        var section = e.target.closest('.section-field[data-block-collapsible]');
+        if (!section) {
+            return;
+        }
+        setCollapsed(section, !section.classList.contains('collapsed'));
     });
 
-    // --- Backup: MutationObserver for non-AJAX re-collapses ---
-
-    function setupObserver() {
-        var observer = new MutationObserver(function (mutations) {
-            if (userTogglingSection) return;
-            mutations.forEach(function (mutation) {
-                var section = mutation.target;
-                if (
-                    section.hasAttribute('data-user-opened') &&
-                    section.classList.contains('collapsed')
-                ) {
-                    openSection(section);
-                }
-            });
-        });
-        observer.observe(document.body, {
-            attributes: true,
-            attributeFilter: ['class'],
-            subtree: true,
-        });
-    }
-
-    // Initial open pass + observer setup after the form widget has initialised
+    // Initial pass.
     if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', function () {
-            openConfiguredSections();
-            setupObserver();
-        });
+        document.addEventListener('DOMContentLoaded', function () { initSections(); });
     } else {
-        setTimeout(openConfiguredSections, 0);
-        setupObserver();
+        initSections();
     }
+
+    // Initialise sections inside any HTML injected by AJAX (new repeater items,
+    // newly added blocks). Already-initialised sections are skipped via the
+    // guard class, so existing open/closed state is preserved.
+    document.addEventListener('ajaxSuccess', function () { initSections(); });
+    document.addEventListener('render', function () { initSections(); });
 })();
diff --git a/formwidgets/Blocks.php b/formwidgets/Blocks.php
index 4899d02..6f44be1 100644
--- a/formwidgets/Blocks.php
+++ b/formwidgets/Blocks.php
@@ -244,13 +244,19 @@ protected function normalizeBlockFields(array $fields): array
             if ($field['collapsible']) {
                 $startCollapsed = $field['collapsed'] ?? true;
 
+                // Use our own data attribute (NOT data-field-collapsible) so the
+                // core form widget's bindCollapsibleSections() never touches these
+                // sections. Core re-runs that on every FormWidget init — including
+                // when a nested repeater adds an item — which would re-collapse and
+                // double-bind handlers on sections the user manually opened. We own
+                // the behaviour entirely in collapsible.js instead.
                 $field['containerAttributes'] = array_merge(
                     $field['containerAttributes'] ?? [],
-                    ['data-field-collapsible' => 1]
+                    ['data-block-collapsible' => 1]
                 );
 
                 if (!$startCollapsed) {
-                    $field['containerAttributes']['data-field-collapsible-open'] = 1;
+                    $field['containerAttributes']['data-block-collapsible-open'] = 1;
                 }
             }
 

From b2fe297ffff76baa3ab7b57ab7639f38b381eeaf Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 20:02:47 +0200
Subject: [PATCH 08/55] Use MutationObserver for collapsible section init
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

DOMContentLoaded / ajaxSuccess / render via native addEventListener never
fired: block section fields are injected by AJAX, and the backend dispatches
lifecycle events through jQuery, which native listeners don't receive. Result
was that nothing collapsed at all.

Detect sections with a MutationObserver instead — fires on any DOM insertion
regardless of framework. Per-section guard class keeps init idempotent;
childList-only observation avoids a feedback loop from our class/style writes.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 assets/dist/js/collapsible.js | 58 +++++++++++++++++++++++------------
 1 file changed, 39 insertions(+), 19 deletions(-)

diff --git a/assets/dist/js/collapsible.js b/assets/dist/js/collapsible.js
index d2f9820..0686caa 100644
--- a/assets/dist/js/collapsible.js
+++ b/assets/dist/js/collapsible.js
@@ -14,11 +14,15 @@
  * Solution:
  *   Blocks.php emits data-block-collapsible (and data-block-collapsible-open),
  *   which core's JS never selects, so core never collapses or binds these.
- *   This file owns everything:
- *     - one-time init per section (guarded by .block-collapsible-ready)
- *     - a single delegated click handler on document (cannot double-bind)
- *   It reuses core's .is-collapsible / .collapsed CSS classes so the visual
- *   styling (chevron, hover) is identical to native collapsible sections.
+ *   This file owns everything and reuses core's .is-collapsible / .collapsed CSS
+ *   classes so the styling is identical to native collapsible sections.
+ *
+ * Init detection uses a MutationObserver rather than DOMContentLoaded / ajax
+ * events: the block form fields (and nested repeater items) are injected by
+ * AJAX, and the backend dispatches its lifecycle events through jQuery, which
+ * native addEventListener handlers do not reliably receive. The observer fires
+ * on any DOM insertion regardless of framework, so newly rendered sections are
+ * always picked up. A per-section guard class makes init idempotent and cheap.
  */
 (function () {
     var READY_CLASS = 'block-collapsible-ready';
@@ -42,8 +46,8 @@
     }
 
     // One-time setup for any not-yet-initialised collapsible section.
-    function initSections(root) {
-        (root || document)
+    function initSections() {
+        document
             .querySelectorAll('.section-field[data-block-collapsible]:not(.' + READY_CLASS + ')')
             .forEach(function (section) {
                 section.classList.add(READY_CLASS);
@@ -60,7 +64,8 @@
             });
     }
 
-    // Single delegated click handler — never doubles regardless of widget inits.
+    // Single delegated click handler — native click events bubble normally, so
+    // addEventListener is reliable here (unlike framework lifecycle events).
     document.addEventListener('click', function (e) {
         var section = e.target.closest('.section-field[data-block-collapsible]');
         if (!section) {
@@ -69,16 +74,31 @@
         setCollapsed(section, !section.classList.contains('collapsed'));
     });
 
-    // Initial pass.
-    if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', function () { initSections(); });
-    } else {
-        initSections();
-    }
+    // Run once now for anything already present.
+    initSections();
+
+    // Watch for sections injected later (block forms, repeater items). Observing
+    // childList only — our own class/style writes are attribute mutations and
+    // won't retrigger this, so there is no feedback loop.
+    var scheduled = false;
+    var observer = new MutationObserver(function () {
+        if (scheduled) {
+            return;
+        }
+        scheduled = true;
+        // Coalesce bursts of insertions into a single pass.
+        (window.requestAnimationFrame || window.setTimeout)(function () {
+            scheduled = false;
+            initSections();
+        }, 0);
+    });
 
-    // Initialise sections inside any HTML injected by AJAX (new repeater items,
-    // newly added blocks). Already-initialised sections are skipped via the
-    // guard class, so existing open/closed state is preserved.
-    document.addEventListener('ajaxSuccess', function () { initSections(); });
-    document.addEventListener('render', function () { initSections(); });
+    function startObserving() {
+        if (document.body) {
+            observer.observe(document.body, { childList: true, subtree: true });
+        } else {
+            document.addEventListener('DOMContentLoaded', startObserving);
+        }
+    }
+    startObserving();
 })();

From 0a29d9b9fc57569c28498c9add44999687186a03 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 20:09:32 +0200
Subject: [PATCH 09/55] Place collapsible.js in the widget's actual asset path
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Blocks widget resolves addJs('js/collapsible.js') relative to
formwidgets/blocks/assets/ (via guessViewPath), not assets/dist/. The file
only existed under assets/dist/js/, so it 404'd and never loaded — which is
why collapsible sections stopped working after switching to the
data-block-collapsible attribute that core's JS ignores.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 formwidgets/blocks/assets/js/collapsible.js | 104 ++++++++++++++++++++
 1 file changed, 104 insertions(+)
 create mode 100644 formwidgets/blocks/assets/js/collapsible.js

diff --git a/formwidgets/blocks/assets/js/collapsible.js b/formwidgets/blocks/assets/js/collapsible.js
new file mode 100644
index 0000000..0686caa
--- /dev/null
+++ b/formwidgets/blocks/assets/js/collapsible.js
@@ -0,0 +1,104 @@
+/**
+ * Self-contained collapsible sections for block form widgets.
+ *
+ * Why this exists instead of reusing core's data-field-collapsible:
+ *
+ *   WinterCMS's FormWidget.bindCollapsibleSections() runs on EVERY FormWidget
+ *   init(), scoped to the closest <form>. When a nested repeater adds an item,
+ *   a new FormWidget initialises, finds the shared parent form, and re-collapses
+ *   ALL data-field-collapsible sections in it while binding a SECOND click
+ *   handler to each. The doubled handler is why adding a repeater item appeared
+ *   to "stall" (two toggles cancel out) and why manually-opened sections snapped
+ *   shut again.
+ *
+ * Solution:
+ *   Blocks.php emits data-block-collapsible (and data-block-collapsible-open),
+ *   which core's JS never selects, so core never collapses or binds these.
+ *   This file owns everything and reuses core's .is-collapsible / .collapsed CSS
+ *   classes so the styling is identical to native collapsible sections.
+ *
+ * Init detection uses a MutationObserver rather than DOMContentLoaded / ajax
+ * events: the block form fields (and nested repeater items) are injected by
+ * AJAX, and the backend dispatches its lifecycle events through jQuery, which
+ * native addEventListener handlers do not reliably receive. The observer fires
+ * on any DOM insertion regardless of framework, so newly rendered sections are
+ * always picked up. A per-section guard class makes init idempotent and cheap.
+ */
+(function () {
+    var READY_CLASS = 'block-collapsible-ready';
+
+    // Collect the fields that follow a section header up to the next section.
+    function followingFields(section) {
+        var els = [];
+        var el = section.nextElementSibling;
+        while (el && !el.classList.contains('section-field')) {
+            els.push(el);
+            el = el.nextElementSibling;
+        }
+        return els;
+    }
+
+    function setCollapsed(section, collapsed) {
+        section.classList.toggle('collapsed', collapsed);
+        followingFields(section).forEach(function (el) {
+            el.style.display = collapsed ? 'none' : '';
+        });
+    }
+
+    // One-time setup for any not-yet-initialised collapsible section.
+    function initSections() {
+        document
+            .querySelectorAll('.section-field[data-block-collapsible]:not(.' + READY_CLASS + ')')
+            .forEach(function (section) {
+                section.classList.add(READY_CLASS);
+
+                // Apply core's styling hook for the chevron + pointer cursor.
+                var header = section.querySelector('.field-section');
+                if (header) {
+                    header.classList.add('is-collapsible');
+                }
+
+                // Initial state: collapsed unless explicitly marked open.
+                var startOpen = section.hasAttribute('data-block-collapsible-open');
+                setCollapsed(section, !startOpen);
+            });
+    }
+
+    // Single delegated click handler — native click events bubble normally, so
+    // addEventListener is reliable here (unlike framework lifecycle events).
+    document.addEventListener('click', function (e) {
+        var section = e.target.closest('.section-field[data-block-collapsible]');
+        if (!section) {
+            return;
+        }
+        setCollapsed(section, !section.classList.contains('collapsed'));
+    });
+
+    // Run once now for anything already present.
+    initSections();
+
+    // Watch for sections injected later (block forms, repeater items). Observing
+    // childList only — our own class/style writes are attribute mutations and
+    // won't retrigger this, so there is no feedback loop.
+    var scheduled = false;
+    var observer = new MutationObserver(function () {
+        if (scheduled) {
+            return;
+        }
+        scheduled = true;
+        // Coalesce bursts of insertions into a single pass.
+        (window.requestAnimationFrame || window.setTimeout)(function () {
+            scheduled = false;
+            initSections();
+        }, 0);
+    });
+
+    function startObserving() {
+        if (document.body) {
+            observer.observe(document.body, { childList: true, subtree: true });
+        } else {
+            document.addEventListener('DOMContentLoaded', startObserving);
+        }
+    }
+    startObserving();
+})();

From 75e3ee017f1042ce6973a74118081c4daaadfa28 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 20:13:20 +0200
Subject: [PATCH 10/55] Inline collapsible-sections bootstrap in block widget
 partial

addJs path/combiner resolution proved unreliable (the file resolved to a
location where it 404'd). Embed the collapse logic inline in _block.php with
a global one-time guard so it is guaranteed to load. Uses data-block-collapsible
(ignored by core) plus a MutationObserver, so sections collapse correctly and
nested repeaters no longer stall.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 formwidgets/blocks/partials/_block.php | 74 ++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index c4d2f04..4a14502 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -85,4 +85,78 @@ class="form-control blocks-group-search"
             </div>
         </div>
     </script>
+
+    <?php
+    /*
+     * Inline bootstrap for collapsible block sections.
+     *
+     * Loaded inline (rather than only via addJs) so it is guaranteed to reach the
+     * page regardless of widget asset-path resolution or the asset combiner. A
+     * global guard ensures the handlers are registered only once even when several
+     * block widgets render on the same page.
+     *
+     * Behaviour lives on the data-block-collapsible attribute, which the core form
+     * widget's bindCollapsibleSections() never selects — so core cannot re-collapse
+     * or double-bind these sections when a nested repeater adds an item.
+     */
+    ?>
+    <script>
+    (function () {
+        if (window.__blockCollapsibleInit) { return; }
+        window.__blockCollapsibleInit = true;
+
+        var READY = 'block-collapsible-ready';
+
+        function followingFields(section) {
+            var els = [], el = section.nextElementSibling;
+            while (el && !el.classList.contains('section-field')) {
+                els.push(el);
+                el = el.nextElementSibling;
+            }
+            return els;
+        }
+
+        function setCollapsed(section, collapsed) {
+            section.classList.toggle('collapsed', collapsed);
+            followingFields(section).forEach(function (el) {
+                el.style.display = collapsed ? 'none' : '';
+            });
+        }
+
+        function initSections() {
+            document.querySelectorAll(
+                '.section-field[data-block-collapsible]:not(.' + READY + ')'
+            ).forEach(function (section) {
+                section.classList.add(READY);
+                var header = section.querySelector('.field-section');
+                if (header) { header.classList.add('is-collapsible'); }
+                var startOpen = section.hasAttribute('data-block-collapsible-open');
+                setCollapsed(section, !startOpen);
+            });
+        }
+
+        document.addEventListener('click', function (e) {
+            var section = e.target.closest('.section-field[data-block-collapsible]');
+            if (!section) { return; }
+            setCollapsed(section, !section.classList.contains('collapsed'));
+        });
+
+        initSections();
+
+        var scheduled = false;
+        var observer = new MutationObserver(function () {
+            if (scheduled) { return; }
+            scheduled = true;
+            setTimeout(function () { scheduled = false; initSections(); }, 0);
+        });
+        function startObserving() {
+            if (document.body) {
+                observer.observe(document.body, { childList: true, subtree: true });
+            } else {
+                document.addEventListener('DOMContentLoaded', startObserving);
+            }
+        }
+        startObserving();
+    })();
+    </script>
 </div>

From 0982f316d9fab63920c212daa9c30c6077d7bde4 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 20:16:10 +0200
Subject: [PATCH 11/55] Remove unused collapsible.js; inline bootstrap is
 canonical

The standalone collapsible.js never reliably loaded via addJs. The collapse
logic now lives inline in the block widget partial, so both copies of
collapsible.js and the addJs registration are dead and removed.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .DS_Store                                   | Bin 0 -> 10244 bytes
 README.md                                   |   2 +-
 assets/.DS_Store                            | Bin 0 -> 8196 bytes
 assets/dist/.DS_Store                       | Bin 0 -> 6148 bytes
 assets/dist/js/collapsible.js               | 104 --------------------
 formwidgets/Blocks.php                      |   4 +-
 formwidgets/blocks/assets/js/collapsible.js | 104 --------------------
 7 files changed, 4 insertions(+), 210 deletions(-)
 create mode 100644 .DS_Store
 create mode 100644 assets/.DS_Store
 create mode 100644 assets/dist/.DS_Store
 delete mode 100644 assets/dist/js/collapsible.js
 delete mode 100644 formwidgets/blocks/assets/js/collapsible.js

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..24c74b7ab70a600fa7ead2ab0f4eaadecaa1f514
GIT binary patch
literal 10244
zcmeHMU2GIp6uxKrH$#W^0!0e$goQ%*$pWQdTmH=UPbq%|wx!!rSY~$yIxss^c4l`A
zZDV8N3kb$1jsHApH1c3Ti7%R{h(2mH!5ANi8ubMeeNlPv+_|%4yM-4c351!=+;i_a
z_uM<@%y;(exl0Iv_N=y^kT4-c#G6qnV{?a#$=N;Q5`0cAQb2t|T;e42&PdX<lQU)q
zjKBkd2LcZS9tb=Tc;J5U0Oo9ViPfA2ZQy~x1Azx_dw_jEgz;uH>eES1y{`^zyb=Iu
zIkLSA`&b8fI$@tieLBghr;2Ox>H&OJ@JkHf>L?Gh=}4nKo#d3O6X5Cu{GGwCP{7+A
z^}^nC0#QzbHt;~;ftem)wR<H|iGv@#q<+7W95D^YZEXA&gtGFA$||u+tQHT&hV6XJ
zRo$%9u4WFhQLk;A$wFUE9x(KLg4T7|ma7_;p79h6O~)xi{f4F4`F1;NX^y8G;{s6<
zr39@X8*6TEjD(w-n<paSu}w|b-?*W9VnPz<H>}&TKXJlLTlN`l2KZkEWOj*JXG?9;
zoRpcwXJqrH8EZPZ4t`is7AqM0UBOssR<%4^>5mT#9+VSwZVs*L8F3BUat`Pj2Wf)V
zI%s`&%C`1qbSCdl*=9CvISD!^rJAX%sk(ZbX~vAxI`V3rRK_;Vy|!bpWd`D|KI$^r
z3{ia0u`_Omw^-c3_4zECb@cr@E^6fTPF&ilE3q7;i!}=tFI%~$sby=lt9$ppsaiT`
z?z}o#9z-`=u5r}RGktkObB701C#74OVIAww8IF-O^<GO&>vJF?NmI4;3l}{aQk1(*
zjc1d_$*kd?q79<x?Gaw0$U_=F({5X1yJ+;Xi0k0)%a<t1K_=<Q=-6t$!m8DZ-0Pt6
zRP`sWT_?-EClDXhVUK{S8#c;HpQ$EwlWG#*r*)I8^yj$$=}w=ytxi_rDLb7;6CIz|
z)~+ar*|xh>$L$%>EqtVF{@zcZY|t52GkQ-R@#%ASAlG}P$Y)Ajn&H}>5WTSntr%d-
zwP~7X!=n0ywMtCs6X{oCf>OiE85k4zT6t)Q4TV?J5M9l?4Ihv5j_2rxXd@p<nE4da
zL^{bXa)e~a7&%8?Bp1jf@)@~Gz9B!5U&&4K7XVa(1hb$T>R=Hpg9tnZEzk;^pdET(
zAMA%148brMa2y;Mh0`zw<M0fefoI_yoQD_SRd^lVfD7<8ya$)yGQ1BT!8P~-zJ#yg
z2K)#=!Ow6L{)T_xmQW!q5bA}6!crk3tP$1<EkdiXS=b`%5qgBUpbEzYTNvdA2!%L2
z#K(nJIEB5^aP!Xwg^PC%x6qT@yLaq-aKi0+4G*ySk1Pl;U%hT)>$bMrK;+0RfVDUT
zJls!<77zCxE=n*v#UoK(T!_-rknF>N(MLrVx3r4SUMepWF<@u~AFhyBi5M!hk`E)H
zwIT*56}+LmKD0r?5Ts>%7zwpVA_YF!EN_)C7-=~lDsohkDDeiNj!>6~0Y%0C3+dO%
z4e|^5o!mmC*T6iehZWF>_<kI=!yZI9!*?GXh6JdP1P#()!3dm0tdGM4JOz{RG@M1O
zpNHq*d3Xt4hF9P<coW`2yuSnQBHBNIEASzF0-wTF_}s_+_lWx6;Exg{?=E1NQ~0wK
z$+=j@GHvS^@)`OoNs^evCMj}a+6nlBok5Finw~+61VIK3GH8%N?`;O19&SMf#UGJD
z2ED^?#rr>l79qJLgH~bgG;i0TPI11eCPy)~W=NXki9s}Sj2EhfDJ=h%qmWgvYB93{
z89J7=_@{I+yNYDV2ri>?aj^(jdYG;<ZfuyH|99Q}|Nn={C4sGh2Oc^PKzV1ZvmMPY
z6!N7WU}x=NypQ0`E;etHQ%?mO?>HW*cN~ucb{xMFZ#LII=<xbcpEt>=r;c+xb)@_>
a|DOLDP;wIY-;djZ`ah`u5y=l={r@jL$-5{3

literal 0
HcmV?d00001

diff --git a/README.md b/README.md
index 3eccf0d..436d518 100644
--- a/README.md
+++ b/README.md
@@ -171,7 +171,7 @@ fields:
 
 When `collapsible: true` is set, the section header becomes a click target. Sections start collapsed by default; set `collapsed: false` to have the section open on first load.
 
-> **Note:** Collapsible behaviour is handled entirely by the `collapsible.js` asset bundled with this fork (via the `data-block-collapsible` attribute), independent of WinterCMS's core collapsible-section JS. This is deliberate: core re-collapses and re-binds every section on each form-widget init — including when a nested repeater adds an item — which broke manually-opened sections and stalled repeater "Add item" clicks. Owning the behaviour avoids that entirely, so collapsible sections work correctly even with repeater fields nested inside them.
+> **Note:** Collapsible behaviour is handled by this fork via the `data-block-collapsible` attribute, bootstrapped inline in the block widget partial (`formwidgets/blocks/partials/_block.php`), independent of WinterCMS's core collapsible-section JS. This is deliberate: core re-collapses and re-binds every section on each form-widget init — including when a nested repeater adds an item — which broke manually-opened sections and stalled repeater "Add item" clicks. Owning the behaviour avoids that entirely, so collapsible sections work correctly even with repeater fields nested inside them.
 
 ---
 
diff --git a/assets/.DS_Store b/assets/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..1370b0d4a8146c31155967ebca97cbd9651bf194
GIT binary patch
literal 8196
zcmeHMTWl0n7(U;$(3#=V)7qA{6JSFllv1P=S>$5a-mvA8Vz;HGRM**^0VYgm>dx#g
zNQhPAgM!AW@eRDbVxo!02tgivz!x9PO2lYPeDK8=(ML`6pE<Kw3Otw)L&BV7&VSB-
z{{LLQ^Zj%7%reH%TQD{<*31}_=?NrXMA>ap&>lRuBq`EVlLYy*Y{{F++HRKWpWR{|
zD`Es<1Y!hY1Y!hY1nva{=*$k1e1~&iw8nXiK#ahBi9qmvNYE3=R3vAG3|}3Tg;xNQ
z!4)7(ROUf}WFnHONX`mLEtDW!NeWj)R}2Vu(kCLjR3vAG6z&Ys<pa^kh;AqdN2mT1
zp*cfJ$T*J?h!MCIfgpUUnZYdPF@Ns;Jv(Dtp5N7V6;f68f`v75jl4*HB7M{?rG4Em
zc)fc5P*59nT{~MT>)8XAS<3K+KG*Se%Q5qzgJqaxGBs{FhFj`&3y$H1zG=}QE3%T|
z%_mPLlU<#O?qu>*XX516ZYn>#DS7IYA~&{e*glduW=}ir%VG(LUIT2&yd|BUyB^ys
z_KEKiRgIPPd{<eIqAt=7j8CW;USFh156}3P>v#vuyhk#_Ydu=rP|kJs=gpvfJm=bl
zX~)a(x}0w33byW>J+_^;o-w@%-#qRIrAg1t`+cF|ghjrAF2i}jGe=Bvu!?3sxp@uq
zCJp7o#f{5XtzOr)dE3tZ!M*#-OP1DhwO(x)FIt|Jwau}TW%x%A>R!%t49ht(Nys_A
zb=WfV3csL?I{LI(=1t3*TUs@3zHz0Ki9*(Tx?uSyc$+Mj`O?}YD^_ailtEM4=Ndt0
z2LD7>!j`s`nsz8?>C2mx8<E4Bc1<1iXjNQ~3_I7W>gX}rS?(#qbz`@xjoEtEw7H>(
zagtk9ZM-O;<$EIK_8qD=k#nb~X(e7AIwN(eN7J4RM&7G?{_u?H(5$XR!w*o~q<2)$
zo5Lj{SEL;xZMb2i51a-J%Xh;@0%RX8<Y3TUk70z%Xl`1@wGnMp=HJM)H<nYhh|sj>
zg4c3eszYo~2x?oZOVkuPpjy~NbPx`*DQ2=6c7mN@XW2P+o_)$Lu`k)z>>B%?{lI=?
zKeJ!ib@nH!uoz2G3yv17MmyG`1DmiDDfD1BhVeK?kj4~r<Y2&r10O|{a2(I!C7i|?
zyn?szHr~Vg_yFf|5tr}<F5@ed@hz_6CtSzx_yd1Q3#A%Kmg=N>sX=O#+NHHpx3on{
ziK$DKV3`#4N-p(K=|=EVutXp4q?y|VOY5%32Jekvxwbe6kGlE?8X8x$wXg3^Zcp9d
zksw}$YjYVK()K2@hqMiMc^==&B9PSOmB^VNQDek+^SB(4me&aDgt|&5zVij5`k=Z-
zCZ_X+qT12gDN}55DXgj+S~n^bLA**-J6bm@GKZ)<qHa?tmUwl!Wm$96jz?9MGYWA<
zbky70FH<;h`M>k@BlbDF%&xF9@$?sB=x^+A$i&SiB#51Bh@0!M9!YG$R&2u#3}6=q
zF@!xB#Tdphfyt1khj9cJ^6)~oK8smAj~DPFUd3y89dF=GoW(i3gLfm=evAwAc(}X5
zKp}B)E)R?8ykoo05z<w7d$W05yGsaEiGG@c`~Se5zyIH*(c*4m1Y!j4MFddYpYHFa
znceAq8{D-M^gKmRkOI3|Aww6+!s|H6@H$TN#vg`MPLOHflZxc5kffpXzkdk$_s4F0
N{>SHk$ie$D`v+n48NUDk

literal 0
HcmV?d00001

diff --git a/assets/dist/.DS_Store b/assets/dist/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..ba3b77f6a8c3248a9cea646d67980a85d45fcca5
GIT binary patch
literal 6148
zcmeH~Jr2S!425lAKw|00n1usyg9yP1xBvnsRH*}E&(V4QVW2Rh3O!5q7rU|AzM-i_
zM0bztR-_Y=CEO?*3nNqHGr7tAdcXANVd$-pHcMIw-pT0tYadAkr~nn90#twsOh<t{
z%9pF@JQAOT3Q&QGC}7`*0yoxV3;L%6!AAgafwCLcK1+bb3SdpPASy78Rxn!C#}KP~
zJ6LjGO}1dPi{|j5d1tjL2By(2T9ClBIvA(`6&NWnkG!+<{{a6s|BqUjQUNOPXA0<I
zf86izQhBz1yq?uhS+#Y8gT5W%?I!?<9mQ+78?F~yfHm2IsKEFm;4&~!fuAby1c*xz
AIsgCw

literal 0
HcmV?d00001

diff --git a/assets/dist/js/collapsible.js b/assets/dist/js/collapsible.js
deleted file mode 100644
index 0686caa..0000000
--- a/assets/dist/js/collapsible.js
+++ /dev/null
@@ -1,104 +0,0 @@
-/**
- * Self-contained collapsible sections for block form widgets.
- *
- * Why this exists instead of reusing core's data-field-collapsible:
- *
- *   WinterCMS's FormWidget.bindCollapsibleSections() runs on EVERY FormWidget
- *   init(), scoped to the closest <form>. When a nested repeater adds an item,
- *   a new FormWidget initialises, finds the shared parent form, and re-collapses
- *   ALL data-field-collapsible sections in it while binding a SECOND click
- *   handler to each. The doubled handler is why adding a repeater item appeared
- *   to "stall" (two toggles cancel out) and why manually-opened sections snapped
- *   shut again.
- *
- * Solution:
- *   Blocks.php emits data-block-collapsible (and data-block-collapsible-open),
- *   which core's JS never selects, so core never collapses or binds these.
- *   This file owns everything and reuses core's .is-collapsible / .collapsed CSS
- *   classes so the styling is identical to native collapsible sections.
- *
- * Init detection uses a MutationObserver rather than DOMContentLoaded / ajax
- * events: the block form fields (and nested repeater items) are injected by
- * AJAX, and the backend dispatches its lifecycle events through jQuery, which
- * native addEventListener handlers do not reliably receive. The observer fires
- * on any DOM insertion regardless of framework, so newly rendered sections are
- * always picked up. A per-section guard class makes init idempotent and cheap.
- */
-(function () {
-    var READY_CLASS = 'block-collapsible-ready';
-
-    // Collect the fields that follow a section header up to the next section.
-    function followingFields(section) {
-        var els = [];
-        var el = section.nextElementSibling;
-        while (el && !el.classList.contains('section-field')) {
-            els.push(el);
-            el = el.nextElementSibling;
-        }
-        return els;
-    }
-
-    function setCollapsed(section, collapsed) {
-        section.classList.toggle('collapsed', collapsed);
-        followingFields(section).forEach(function (el) {
-            el.style.display = collapsed ? 'none' : '';
-        });
-    }
-
-    // One-time setup for any not-yet-initialised collapsible section.
-    function initSections() {
-        document
-            .querySelectorAll('.section-field[data-block-collapsible]:not(.' + READY_CLASS + ')')
-            .forEach(function (section) {
-                section.classList.add(READY_CLASS);
-
-                // Apply core's styling hook for the chevron + pointer cursor.
-                var header = section.querySelector('.field-section');
-                if (header) {
-                    header.classList.add('is-collapsible');
-                }
-
-                // Initial state: collapsed unless explicitly marked open.
-                var startOpen = section.hasAttribute('data-block-collapsible-open');
-                setCollapsed(section, !startOpen);
-            });
-    }
-
-    // Single delegated click handler — native click events bubble normally, so
-    // addEventListener is reliable here (unlike framework lifecycle events).
-    document.addEventListener('click', function (e) {
-        var section = e.target.closest('.section-field[data-block-collapsible]');
-        if (!section) {
-            return;
-        }
-        setCollapsed(section, !section.classList.contains('collapsed'));
-    });
-
-    // Run once now for anything already present.
-    initSections();
-
-    // Watch for sections injected later (block forms, repeater items). Observing
-    // childList only — our own class/style writes are attribute mutations and
-    // won't retrigger this, so there is no feedback loop.
-    var scheduled = false;
-    var observer = new MutationObserver(function () {
-        if (scheduled) {
-            return;
-        }
-        scheduled = true;
-        // Coalesce bursts of insertions into a single pass.
-        (window.requestAnimationFrame || window.setTimeout)(function () {
-            scheduled = false;
-            initSections();
-        }, 0);
-    });
-
-    function startObserving() {
-        if (document.body) {
-            observer.observe(document.body, { childList: true, subtree: true });
-        } else {
-            document.addEventListener('DOMContentLoaded', startObserving);
-        }
-    }
-    startObserving();
-})();
diff --git a/formwidgets/Blocks.php b/formwidgets/Blocks.php
index 6f44be1..c256269 100644
--- a/formwidgets/Blocks.php
+++ b/formwidgets/Blocks.php
@@ -53,7 +53,9 @@ protected function loadAssets()
     {
         $this->addCss('css/blocks.css', 'Winter.Blocks');
         $this->addJs('js/blocks.js', 'Winter.Blocks');
-        $this->addJs('js/collapsible.js', 'Winter.Blocks');
+        // Collapsible-section behaviour is bootstrapped inline in the block
+        // widget partial (formwidgets/blocks/partials/_block.php) so it loads
+        // reliably regardless of asset-path resolution or the asset combiner.
     }
 
     /**
diff --git a/formwidgets/blocks/assets/js/collapsible.js b/formwidgets/blocks/assets/js/collapsible.js
deleted file mode 100644
index 0686caa..0000000
--- a/formwidgets/blocks/assets/js/collapsible.js
+++ /dev/null
@@ -1,104 +0,0 @@
-/**
- * Self-contained collapsible sections for block form widgets.
- *
- * Why this exists instead of reusing core's data-field-collapsible:
- *
- *   WinterCMS's FormWidget.bindCollapsibleSections() runs on EVERY FormWidget
- *   init(), scoped to the closest <form>. When a nested repeater adds an item,
- *   a new FormWidget initialises, finds the shared parent form, and re-collapses
- *   ALL data-field-collapsible sections in it while binding a SECOND click
- *   handler to each. The doubled handler is why adding a repeater item appeared
- *   to "stall" (two toggles cancel out) and why manually-opened sections snapped
- *   shut again.
- *
- * Solution:
- *   Blocks.php emits data-block-collapsible (and data-block-collapsible-open),
- *   which core's JS never selects, so core never collapses or binds these.
- *   This file owns everything and reuses core's .is-collapsible / .collapsed CSS
- *   classes so the styling is identical to native collapsible sections.
- *
- * Init detection uses a MutationObserver rather than DOMContentLoaded / ajax
- * events: the block form fields (and nested repeater items) are injected by
- * AJAX, and the backend dispatches its lifecycle events through jQuery, which
- * native addEventListener handlers do not reliably receive. The observer fires
- * on any DOM insertion regardless of framework, so newly rendered sections are
- * always picked up. A per-section guard class makes init idempotent and cheap.
- */
-(function () {
-    var READY_CLASS = 'block-collapsible-ready';
-
-    // Collect the fields that follow a section header up to the next section.
-    function followingFields(section) {
-        var els = [];
-        var el = section.nextElementSibling;
-        while (el && !el.classList.contains('section-field')) {
-            els.push(el);
-            el = el.nextElementSibling;
-        }
-        return els;
-    }
-
-    function setCollapsed(section, collapsed) {
-        section.classList.toggle('collapsed', collapsed);
-        followingFields(section).forEach(function (el) {
-            el.style.display = collapsed ? 'none' : '';
-        });
-    }
-
-    // One-time setup for any not-yet-initialised collapsible section.
-    function initSections() {
-        document
-            .querySelectorAll('.section-field[data-block-collapsible]:not(.' + READY_CLASS + ')')
-            .forEach(function (section) {
-                section.classList.add(READY_CLASS);
-
-                // Apply core's styling hook for the chevron + pointer cursor.
-                var header = section.querySelector('.field-section');
-                if (header) {
-                    header.classList.add('is-collapsible');
-                }
-
-                // Initial state: collapsed unless explicitly marked open.
-                var startOpen = section.hasAttribute('data-block-collapsible-open');
-                setCollapsed(section, !startOpen);
-            });
-    }
-
-    // Single delegated click handler — native click events bubble normally, so
-    // addEventListener is reliable here (unlike framework lifecycle events).
-    document.addEventListener('click', function (e) {
-        var section = e.target.closest('.section-field[data-block-collapsible]');
-        if (!section) {
-            return;
-        }
-        setCollapsed(section, !section.classList.contains('collapsed'));
-    });
-
-    // Run once now for anything already present.
-    initSections();
-
-    // Watch for sections injected later (block forms, repeater items). Observing
-    // childList only — our own class/style writes are attribute mutations and
-    // won't retrigger this, so there is no feedback loop.
-    var scheduled = false;
-    var observer = new MutationObserver(function () {
-        if (scheduled) {
-            return;
-        }
-        scheduled = true;
-        // Coalesce bursts of insertions into a single pass.
-        (window.requestAnimationFrame || window.setTimeout)(function () {
-            scheduled = false;
-            initSections();
-        }, 0);
-    });
-
-    function startObserving() {
-        if (document.body) {
-            observer.observe(document.body, { childList: true, subtree: true });
-        } else {
-            document.addEventListener('DOMContentLoaded', startObserving);
-        }
-    }
-    startObserving();
-})();

From ca958bdbfde75e1db8f1d7065aff3913a4d84985 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 20:16:18 +0200
Subject: [PATCH 12/55] Stop tracking .DS_Store files

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .DS_Store             | Bin 10244 -> 0 bytes
 .gitignore            |   1 +
 assets/.DS_Store      | Bin 8196 -> 0 bytes
 assets/dist/.DS_Store | Bin 6148 -> 0 bytes
 4 files changed, 1 insertion(+)
 delete mode 100644 .DS_Store
 delete mode 100644 assets/.DS_Store
 delete mode 100644 assets/dist/.DS_Store

diff --git a/.DS_Store b/.DS_Store
deleted file mode 100644
index 24c74b7ab70a600fa7ead2ab0f4eaadecaa1f514..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10244
zcmeHMU2GIp6uxKrH$#W^0!0e$goQ%*$pWQdTmH=UPbq%|wx!!rSY~$yIxss^c4l`A
zZDV8N3kb$1jsHApH1c3Ti7%R{h(2mH!5ANi8ubMeeNlPv+_|%4yM-4c351!=+;i_a
z_uM<@%y;(exl0Iv_N=y^kT4-c#G6qnV{?a#$=N;Q5`0cAQb2t|T;e42&PdX<lQU)q
zjKBkd2LcZS9tb=Tc;J5U0Oo9ViPfA2ZQy~x1Azx_dw_jEgz;uH>eES1y{`^zyb=Iu
zIkLSA`&b8fI$@tieLBghr;2Ox>H&OJ@JkHf>L?Gh=}4nKo#d3O6X5Cu{GGwCP{7+A
z^}^nC0#QzbHt;~;ftem)wR<H|iGv@#q<+7W95D^YZEXA&gtGFA$||u+tQHT&hV6XJ
zRo$%9u4WFhQLk;A$wFUE9x(KLg4T7|ma7_;p79h6O~)xi{f4F4`F1;NX^y8G;{s6<
zr39@X8*6TEjD(w-n<paSu}w|b-?*W9VnPz<H>}&TKXJlLTlN`l2KZkEWOj*JXG?9;
zoRpcwXJqrH8EZPZ4t`is7AqM0UBOssR<%4^>5mT#9+VSwZVs*L8F3BUat`Pj2Wf)V
zI%s`&%C`1qbSCdl*=9CvISD!^rJAX%sk(ZbX~vAxI`V3rRK_;Vy|!bpWd`D|KI$^r
z3{ia0u`_Omw^-c3_4zECb@cr@E^6fTPF&ilE3q7;i!}=tFI%~$sby=lt9$ppsaiT`
z?z}o#9z-`=u5r}RGktkObB701C#74OVIAww8IF-O^<GO&>vJF?NmI4;3l}{aQk1(*
zjc1d_$*kd?q79<x?Gaw0$U_=F({5X1yJ+;Xi0k0)%a<t1K_=<Q=-6t$!m8DZ-0Pt6
zRP`sWT_?-EClDXhVUK{S8#c;HpQ$EwlWG#*r*)I8^yj$$=}w=ytxi_rDLb7;6CIz|
z)~+ar*|xh>$L$%>EqtVF{@zcZY|t52GkQ-R@#%ASAlG}P$Y)Ajn&H}>5WTSntr%d-
zwP~7X!=n0ywMtCs6X{oCf>OiE85k4zT6t)Q4TV?J5M9l?4Ihv5j_2rxXd@p<nE4da
zL^{bXa)e~a7&%8?Bp1jf@)@~Gz9B!5U&&4K7XVa(1hb$T>R=Hpg9tnZEzk;^pdET(
zAMA%148brMa2y;Mh0`zw<M0fefoI_yoQD_SRd^lVfD7<8ya$)yGQ1BT!8P~-zJ#yg
z2K)#=!Ow6L{)T_xmQW!q5bA}6!crk3tP$1<EkdiXS=b`%5qgBUpbEzYTNvdA2!%L2
z#K(nJIEB5^aP!Xwg^PC%x6qT@yLaq-aKi0+4G*ySk1Pl;U%hT)>$bMrK;+0RfVDUT
zJls!<77zCxE=n*v#UoK(T!_-rknF>N(MLrVx3r4SUMepWF<@u~AFhyBi5M!hk`E)H
zwIT*56}+LmKD0r?5Ts>%7zwpVA_YF!EN_)C7-=~lDsohkDDeiNj!>6~0Y%0C3+dO%
z4e|^5o!mmC*T6iehZWF>_<kI=!yZI9!*?GXh6JdP1P#()!3dm0tdGM4JOz{RG@M1O
zpNHq*d3Xt4hF9P<coW`2yuSnQBHBNIEASzF0-wTF_}s_+_lWx6;Exg{?=E1NQ~0wK
z$+=j@GHvS^@)`OoNs^evCMj}a+6nlBok5Finw~+61VIK3GH8%N?`;O19&SMf#UGJD
z2ED^?#rr>l79qJLgH~bgG;i0TPI11eCPy)~W=NXki9s}Sj2EhfDJ=h%qmWgvYB93{
z89J7=_@{I+yNYDV2ri>?aj^(jdYG;<ZfuyH|99Q}|Nn={C4sGh2Oc^PKzV1ZvmMPY
z6!N7WU}x=NypQ0`E;etHQ%?mO?>HW*cN~ucb{xMFZ#LII=<xbcpEt>=r;c+xb)@_>
a|DOLDP;wIY-;djZ`ah`u5y=l={r@jL$-5{3

diff --git a/.gitignore b/.gitignore
index 6d42620..d7c8c38 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 .phpunit.result.cache
 mix.webpack.js
+.DS_Store
diff --git a/assets/.DS_Store b/assets/.DS_Store
deleted file mode 100644
index 1370b0d4a8146c31155967ebca97cbd9651bf194..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8196
zcmeHMTWl0n7(U;$(3#=V)7qA{6JSFllv1P=S>$5a-mvA8Vz;HGRM**^0VYgm>dx#g
zNQhPAgM!AW@eRDbVxo!02tgivz!x9PO2lYPeDK8=(ML`6pE<Kw3Otw)L&BV7&VSB-
z{{LLQ^Zj%7%reH%TQD{<*31}_=?NrXMA>ap&>lRuBq`EVlLYy*Y{{F++HRKWpWR{|
zD`Es<1Y!hY1Y!hY1nva{=*$k1e1~&iw8nXiK#ahBi9qmvNYE3=R3vAG3|}3Tg;xNQ
z!4)7(ROUf}WFnHONX`mLEtDW!NeWj)R}2Vu(kCLjR3vAG6z&Ys<pa^kh;AqdN2mT1
zp*cfJ$T*J?h!MCIfgpUUnZYdPF@Ns;Jv(Dtp5N7V6;f68f`v75jl4*HB7M{?rG4Em
zc)fc5P*59nT{~MT>)8XAS<3K+KG*Se%Q5qzgJqaxGBs{FhFj`&3y$H1zG=}QE3%T|
z%_mPLlU<#O?qu>*XX516ZYn>#DS7IYA~&{e*glduW=}ir%VG(LUIT2&yd|BUyB^ys
z_KEKiRgIPPd{<eIqAt=7j8CW;USFh156}3P>v#vuyhk#_Ydu=rP|kJs=gpvfJm=bl
zX~)a(x}0w33byW>J+_^;o-w@%-#qRIrAg1t`+cF|ghjrAF2i}jGe=Bvu!?3sxp@uq
zCJp7o#f{5XtzOr)dE3tZ!M*#-OP1DhwO(x)FIt|Jwau}TW%x%A>R!%t49ht(Nys_A
zb=WfV3csL?I{LI(=1t3*TUs@3zHz0Ki9*(Tx?uSyc$+Mj`O?}YD^_ailtEM4=Ndt0
z2LD7>!j`s`nsz8?>C2mx8<E4Bc1<1iXjNQ~3_I7W>gX}rS?(#qbz`@xjoEtEw7H>(
zagtk9ZM-O;<$EIK_8qD=k#nb~X(e7AIwN(eN7J4RM&7G?{_u?H(5$XR!w*o~q<2)$
zo5Lj{SEL;xZMb2i51a-J%Xh;@0%RX8<Y3TUk70z%Xl`1@wGnMp=HJM)H<nYhh|sj>
zg4c3eszYo~2x?oZOVkuPpjy~NbPx`*DQ2=6c7mN@XW2P+o_)$Lu`k)z>>B%?{lI=?
zKeJ!ib@nH!uoz2G3yv17MmyG`1DmiDDfD1BhVeK?kj4~r<Y2&r10O|{a2(I!C7i|?
zyn?szHr~Vg_yFf|5tr}<F5@ed@hz_6CtSzx_yd1Q3#A%Kmg=N>sX=O#+NHHpx3on{
ziK$DKV3`#4N-p(K=|=EVutXp4q?y|VOY5%32Jekvxwbe6kGlE?8X8x$wXg3^Zcp9d
zksw}$YjYVK()K2@hqMiMc^==&B9PSOmB^VNQDek+^SB(4me&aDgt|&5zVij5`k=Z-
zCZ_X+qT12gDN}55DXgj+S~n^bLA**-J6bm@GKZ)<qHa?tmUwl!Wm$96jz?9MGYWA<
zbky70FH<;h`M>k@BlbDF%&xF9@$?sB=x^+A$i&SiB#51Bh@0!M9!YG$R&2u#3}6=q
zF@!xB#Tdphfyt1khj9cJ^6)~oK8smAj~DPFUd3y89dF=GoW(i3gLfm=evAwAc(}X5
zKp}B)E)R?8ykoo05z<w7d$W05yGsaEiGG@c`~Se5zyIH*(c*4m1Y!j4MFddYpYHFa
znceAq8{D-M^gKmRkOI3|Aww6+!s|H6@H$TN#vg`MPLOHflZxc5kffpXzkdk$_s4F0
N{>SHk$ie$D`v+n48NUDk

diff --git a/assets/dist/.DS_Store b/assets/dist/.DS_Store
deleted file mode 100644
index ba3b77f6a8c3248a9cea646d67980a85d45fcca5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeH~Jr2S!425lAKw|00n1usyg9yP1xBvnsRH*}E&(V4QVW2Rh3O!5q7rU|AzM-i_
zM0bztR-_Y=CEO?*3nNqHGr7tAdcXANVd$-pHcMIw-pT0tYadAkr~nn90#twsOh<t{
z%9pF@JQAOT3Q&QGC}7`*0yoxV3;L%6!AAgafwCLcK1+bb3SdpPASy78Rxn!C#}KP~
zJ6LjGO}1dPi{|j5d1tjL2By(2T9ClBIvA(`6&NWnkG!+<{{a6s|BqUjQUNOPXA0<I
zf86izQhBz1yq?uhS+#Y8gT5W%?I!?<9mQ+78?F~yfHm2IsKEFm;4&~!fuAby1c*xz
AIsgCw


From 2d8f1e68931228fff58676aff912554e6c75c5a7 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 20:20:10 +0200
Subject: [PATCH 13/55] Add shared field includes for block definitions

A block may declare `include: path` (or a list of paths) to merge fields,
tabs, secondaryTabs, and config from external plain-YAML files. Included
definitions form the base; the block's own definitions override on collision.
Paths resolve via File::symbolizePath() ($/, ~/, #/). Lets shared sections,
tabs, and field groups be reused across blocks without copy-paste.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 README.md                | 66 ++++++++++++++++++++++++++++++++++++-
 classes/BlockManager.php | 70 +++++++++++++++++++++++++++++++++++++++-
 2 files changed, 134 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 436d518..a79f3f7 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ Provides a "block based" content management experience in Winter CMS
 
 >**NOTE:** This plugin is still in development and is likely to undergo changes. Do not use in production environments without using a version constraint in your composer.json file and carefully monitoring for breaking changes.
 
-> **Fork note:** This is a fork of [wintercms/wn-blocks-plugin](https://github.com/wintercms/wn-blocks-plugin) that adds **collapsible sections** and **tabs/secondaryTabs** support in block definitions. See [Collapsible Sections](#collapsible-sections) and [Tabs](#tabs) below.
+> **Fork note:** This is a fork of [wintercms/wn-blocks-plugin](https://github.com/wintercms/wn-blocks-plugin) that adds **collapsible sections**, **tabs/secondaryTabs** support, and **shared field includes** in block definitions. See [Collapsible Sections](#collapsible-sections), [Tabs](#tabs), and [Including shared field definitions](#including-shared-field-definitions) below.
 
 ## Installation
 
@@ -221,6 +221,70 @@ Fields declared under `tabs` / `secondaryTabs` are placed in the tabbed area of
 
 ---
 
+## Including shared field definitions
+
+To avoid repeating the same fields (or sections/tabs) across many blocks, a block can pull them in from one or more external YAML files via the top-level `include` key.
+
+```yaml
+name: Article
+description: An article block
+icon: icon-newspaper
+
+include: $/myauthor/myplugin/blocks/_seo.yaml
+
+fields:
+    title:
+        label: Title
+        type: text
+==
+<article>{{ title }}</article>
+```
+
+`_seo.yaml` is a plain YAML file (no `==` markup, no block metadata) containing any of `fields`, `tabs`, `secondaryTabs`, or `config`:
+
+```yaml
+# blocks/_seo.yaml
+tabs:
+    fields:
+        meta_title:
+            label: Meta title
+            type: text
+            tab: SEO
+        meta_description:
+            label: Meta description
+            type: textarea
+            tab: SEO
+```
+
+**Multiple includes** — pass a list; they are merged in order:
+
+```yaml
+include:
+    - $/myauthor/myplugin/blocks/_seo.yaml
+    - ~/app/blocks/_tracking.yaml
+```
+
+**Merge rules:**
+
+| | |
+|---|---|
+| Merged keys | `fields`, `tabs`, `secondaryTabs`, `config` |
+| Precedence | Included files form the base; the block's own definitions **override** on key collision |
+| Order | Multiple includes merge top-to-bottom (later files override earlier ones, the block still wins overall) |
+| Missing files | Silently skipped |
+
+**Path resolution** uses the standard Winter path symbols via `File::symbolizePath()`:
+
+| Symbol | Resolves to |
+|---|---|
+| `$/author/plugin/...` | `plugins/author/plugin/...` |
+| `~/...` | application root |
+| `#/...` | `storage/app/...` |
+
+This works for `collapsible` sections and tabs too — an included file can define a complete collapsible section (or a whole tab group) that every block reuses without copy-paste.
+
+---
+
 ## Using the `blocks` FormWidget
 
 In order to provide an interface for managing block-based content, this plugin provides the `blocks` FormWidget. This widget can be used in the backend as a form field to manage blocks.
diff --git a/classes/BlockManager.php b/classes/BlockManager.php
index e3d2f07..38807a9 100644
--- a/classes/BlockManager.php
+++ b/classes/BlockManager.php
@@ -7,6 +7,7 @@
 use Cms\Classes\Theme;
 use Event;
 use File;
+use Yaml;
 use System\Classes\PluginManager;
 use Winter\Storm\Support\Traits\Singleton;
 use Winter\Storm\Support\Str;
@@ -98,7 +99,7 @@ public function getConfigs(string|array|null $tags = null): array
                 }
             }
 
-            $configs[pathinfo($block['fileName'])['filename']] = array_except(
+            $config = array_except(
                 $block->getAttributes(),
                 [
                     'fileName',
@@ -108,11 +109,78 @@ public function getConfigs(string|array|null $tags = null): array
                     'code',
                 ]
             );
+
+            $config = $this->resolveIncludes($config);
+
+            $configs[pathinfo($block['fileName'])['filename']] = $config;
         }
 
         return $configs;
     }
 
+    /**
+     * Resolves an `include` directive in a block definition by merging field
+     * definitions from one or more external YAML files.
+     *
+     * A block may declare:
+     *
+     *     include: $/author/plugin/blocks/_shared.yaml
+     *     # or
+     *     include:
+     *         - $/author/plugin/blocks/_seo.yaml
+     *         - ~/app/blocks/_tracking.yaml
+     *
+     * Each included file is a plain YAML file that may contain any of the keys
+     * `fields`, `tabs`, `secondaryTabs` and `config`. Included definitions are
+     * merged in order and act as a base; the block's own definitions take
+     * precedence on key collisions.
+     *
+     * Paths are resolved with File::symbolizePath(), so the usual Winter symbols
+     * are supported ($ = plugins, ~ = app, # = app/storage/...).
+     */
+    protected function resolveIncludes(array $config): array
+    {
+        if (empty($config['include'])) {
+            unset($config['include']);
+            return $config;
+        }
+
+        $paths = (array) $config['include'];
+        unset($config['include']);
+
+        $mergeKeys = ['fields', 'tabs', 'secondaryTabs', 'config'];
+
+        foreach ($paths as $path) {
+            if (!is_string($path) || $path === '') {
+                continue;
+            }
+
+            $realPath = File::symbolizePath($path);
+            if (!$realPath || !File::exists($realPath)) {
+                continue;
+            }
+
+            $included = Yaml::parse(File::get($realPath));
+            if (!is_array($included)) {
+                continue;
+            }
+
+            foreach ($mergeKeys as $key) {
+                if (!isset($included[$key]) || !is_array($included[$key])) {
+                    continue;
+                }
+
+                // Included definitions form the base; the block's own win on collision.
+                $config[$key] = array_replace_recursive(
+                    $included[$key],
+                    (isset($config[$key]) && is_array($config[$key])) ? $config[$key] : []
+                );
+            }
+        }
+
+        return $config;
+    }
+
     /**
      * Get the configuration of the provided block type
      */

From 03871e7da516b139b122bf26feaa3c256d95ab3f Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 20:30:45 +0200
Subject: [PATCH 14/55] Add nested includes, schema guard, collapse
 persistence, recent blocks

- BlockManager: resolve nested includes recursively with a circular-reference
  guard; warn when an include redefines a field with a different type; log
  missing include files instead of skipping silently.
- Block widget partial: persist each collapsible section's open/closed state in
  localStorage; pin recently used blocks to the top of the add-block palette.
- winter.mix.js: document the two distinct blocks.js files (frontend Snowboard
  build vs backend FormWidget script) to prevent accidental merging.
- Add CHANGELOG.md summarising fork additions; update README.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                           | 42 +++++++++++
 README.md                              | 14 +++-
 classes/BlockManager.php               | 61 ++++++++++++++--
 formwidgets/blocks/partials/_block.php | 97 +++++++++++++++++++++++---
 winter.mix.js                          | 13 ++++
 5 files changed, 208 insertions(+), 19 deletions(-)
 create mode 100644 CHANGELOG.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..377b9e8
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,42 @@
+# Changelog
+
+This is a fork of [wintercms/wn-blocks-plugin](https://github.com/wintercms/wn-blocks-plugin).
+Entries below describe changes that diverge from upstream.
+
+## Fork additions
+
+### Collapsible sections
+- `.block` `type: section` fields support a `collapsible: true` shorthand, with
+  `collapsed: true|false` controlling the initial state.
+- Handled via the `data-block-collapsible` attribute and an inline bootstrap in
+  the block widget partial, independent of core's collapsible-section JS. This
+  fixes the core behaviour where adding an item to a repeater nested inside a
+  section re-collapsed it and double-bound its click handler (causing the
+  "Add item" stall).
+- **Open/closed state now persists** per section across page reloads
+  (`localStorage`, keyed by field name).
+
+### Tabs
+- `.block` definitions may declare top-level `tabs` and `secondaryTabs`, passed
+  through to the backend `Form` widget like a standard `fields.yaml`.
+
+### Shared field includes
+- `.block` definitions may declare a top-level `include:` (string or list) to
+  merge `fields`, `tabs`, `secondaryTabs`, and `config` from external plain-YAML
+  files.
+- Included definitions form the base; the block's own definitions override on
+  collision. Paths resolve via `File::symbolizePath()` (`$/`, `~/`, `#/`).
+- **Nested includes** are resolved recursively, guarded against circular
+  references.
+- A **schema guard** logs a warning when an include would redefine a field with
+  a different `type`.
+- Missing include files are skipped and logged as a warning.
+
+### Editor UX
+- **Recently used blocks** are pinned to the top of the "add block" palette
+  (tracked in `localStorage`, most-recent first).
+
+### Housekeeping
+- Documented the two distinct `blocks.js` files (frontend Snowboard build vs.
+  backend FormWidget script) in `winter.mix.js` to prevent accidental merging.
+- Stopped tracking `.DS_Store` files.
diff --git a/README.md b/README.md
index a79f3f7..f659d16 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ Provides a "block based" content management experience in Winter CMS
 
 >**NOTE:** This plugin is still in development and is likely to undergo changes. Do not use in production environments without using a version constraint in your composer.json file and carefully monitoring for breaking changes.
 
-> **Fork note:** This is a fork of [wintercms/wn-blocks-plugin](https://github.com/wintercms/wn-blocks-plugin) that adds **collapsible sections**, **tabs/secondaryTabs** support, and **shared field includes** in block definitions. See [Collapsible Sections](#collapsible-sections), [Tabs](#tabs), and [Including shared field definitions](#including-shared-field-definitions) below.
+> **Fork note:** This is a fork of [wintercms/wn-blocks-plugin](https://github.com/wintercms/wn-blocks-plugin) that adds **collapsible sections** (with persisted state), **tabs/secondaryTabs** support, **shared field includes** (with nested includes), and **recently used blocks** in the palette. See [Collapsible Sections](#collapsible-sections), [Tabs](#tabs), [Including shared field definitions](#including-shared-field-definitions), and [Recently used blocks](#recently-used-blocks) below. Full list in [CHANGELOG.md](CHANGELOG.md).
 
 ## Installation
 
@@ -169,7 +169,7 @@ fields:
 | `collapsible` | bool | — | Set to `true` to enable the collapse toggle |
 | `collapsed` | bool | `true` | Initial state. `false` = section starts open |
 
-When `collapsible: true` is set, the section header becomes a click target. Sections start collapsed by default; set `collapsed: false` to have the section open on first load.
+When `collapsible: true` is set, the section header becomes a click target. Sections start collapsed by default; set `collapsed: false` to have the section open on first load. Each section's open/closed state is **remembered across page reloads** (stored in `localStorage`, keyed by field name), so the editor returns to the state you left it in.
 
 > **Note:** Collapsible behaviour is handled by this fork via the `data-block-collapsible` attribute, bootstrapped inline in the block widget partial (`formwidgets/blocks/partials/_block.php`), independent of WinterCMS's core collapsible-section JS. This is deliberate: core re-collapses and re-binds every section on each form-widget init — including when a nested repeater adds an item — which broke manually-opened sections and stalled repeater "Add item" clicks. Owning the behaviour avoids that entirely, so collapsible sections work correctly even with repeater fields nested inside them.
 
@@ -271,7 +271,9 @@ include:
 | Merged keys | `fields`, `tabs`, `secondaryTabs`, `config` |
 | Precedence | Included files form the base; the block's own definitions **override** on key collision |
 | Order | Multiple includes merge top-to-bottom (later files override earlier ones, the block still wins overall) |
-| Missing files | Silently skipped |
+| Nested includes | An included file may itself declare `include:` — resolved recursively, with a circular-reference guard |
+| Type guard | Redefining a field with a different `type` than the include logs a warning |
+| Missing files | Skipped, and logged as a warning |
 
 **Path resolution** uses the standard Winter path symbols via `File::symbolizePath()`:
 
@@ -285,6 +287,12 @@ This works for `collapsible` sections and tabs too — an included file can defi
 
 ---
 
+## Recently used blocks
+
+When adding a block from the palette, the blocks you use most recently are pinned to the top of the list (tracked per browser in `localStorage`, most-recent first). This speeds up repetitive content building where the same few block types are added over and over. No configuration is required.
+
+---
+
 ## Using the `blocks` FormWidget
 
 In order to provide an interface for managing block-based content, this plugin provides the `blocks` FormWidget. This widget can be used in the backend as a form field to manage blocks.
diff --git a/classes/BlockManager.php b/classes/BlockManager.php
index 38807a9..3b986d1 100644
--- a/classes/BlockManager.php
+++ b/classes/BlockManager.php
@@ -7,6 +7,7 @@
 use Cms\Classes\Theme;
 use Event;
 use File;
+use Log;
 use Yaml;
 use System\Classes\PluginManager;
 use Winter\Storm\Support\Traits\Singleton;
@@ -135,10 +136,15 @@ public function getConfigs(string|array|null $tags = null): array
      * merged in order and act as a base; the block's own definitions take
      * precedence on key collisions.
      *
+     * Included files may themselves declare an `include` key — nested includes
+     * are resolved recursively, guarded against circular references.
+     *
      * Paths are resolved with File::symbolizePath(), so the usual Winter symbols
      * are supported ($ = plugins, ~ = app, # = app/storage/...).
+     *
+     * @param string[] $visited Canonical paths already being resolved (cycle guard).
      */
-    protected function resolveIncludes(array $config): array
+    protected function resolveIncludes(array $config, array $visited = []): array
     {
         if (empty($config['include'])) {
             unset($config['include']);
@@ -157,6 +163,13 @@ protected function resolveIncludes(array $config): array
 
             $realPath = File::symbolizePath($path);
             if (!$realPath || !File::exists($realPath)) {
+                Log::warning("Winter.Blocks: included file not found: {$path}");
+                continue;
+            }
+
+            $canonical = PathResolver::standardize($realPath);
+            if (in_array($canonical, $visited, true)) {
+                Log::warning("Winter.Blocks: circular include detected, skipping: {$path}");
                 continue;
             }
 
@@ -165,22 +178,60 @@ protected function resolveIncludes(array $config): array
                 continue;
             }
 
+            // Resolve nested includes first so they form the deepest base layer.
+            $included = $this->resolveIncludes($included, array_merge($visited, [$canonical]));
+
             foreach ($mergeKeys as $key) {
                 if (!isset($included[$key]) || !is_array($included[$key])) {
                     continue;
                 }
 
+                $own = (isset($config[$key]) && is_array($config[$key])) ? $config[$key] : [];
+
+                // Warn when a field is redefined with a different type.
+                $this->warnOnTypeCollisions($key, $included[$key], $own);
+
                 // Included definitions form the base; the block's own win on collision.
-                $config[$key] = array_replace_recursive(
-                    $included[$key],
-                    (isset($config[$key]) && is_array($config[$key])) ? $config[$key] : []
-                );
+                $config[$key] = array_replace_recursive($included[$key], $own);
             }
         }
 
         return $config;
     }
 
+    /**
+     * Logs a warning when merging an include would redefine a field with a
+     * different `type`, which is almost always a mistake. Field definitions live
+     * directly under `fields`/`config`, and under a `fields` sub-key for
+     * `tabs`/`secondaryTabs`.
+     */
+    protected function warnOnTypeCollisions(string $key, array $included, array $own): void
+    {
+        $nested = in_array($key, ['tabs', 'secondaryTabs'], true);
+        $includedFields = $nested ? ($included['fields'] ?? []) : $included;
+        $ownFields = $nested ? ($own['fields'] ?? []) : $own;
+
+        if (!is_array($includedFields) || !is_array($ownFields)) {
+            return;
+        }
+
+        foreach ($includedFields as $name => $def) {
+            if (!isset($ownFields[$name]) || !is_array($def) || !is_array($ownFields[$name])) {
+                continue;
+            }
+
+            $includedType = $def['type'] ?? null;
+            $ownType = $ownFields[$name]['type'] ?? null;
+
+            if ($includedType && $ownType && $includedType !== $ownType) {
+                Log::warning(
+                    "Winter.Blocks: field '{$name}' redefined with a different type " .
+                    "('{$ownType}' overrides included '{$includedType}') in '{$key}'."
+                );
+            }
+        }
+    }
+
     /**
      * Get the configuration of the provided block type
      */
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 4a14502..00ac933 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -69,6 +69,7 @@ class="form-control blocks-group-search"
                                 <a
                                     href="javascript:;"
                                     data-repeater-add
+                                    data-block-code="<?= $item['code'] ?>"
                                     data-request="<?= $this->getEventHandler('onAddItem') ?>"
                                     data-request-data="_repeater_group: '<?= $item['code'] ?>'">
                                     <i class="<?= $item['icon'] ?>"></i>
@@ -88,25 +89,39 @@ class="form-control blocks-group-search"
 
     <?php
     /*
-     * Inline bootstrap for collapsible block sections.
+     * Inline bootstrap for block widget enhancements:
+     *   - Collapsible sections (persisting open/closed state per section)
+     *   - Recently used blocks pinned to the top of the "add block" palette
      *
      * Loaded inline (rather than only via addJs) so it is guaranteed to reach the
      * page regardless of widget asset-path resolution or the asset combiner. A
      * global guard ensures the handlers are registered only once even when several
      * block widgets render on the same page.
      *
-     * Behaviour lives on the data-block-collapsible attribute, which the core form
-     * widget's bindCollapsibleSections() never selects — so core cannot re-collapse
-     * or double-bind these sections when a nested repeater adds an item.
+     * Collapse behaviour lives on the data-block-collapsible attribute, which the
+     * core form widget's bindCollapsibleSections() never selects — so core cannot
+     * re-collapse or double-bind these sections when a nested repeater adds an item.
      */
     ?>
     <script>
     (function () {
-        if (window.__blockCollapsibleInit) { return; }
-        window.__blockCollapsibleInit = true;
+        if (window.__blockEnhancementsInit) { return; }
+        window.__blockEnhancementsInit = true;
 
         var READY = 'block-collapsible-ready';
+        var COLLAPSE_PREFIX = 'wnBlocksCollapse:';
+        var RECENT_KEY = 'wnBlocksRecent';
+        var RECENT_MAX = 6;
 
+        // --- safe localStorage helpers -------------------------------------
+        function lsGet(key) {
+            try { return window.localStorage.getItem(key); } catch (e) { return null; }
+        }
+        function lsSet(key, val) {
+            try { window.localStorage.setItem(key, val); } catch (e) {}
+        }
+
+        // --- collapsible sections ------------------------------------------
         function followingFields(section) {
             var els = [], el = section.nextElementSibling;
             while (el && !el.classList.contains('section-field')) {
@@ -123,6 +138,11 @@ function setCollapsed(section, collapsed) {
             });
         }
 
+        function storageKey(section) {
+            var name = section.getAttribute('data-field-name') || '';
+            return name ? (COLLAPSE_PREFIX + name) : null;
+        }
+
         function initSections() {
             document.querySelectorAll(
                 '.section-field[data-block-collapsible]:not(.' + READY + ')'
@@ -130,24 +150,79 @@ function initSections() {
                 section.classList.add(READY);
                 var header = section.querySelector('.field-section');
                 if (header) { header.classList.add('is-collapsible'); }
-                var startOpen = section.hasAttribute('data-block-collapsible-open');
-                setCollapsed(section, !startOpen);
+
+                // Restore persisted state if present, else fall back to config default.
+                var key = storageKey(section);
+                var stored = key ? lsGet(key) : null;
+                var collapsed = stored !== null
+                    ? stored === '1'
+                    : !section.hasAttribute('data-block-collapsible-open');
+                setCollapsed(section, collapsed);
             });
         }
 
         document.addEventListener('click', function (e) {
             var section = e.target.closest('.section-field[data-block-collapsible]');
             if (!section) { return; }
-            setCollapsed(section, !section.classList.contains('collapsed'));
+            var collapsed = !section.classList.contains('collapsed');
+            setCollapsed(section, collapsed);
+            var key = storageKey(section);
+            if (key) { lsSet(key, collapsed ? '1' : '0'); }
+        });
+
+        // --- recently used blocks ------------------------------------------
+        function getRecent() {
+            try {
+                var raw = lsGet(RECENT_KEY);
+                var arr = raw ? JSON.parse(raw) : [];
+                return Array.isArray(arr) ? arr : [];
+            } catch (e) { return []; }
+        }
+
+        function pushRecent(code) {
+            if (!code) { return; }
+            var arr = getRecent().filter(function (c) { return c !== code; });
+            arr.unshift(code);
+            arr = arr.slice(0, RECENT_MAX);
+            lsSet(RECENT_KEY, JSON.stringify(arr));
+        }
+
+        // Record a block as recently used whenever one is added from the palette.
+        document.addEventListener('click', function (e) {
+            var a = e.target.closest('[data-block-code]');
+            if (!a) { return; }
+            pushRecent(a.getAttribute('data-block-code'));
         });
 
-        initSections();
+        // When a palette grid appears, move recently used blocks to the front.
+        // Reordering (rather than cloning) avoids duplicates and styling issues
+        // and degrades gracefully if the markup differs.
+        function applyRecent() {
+            document.querySelectorAll('.blocks-group-grid:not([data-recent-processed])')
+                .forEach(function (grid) {
+                    grid.setAttribute('data-recent-processed', '1');
+                    var recent = getRecent();
+                    // Reverse so the most recent ends up first after successive prepends.
+                    recent.slice().reverse().forEach(function (code) {
+                        var link = grid.querySelector('a[data-block-code="' + code + '"]');
+                        var item = link && link.closest('.blocks-group-item');
+                        if (item && item.parentNode === grid) {
+                            grid.insertBefore(item, grid.firstChild);
+                        }
+                    });
+                });
+        }
+
+        // --- shared init + observer ----------------------------------------
+        function runAll() { initSections(); applyRecent(); }
+
+        runAll();
 
         var scheduled = false;
         var observer = new MutationObserver(function () {
             if (scheduled) { return; }
             scheduled = true;
-            setTimeout(function () { scheduled = false; initSections(); }, 0);
+            setTimeout(function () { scheduled = false; runAll(); }, 0);
         });
         function startObserving() {
             if (document.body) {
diff --git a/winter.mix.js b/winter.mix.js
index 082f4b8..3034a9a 100644
--- a/winter.mix.js
+++ b/winter.mix.js
@@ -1,5 +1,18 @@
 const mix = require('laravel-mix');
 
+/*
+ * NOTE: there are two distinct blocks.js files — do not confuse or merge them:
+ *
+ *   assets/dist/js/blocks.js            (built here from assets/src/js/blocks.js)
+ *     The FRONTEND Snowboard "actions" build. Loaded manually in the theme after
+ *     Snowboard (see README "Actions").
+ *
+ *   formwidgets/blocks/assets/js/blocks.js  (hand-maintained, not built here)
+ *     The BACKEND FormWidget behaviour (jQuery "fieldBlocks" plugin), served via
+ *     addJs() in formwidgets/Blocks.php. This is the one the editor UI uses.
+ *
+ * They share a filename but target different runtimes.
+ */
 mix
     .setPublicPath(__dirname)
     .js('assets/src/js/blocks.js', 'assets/dist/js/blocks.js')

From 60443ed34498ce091758961ef3feca5122f82c60 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 22:17:49 +0200
Subject: [PATCH 15/55] Add tests for includes and collapsible shorthand

BlockManagerTest covers resolveIncludes: field/tab/config merging,
block-overrides-include precedence, nested includes, circular-include guard,
missing-file skip, multiple includes, and no-include no-op.

BlocksTest covers normalizeBlockFields: collapsible/collapsed shorthand
translation to data-block-collapsible[-open] and that non-collapsible fields
are untouched.

Adds YAML fixtures under tests/fixtures/blocks/includes/. Merge behaviour
verified end-to-end against the real resolveIncludes() code path.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   9 ++
 tests/classes/BlockManagerTest.php            | 143 ++++++++++++++++++
 tests/fixtures/blocks/includes/_base.yaml     |   4 +
 tests/fixtures/blocks/includes/_cycle_a.yaml  |   5 +
 tests/fixtures/blocks/includes/_cycle_b.yaml  |   5 +
 tests/fixtures/blocks/includes/_shared.yaml   |  17 +++
 .../blocks/includes/_with_nested.yaml         |   5 +
 tests/formwidgets/BlocksTest.php              | 102 +++++++++++++
 8 files changed, 290 insertions(+)
 create mode 100644 tests/fixtures/blocks/includes/_base.yaml
 create mode 100644 tests/fixtures/blocks/includes/_cycle_a.yaml
 create mode 100644 tests/fixtures/blocks/includes/_cycle_b.yaml
 create mode 100644 tests/fixtures/blocks/includes/_shared.yaml
 create mode 100644 tests/fixtures/blocks/includes/_with_nested.yaml

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 377b9e8..912da48 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -36,6 +36,15 @@ Entries below describe changes that diverge from upstream.
 - **Recently used blocks** are pinned to the top of the "add block" palette
   (tracked in `localStorage`, most-recent first).
 
+### Tests
+- `BlockManagerTest`: include merging, block-overrides-include precedence,
+  nested includes, circular-include guard, missing-file skip, multiple includes,
+  and the no-include no-op.
+- `BlocksTest`: `collapsible`/`collapsed` shorthand translation to
+  `data-block-collapsible` / `data-block-collapsible-open`, and that non-section
+  / plain-section fields are left untouched.
+- Fixtures under `tests/fixtures/blocks/includes/`.
+
 ### Housekeeping
 - Documented the two distinct `blocks.js` files (frontend Snowboard build vs.
   backend FormWidget script) in `winter.mix.js` to prevent accidental merging.
diff --git a/tests/classes/BlockManagerTest.php b/tests/classes/BlockManagerTest.php
index 7851af0..80da180 100644
--- a/tests/classes/BlockManagerTest.php
+++ b/tests/classes/BlockManagerTest.php
@@ -35,6 +35,149 @@ public function setUp(): void
         $this->pluginPath = dirname(dirname(__DIR__)) . '/blocks/';
     }
 
+    /**
+     * Invokes the protected resolveIncludes() with the given block config.
+     */
+    protected function resolveIncludes(array $config): array
+    {
+        $method = new \ReflectionMethod(BlockManager::class, 'resolveIncludes');
+        $method->setAccessible(true);
+
+        return $method->invoke($this->manager, $config);
+    }
+
+    protected function includePath(string $file): string
+    {
+        return '$/winter/blocks/tests/fixtures/blocks/includes/' . $file;
+    }
+
+    /**
+     * @testdox merges fields, tabs and config from an included file
+     */
+    public function testIncludeMergesDefinitions()
+    {
+        $result = $this->resolveIncludes([
+            'include' => $this->includePath('_shared.yaml'),
+            'fields' => [
+                'title' => ['label' => 'Title', 'type' => 'text'],
+            ],
+        ]);
+
+        // The include key itself is stripped.
+        $this->assertArrayNotHasKey('include', $result);
+
+        // Fields from both the include and the block are present.
+        $this->assertArrayHasKey('shared_field', $result['fields']);
+        $this->assertArrayHasKey('title', $result['fields']);
+
+        // tabs and config from the include are merged in too.
+        $this->assertArrayHasKey('meta_title', $result['tabs']['fields']);
+        $this->assertArrayHasKey('shared_config', $result['config']);
+    }
+
+    /**
+     * @testdox lets the block's own definitions override the include on collision
+     */
+    public function testBlockOverridesInclude()
+    {
+        $result = $this->resolveIncludes([
+            'include' => $this->includePath('_shared.yaml'),
+            'fields' => [
+                'overridden' => ['label' => 'From block', 'type' => 'textarea'],
+            ],
+        ]);
+
+        $this->assertEquals('From block', $result['fields']['overridden']['label']);
+        $this->assertEquals('textarea', $result['fields']['overridden']['type']);
+    }
+
+    /**
+     * @testdox resolves nested includes recursively
+     */
+    public function testNestedIncludesAreResolved()
+    {
+        $result = $this->resolveIncludes([
+            'include' => $this->includePath('_with_nested.yaml'),
+            'fields' => [
+                'own_field' => ['label' => 'Own', 'type' => 'text'],
+            ],
+        ]);
+
+        // base_field (deepest), mid_field (middle), own_field (block) all present.
+        $this->assertArrayHasKey('base_field', $result['fields']);
+        $this->assertArrayHasKey('mid_field', $result['fields']);
+        $this->assertArrayHasKey('own_field', $result['fields']);
+    }
+
+    /**
+     * @testdox does not loop on circular includes and still merges what it can
+     */
+    public function testCircularIncludeIsGuarded()
+    {
+        $result = $this->resolveIncludes([
+            'include' => $this->includePath('_cycle_a.yaml'),
+            'fields' => [
+                'own_field' => ['label' => 'Own', 'type' => 'text'],
+            ],
+        ]);
+
+        // Both ends of the cycle contribute their fields; no infinite recursion.
+        $this->assertArrayHasKey('field_a', $result['fields']);
+        $this->assertArrayHasKey('field_b', $result['fields']);
+        $this->assertArrayHasKey('own_field', $result['fields']);
+    }
+
+    /**
+     * @testdox skips a missing include file without error
+     */
+    public function testMissingIncludeIsSkipped()
+    {
+        $result = $this->resolveIncludes([
+            'include' => $this->includePath('_does_not_exist.yaml'),
+            'fields' => [
+                'title' => ['label' => 'Title', 'type' => 'text'],
+            ],
+        ]);
+
+        $this->assertArrayNotHasKey('include', $result);
+        $this->assertArrayHasKey('title', $result['fields']);
+        $this->assertCount(1, $result['fields']);
+    }
+
+    /**
+     * @testdox accepts a list of includes merged in order
+     */
+    public function testMultipleIncludes()
+    {
+        $result = $this->resolveIncludes([
+            'include' => [
+                $this->includePath('_base.yaml'),
+                $this->includePath('_shared.yaml'),
+            ],
+            'fields' => [
+                'title' => ['label' => 'Title', 'type' => 'text'],
+            ],
+        ]);
+
+        $this->assertArrayHasKey('base_field', $result['fields']);
+        $this->assertArrayHasKey('shared_field', $result['fields']);
+        $this->assertArrayHasKey('title', $result['fields']);
+    }
+
+    /**
+     * @testdox leaves a block without an include untouched
+     */
+    public function testNoIncludeIsNoop()
+    {
+        $config = [
+            'fields' => [
+                'title' => ['label' => 'Title', 'type' => 'text'],
+            ],
+        ];
+
+        $this->assertEquals($config, $this->resolveIncludes($config));
+    }
+
     public function testCanRegisterBlocksDirectly()
     {
         $this->manager->registerBlock('container', $this->fixturePath . 'container.block');
diff --git a/tests/fixtures/blocks/includes/_base.yaml b/tests/fixtures/blocks/includes/_base.yaml
new file mode 100644
index 0000000..518845f
--- /dev/null
+++ b/tests/fixtures/blocks/includes/_base.yaml
@@ -0,0 +1,4 @@
+fields:
+    base_field:
+        label: Base
+        type: textarea
diff --git a/tests/fixtures/blocks/includes/_cycle_a.yaml b/tests/fixtures/blocks/includes/_cycle_a.yaml
new file mode 100644
index 0000000..95c00fc
--- /dev/null
+++ b/tests/fixtures/blocks/includes/_cycle_a.yaml
@@ -0,0 +1,5 @@
+include: $/winter/blocks/tests/fixtures/blocks/includes/_cycle_b.yaml
+fields:
+    field_a:
+        label: A
+        type: text
diff --git a/tests/fixtures/blocks/includes/_cycle_b.yaml b/tests/fixtures/blocks/includes/_cycle_b.yaml
new file mode 100644
index 0000000..24a203f
--- /dev/null
+++ b/tests/fixtures/blocks/includes/_cycle_b.yaml
@@ -0,0 +1,5 @@
+include: $/winter/blocks/tests/fixtures/blocks/includes/_cycle_a.yaml
+fields:
+    field_b:
+        label: B
+        type: text
diff --git a/tests/fixtures/blocks/includes/_shared.yaml b/tests/fixtures/blocks/includes/_shared.yaml
new file mode 100644
index 0000000..28e70e7
--- /dev/null
+++ b/tests/fixtures/blocks/includes/_shared.yaml
@@ -0,0 +1,17 @@
+fields:
+    shared_field:
+        label: Shared
+        type: text
+    overridden:
+        label: From include
+        type: text
+tabs:
+    fields:
+        meta_title:
+            label: Meta title
+            type: text
+            tab: SEO
+config:
+    shared_config:
+        label: Shared config
+        type: checkbox
diff --git a/tests/fixtures/blocks/includes/_with_nested.yaml b/tests/fixtures/blocks/includes/_with_nested.yaml
new file mode 100644
index 0000000..4227a29
--- /dev/null
+++ b/tests/fixtures/blocks/includes/_with_nested.yaml
@@ -0,0 +1,5 @@
+include: $/winter/blocks/tests/fixtures/blocks/includes/_base.yaml
+fields:
+    mid_field:
+        label: Mid
+        type: text
diff --git a/tests/formwidgets/BlocksTest.php b/tests/formwidgets/BlocksTest.php
index e906284..1b22d29 100644
--- a/tests/formwidgets/BlocksTest.php
+++ b/tests/formwidgets/BlocksTest.php
@@ -63,6 +63,108 @@ public function testCanCreateFormWidget()
         $this->assertInstanceOf(Blocks::class, $this->createTestFormWidget());
     }
 
+    /**
+     * Invokes the protected normalizeBlockFields() on a widget instance.
+     */
+    protected function normalizeBlockFields(Blocks $widget, array $fields): array
+    {
+        $method = new \ReflectionMethod(Blocks::class, 'normalizeBlockFields');
+        $method->setAccessible(true);
+
+        return $method->invoke($widget, $fields);
+    }
+
+    /**
+     * @testdox translates collapsible: true into the data-block-collapsible attribute
+     */
+    public function testCollapsibleShorthandAddsAttribute()
+    {
+        $widget = $this->createTestFormWidget();
+
+        $result = $this->normalizeBlockFields($widget, [
+            'section_advanced' => [
+                'type' => 'section',
+                'label' => 'Advanced',
+                'collapsible' => true,
+            ],
+        ]);
+
+        $field = $result['section_advanced'];
+
+        $this->assertArrayHasKey('data-block-collapsible', $field['containerAttributes']);
+        // Defaults to collapsed: no "open" marker.
+        $this->assertArrayNotHasKey('data-block-collapsible-open', $field['containerAttributes']);
+        // Shorthand keys are removed once translated.
+        $this->assertArrayNotHasKey('collapsible', $field);
+        $this->assertArrayNotHasKey('collapsed', $field);
+    }
+
+    /**
+     * @testdox marks a section as initially open when collapsed: false
+     */
+    public function testCollapsedFalseAddsOpenAttribute()
+    {
+        $widget = $this->createTestFormWidget();
+
+        $result = $this->normalizeBlockFields($widget, [
+            'section_open' => [
+                'type' => 'section',
+                'label' => 'Open',
+                'collapsible' => true,
+                'collapsed' => false,
+            ],
+        ]);
+
+        $attrs = $result['section_open']['containerAttributes'];
+
+        $this->assertArrayHasKey('data-block-collapsible', $attrs);
+        $this->assertArrayHasKey('data-block-collapsible-open', $attrs);
+    }
+
+    /**
+     * @testdox does not add the open marker when collapsed: true
+     */
+    public function testCollapsedTrueOmitsOpenAttribute()
+    {
+        $widget = $this->createTestFormWidget();
+
+        $result = $this->normalizeBlockFields($widget, [
+            'section_closed' => [
+                'type' => 'section',
+                'label' => 'Closed',
+                'collapsible' => true,
+                'collapsed' => true,
+            ],
+        ]);
+
+        $attrs = $result['section_closed']['containerAttributes'];
+
+        $this->assertArrayHasKey('data-block-collapsible', $attrs);
+        $this->assertArrayNotHasKey('data-block-collapsible-open', $attrs);
+    }
+
+    /**
+     * @testdox leaves non-section fields and sections without the shorthand untouched
+     */
+    public function testNonCollapsibleFieldsUntouched()
+    {
+        $widget = $this->createTestFormWidget();
+
+        $result = $this->normalizeBlockFields($widget, [
+            'title' => [
+                'type' => 'text',
+                'label' => 'Title',
+            ],
+            'plain_section' => [
+                'type' => 'section',
+                'label' => 'Plain',
+            ],
+        ]);
+
+        $this->assertArrayNotHasKey('containerAttributes', $result['title']);
+        $this->assertArrayNotHasKey('containerAttributes', $result['plain_section']);
+    }
+
     public function testCanLimitAvailableBlocksByTag()
     {
         BlockManager::instance()->registerBlock('container', $this->fixturePath . 'container.block');

From c1b394b14185b42546a2a269660aec20acff818d Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 22:19:00 +0200
Subject: [PATCH 16/55] Remove fork references from README and CHANGELOG

These features are intended to be proposed upstream, so the docs describe them
as plugin features rather than fork-specific additions.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md | 5 +----
 README.md    | 4 ++--
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 912da48..70c2af0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,9 +1,6 @@
 # Changelog
 
-This is a fork of [wintercms/wn-blocks-plugin](https://github.com/wintercms/wn-blocks-plugin).
-Entries below describe changes that diverge from upstream.
-
-## Fork additions
+## Unreleased
 
 ### Collapsible sections
 - `.block` `type: section` fields support a `collapsible: true` shorthand, with
diff --git a/README.md b/README.md
index f659d16..17e2960 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ Provides a "block based" content management experience in Winter CMS
 
 >**NOTE:** This plugin is still in development and is likely to undergo changes. Do not use in production environments without using a version constraint in your composer.json file and carefully monitoring for breaking changes.
 
-> **Fork note:** This is a fork of [wintercms/wn-blocks-plugin](https://github.com/wintercms/wn-blocks-plugin) that adds **collapsible sections** (with persisted state), **tabs/secondaryTabs** support, **shared field includes** (with nested includes), and **recently used blocks** in the palette. See [Collapsible Sections](#collapsible-sections), [Tabs](#tabs), [Including shared field definitions](#including-shared-field-definitions), and [Recently used blocks](#recently-used-blocks) below. Full list in [CHANGELOG.md](CHANGELOG.md).
+> **Block definition features:** **collapsible sections** (with persisted state), **tabs/secondaryTabs** support, **shared field includes** (with nested includes), and **recently used blocks** in the palette. See [Collapsible Sections](#collapsible-sections), [Tabs](#tabs), [Including shared field definitions](#including-shared-field-definitions), and [Recently used blocks](#recently-used-blocks) below. Full list in [CHANGELOG.md](CHANGELOG.md).
 
 ## Installation
 
@@ -171,7 +171,7 @@ fields:
 
 When `collapsible: true` is set, the section header becomes a click target. Sections start collapsed by default; set `collapsed: false` to have the section open on first load. Each section's open/closed state is **remembered across page reloads** (stored in `localStorage`, keyed by field name), so the editor returns to the state you left it in.
 
-> **Note:** Collapsible behaviour is handled by this fork via the `data-block-collapsible` attribute, bootstrapped inline in the block widget partial (`formwidgets/blocks/partials/_block.php`), independent of WinterCMS's core collapsible-section JS. This is deliberate: core re-collapses and re-binds every section on each form-widget init — including when a nested repeater adds an item — which broke manually-opened sections and stalled repeater "Add item" clicks. Owning the behaviour avoids that entirely, so collapsible sections work correctly even with repeater fields nested inside them.
+> **Note:** Collapsible behaviour is handled via the `data-block-collapsible` attribute, bootstrapped inline in the block widget partial (`formwidgets/blocks/partials/_block.php`), independent of WinterCMS's core collapsible-section JS. This is deliberate: core re-collapses and re-binds every section on each form-widget init — including when a nested repeater adds an item — which broke manually-opened sections and stalled repeater "Add item" clicks. Owning the behaviour avoids that entirely, so collapsible sections work correctly even with repeater fields nested inside them.
 
 ---
 

From 4830cc07442cb5bb8f75ed1058d7934927d916fb Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 22:28:57 +0200
Subject: [PATCH 17/55] Tidy winter.mix.js comment about the two blocks.js
 files

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 winter.mix.js | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/winter.mix.js b/winter.mix.js
index 3034a9a..73e437c 100644
--- a/winter.mix.js
+++ b/winter.mix.js
@@ -1,17 +1,11 @@
 const mix = require('laravel-mix');
 
 /*
- * NOTE: there are two distinct blocks.js files — do not confuse or merge them:
- *
- *   assets/dist/js/blocks.js            (built here from assets/src/js/blocks.js)
- *     The FRONTEND Snowboard "actions" build. Loaded manually in the theme after
- *     Snowboard (see README "Actions").
- *
- *   formwidgets/blocks/assets/js/blocks.js  (hand-maintained, not built here)
- *     The BACKEND FormWidget behaviour (jQuery "fieldBlocks" plugin), served via
- *     addJs() in formwidgets/Blocks.php. This is the one the editor UI uses.
- *
- * They share a filename but target different runtimes.
+ * Two separate blocks.js files exist for different runtimes:
+ *   - assets/dist/js/blocks.js: frontend Snowboard "actions" build, compiled
+ *     here from assets/src/js/blocks.js.
+ *   - formwidgets/blocks/assets/js/blocks.js: backend FormWidget script (jQuery
+ *     "fieldBlocks"), maintained by hand and served via addJs() in Blocks.php.
  */
 mix
     .setPublicPath(__dirname)

From 742dacc36c650cf8c03a69a5f5bbc78875b366c9 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 23:10:57 +0200
Subject: [PATCH 18/55] Add copy/cut/paste for blocks

Copy and Cut buttons on each block item serialize field values to
sessionStorage. A Paste entry appears at the top of the add-block palette
when clipboard data is present and the block type is allowed in the target
widget. Paste works across pages within the same browser session.

The MutationObserver that already watches for new block items now fills
clipboard values into a newly added item immediately after onAddItem's AJAX
response is injected, before any debounced re-init runs.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                                |   5 +
 README.md                                   |  14 ++
 formwidgets/blocks/partials/_block.php      | 136 +++++++++++++++++++-
 formwidgets/blocks/partials/_block_item.php |   6 +
 4 files changed, 159 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 70c2af0..a1dcb55 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -32,6 +32,11 @@
 ### Editor UX
 - **Recently used blocks** are pinned to the top of the "add block" palette
   (tracked in `localStorage`, most-recent first).
+- **Copy / Cut / Paste blocks** — Copy and Cut icon buttons on each block
+  serialize its field values to `sessionStorage`. A Paste entry appears at the
+  top of the "add block" palette when the clipboard holds a block whose type is
+  available in the current widget (respects `allow`/`ignore`/`tags`). Paste
+  survives navigation within the same browser tab.
 
 ### Tests
 - `BlockManagerTest`: include merging, block-overrides-include precedence,
diff --git a/README.md b/README.md
index 17e2960..ffb96be 100644
--- a/README.md
+++ b/README.md
@@ -293,6 +293,20 @@ When adding a block from the palette, the blocks you use most recently are pinne
 
 ---
 
+## Copy, cut and paste blocks
+
+Each block has **Copy** and **Cut** icon buttons next to the remove (×) button.
+
+- **Copy** — serializes the block's current field values to `sessionStorage`.
+- **Cut** — copies then immediately triggers the remove button (with the usual confirmation prompt).
+- **Paste** — when the clipboard holds a block, a **Paste block** entry appears at the top of the "add block" palette. Clicking it adds a fresh block of that type and fills all its fields with the copied values.
+
+Paste respects the widget's `allow` / `ignore` / `tags` constraints: if the copied block type is not available in the target widget's palette, the Paste entry is not shown. The clipboard persists for the duration of the browser session (`sessionStorage`), so you can paste across different pages in the same tab.
+
+> **Note on nested blocks:** Field values — including nested `blocks` fields, which store their content as JSON — are captured and restored correctly. Complex editor widgets (e.g. rich-text, code editors) may require an extra click to refresh their UI after paste, as those widgets listen for native `change` events.
+
+---
+
 ## Using the `blocks` FormWidget
 
 In order to provide an interface for managing block-based content, this plugin provides the `blocks` FormWidget. This widget can be used in the backend as a form field to manage blocks.
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 00ac933..37794ce 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -112,6 +112,7 @@ class="form-control blocks-group-search"
         var COLLAPSE_PREFIX = 'wnBlocksCollapse:';
         var RECENT_KEY = 'wnBlocksRecent';
         var RECENT_MAX = 6;
+        var CLIPBOARD_KEY = 'wnBlocksClipboard';
 
         // --- safe localStorage helpers -------------------------------------
         function lsGet(key) {
@@ -121,6 +122,124 @@ function lsSet(key, val) {
             try { window.localStorage.setItem(key, val); } catch (e) {}
         }
 
+        // --- safe sessionStorage helpers -----------------------------------
+        function ssGet(key) {
+            try { return window.sessionStorage.getItem(key); } catch (e) { return null; }
+        }
+        function ssSet(key, val) {
+            try { window.sessionStorage.setItem(key, val); } catch (e) {}
+        }
+
+        // --- block clipboard (copy / cut / paste) -------------------------
+        function getClipboard() {
+            try {
+                var raw = ssGet(CLIPBOARD_KEY);
+                return raw ? JSON.parse(raw) : null;
+            } catch (e) { return null; }
+        }
+
+        // Serialize all named inputs in a block <li> by their trailing [key] segment.
+        // The _group hidden input gives us the block type; all other inputs are field data.
+        // Nested blocks fields store their JSON in a hidden input, so they serialize cleanly.
+        function serializeBlockItem(li) {
+            var data = { group: null, fields: {} };
+            li.querySelectorAll('input[name], select[name], textarea[name]').forEach(function (el) {
+                var m = el.name.match(/\[([^\[\]]+)\]$/);
+                if (!m) { return; }
+                var key = m[1];
+                if (key === '_group') {
+                    if (!data.group) { data.group = el.value; }
+                } else {
+                    data.fields[key] = el.value;
+                }
+            });
+            return data;
+        }
+
+        // Fill form inputs in a newly added <li> from stored field values.
+        // Matches by trailing [key] segment — works for flat fields and JSON hidden inputs.
+        function fillFromClipboard(li, fields) {
+            li.querySelectorAll('input[name], select[name], textarea[name]').forEach(function (el) {
+                var m = el.name.match(/\[([^\[\]]+)\]$/);
+                if (!m) { return; }
+                var key = m[1];
+                if (Object.prototype.hasOwnProperty.call(fields, key)) {
+                    el.value = fields[key];
+                    // Dispatch change so any widget listeners (e.g. select2, codemirror) react.
+                    el.dispatchEvent(new Event('change', { bubbles: true }));
+                }
+            });
+        }
+
+        // Copy button
+        document.addEventListener('click', function (e) {
+            var btn = e.target.closest('[data-block-copy]');
+            if (!btn) { return; }
+            e.stopPropagation();
+            var li = btn.closest('.field-block-item');
+            if (!li) { return; }
+            ssSet(CLIPBOARD_KEY, JSON.stringify(serializeBlockItem(li)));
+        });
+
+        // Cut button: copy then trigger the existing remove button (with confirm).
+        document.addEventListener('click', function (e) {
+            var btn = e.target.closest('[data-block-cut]');
+            if (!btn) { return; }
+            e.stopPropagation();
+            var li = btn.closest('.field-block-item');
+            if (!li) { return; }
+            ssSet(CLIPBOARD_KEY, JSON.stringify(serializeBlockItem(li)));
+            var removeBtn = li.querySelector('[data-repeater-remove]');
+            if (removeBtn) { removeBtn.click(); }
+        });
+
+        // Paste button (injected into the palette by applyPasteItem below).
+        // Sets a pending-paste flag, then programmatically clicks the matching block's
+        // add-link so onAddItem runs normally. The MutationObserver detects the new <li>
+        // and fills its fields from the clipboard.
+        document.addEventListener('click', function (e) {
+            var a = e.target.closest('[data-block-paste]');
+            if (!a) { return; }
+            e.preventDefault();
+            e.stopPropagation();
+            var cb = getClipboard();
+            if (!cb || !cb.group) { return; }
+            window.__pendingPaste = cb.fields;
+            var grid = a.closest('.blocks-group-grid');
+            var addLink = grid && grid.querySelector(
+                'a[data-block-code="' + cb.group + '"][data-repeater-add]'
+            );
+            if (addLink) { addLink.click(); }
+        });
+
+        // Inject a "Paste block" item at the top of the palette when clipboard has data
+        // and the block type is available in this widget's palette.
+        function applyPasteItem() {
+            document.querySelectorAll('.blocks-group-grid').forEach(function (grid) {
+                var existing = grid.querySelector('[data-block-paste]');
+                if (existing) { existing.closest('.blocks-group-item').remove(); }
+
+                var cb = getClipboard();
+                if (!cb || !cb.group) { return; }
+
+                var matchLink = grid.querySelector(
+                    'a[data-block-code="' + cb.group + '"][data-repeater-add]'
+                );
+                if (!matchLink) { return; }
+
+                var item = document.createElement('div');
+                item.className = 'blocks-group-item';
+                item.innerHTML =
+                    '<a href="javascript:;" data-block-paste data-block-code="' + cb.group + '">' +
+                    '<i class="icon-paste"></i>' +
+                    '<div>' +
+                    '<span class="title">Paste block</span>' +
+                    '<span class="description">Paste copied “' + cb.group + '” block</span>' +
+                    '</div></a>';
+                grid.insertBefore(item, grid.firstChild);
+            });
+        }
+
         // --- collapsible sections ------------------------------------------
         function followingFields(section) {
             var els = [], el = section.nextElementSibling;
@@ -214,12 +333,25 @@ function applyRecent() {
         }
 
         // --- shared init + observer ----------------------------------------
-        function runAll() { initSections(); applyRecent(); }
+        function runAll() { initSections(); applyRecent(); applyPasteItem(); }
 
         runAll();
 
         var scheduled = false;
-        var observer = new MutationObserver(function () {
+        var observer = new MutationObserver(function (mutations) {
+            // Fill clipboard fields into a newly added block item immediately,
+            // before the debounced runAll() fires, so inputs are ready.
+            if (window.__pendingPaste) {
+                for (var i = 0; i < mutations.length; i++) {
+                    mutations[i].addedNodes.forEach(function (node) {
+                        if (node.nodeType === 1 && node.classList &&
+                                node.classList.contains('field-block-item')) {
+                            fillFromClipboard(node, window.__pendingPaste);
+                            window.__pendingPaste = null;
+                        }
+                    });
+                }
+            }
             if (scheduled) { return; }
             scheduled = true;
             setTimeout(function () { scheduled = false; runAll(); }, 0);
diff --git a/formwidgets/blocks/partials/_block_item.php b/formwidgets/blocks/partials/_block_item.php
index 1268bd4..6c7eef6 100644
--- a/formwidgets/blocks/partials/_block_item.php
+++ b/formwidgets/blocks/partials/_block_item.php
@@ -12,6 +12,12 @@ class="field-repeater-item field-block-item<?php if (!count($widget->getFields()
 
     <?php if (!$this->previewMode) : ?>
         <div class="repeater-item-remove">
+            <button type="button" class="close" aria-label="Copy block" title="Copy" data-block-copy>
+                <i class="icon-copy" style="font-size:13px;opacity:.7"></i>
+            </button>
+            <button type="button" class="close" aria-label="Cut block" title="Cut" data-block-cut>
+                <i class="icon-scissors" style="font-size:13px;opacity:.7"></i>
+            </button>
             <button
                 type="button"
                 class="close"

From dc990d40e89cddf297c42f4e012e1ad68542e832 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 23:16:38 +0200
Subject: [PATCH 19/55] Improve copy/cut/paste UX: inline paste button per
 block

- Align copy/cut/paste/remove buttons horizontally with flexbox
- Move paste out of the add-block palette into each block's own toolbar:
  a paste icon button (hidden until clipboard has data) appears next to
  copy/cut/remove on every block item
- Clicking paste inserts the copied block immediately after the clicked
  block by firing onAddItem via the palette template's handler name, then
  the MutationObserver moves and fills the new <li> before any re-init runs
- updatePasteButtons() shows/hides paste buttons based on clipboard state
  and whether the copied block type is available in the same widget

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 formwidgets/blocks/partials/_block.php      | 97 +++++++++++----------
 formwidgets/blocks/partials/_block_item.php | 14 +--
 2 files changed, 62 insertions(+), 49 deletions(-)

diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 37794ce..2e9b076 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -171,6 +171,33 @@ function fillFromClipboard(li, fields) {
             });
         }
 
+        // Show/hide the paste button on every block item based on clipboard state.
+        // Also checks that the block type in the clipboard is available in the same widget.
+        function updatePasteButtons() {
+            var cb = getClipboard();
+            document.querySelectorAll('[data-block-paste]').forEach(function (btn) {
+                if (!cb || !cb.group) { btn.style.display = 'none'; return; }
+                // Find the palette template for this widget and check the block type exists.
+                var fieldBlocks = btn.closest('.field-blocks');
+                var tmpl = fieldBlocks && fieldBlocks.querySelector('[data-group-palette-template]');
+                var available = tmpl && (tmpl.textContent || tmpl.innerHTML)
+                    .indexOf('data-block-code=”' + cb.group + '”') !== -1;
+                btn.style.display = available ? '' : 'none';
+            });
+        }
+
+        // Find the onAddItem AJAX handler name for a given group code by reading the
+        // palette template embedded in the same .field-blocks widget.
+        function findAddHandler(fieldBlocks, groupCode) {
+            var tmpl = fieldBlocks && fieldBlocks.querySelector('[data-group-palette-template]');
+            if (!tmpl) { return null; }
+            // Parse the template text to extract data-request from the matching link.
+            var div = document.createElement('div');
+            div.innerHTML = tmpl.textContent || tmpl.innerHTML;
+            var link = div.querySelector('a[data-block-code=”' + groupCode + '”]');
+            return link ? link.getAttribute('data-request') : null;
+        }
+
         // Copy button
         document.addEventListener('click', function (e) {
             var btn = e.target.closest('[data-block-copy]');
@@ -179,6 +206,7 @@ function fillFromClipboard(li, fields) {
             var li = btn.closest('.field-block-item');
             if (!li) { return; }
             ssSet(CLIPBOARD_KEY, JSON.stringify(serializeBlockItem(li)));
+            updatePasteButtons();
         });
 
         // Cut button: copy then trigger the existing remove button (with confirm).
@@ -189,57 +217,31 @@ function fillFromClipboard(li, fields) {
             var li = btn.closest('.field-block-item');
             if (!li) { return; }
             ssSet(CLIPBOARD_KEY, JSON.stringify(serializeBlockItem(li)));
+            updatePasteButtons();
             var removeBtn = li.querySelector('[data-repeater-remove]');
             if (removeBtn) { removeBtn.click(); }
         });
 
-        // Paste button (injected into the palette by applyPasteItem below).
-        // Sets a pending-paste flag, then programmatically clicks the matching block's
-        // add-link so onAddItem runs normally. The MutationObserver detects the new <li>
-        // and fills its fields from the clipboard.
+        // Paste button on each block item — inserts the copied block immediately after.
+        // Reads the AJAX handler name from the palette template (no popover needed),
+        // fires onAddItem directly, then the MutationObserver moves the new <li> into place.
         document.addEventListener('click', function (e) {
-            var a = e.target.closest('[data-block-paste]');
-            if (!a) { return; }
+            var btn = e.target.closest('[data-block-paste]');
+            if (!btn || !btn.closest('.field-block-item')) { return; }
             e.preventDefault();
             e.stopPropagation();
             var cb = getClipboard();
             if (!cb || !cb.group) { return; }
-            window.__pendingPaste = cb.fields;
-            var grid = a.closest('.blocks-group-grid');
-            var addLink = grid && grid.querySelector(
-                'a[data-block-code="' + cb.group + '"][data-repeater-add]'
-            );
-            if (addLink) { addLink.click(); }
+            var li = btn.closest('.field-block-item');
+            var fieldBlocks = li.closest('.field-blocks');
+            var handler = findAddHandler(fieldBlocks, cb.group);
+            if (!handler) { return; }
+            window.__pendingPaste = { fields: cb.fields, afterLi: li };
+            if (typeof $ !== 'undefined') {
+                $(fieldBlocks).request(handler, { data: { _repeater_group: cb.group } });
+            }
         });
 
-        // Inject a "Paste block" item at the top of the palette when clipboard has data
-        // and the block type is available in this widget's palette.
-        function applyPasteItem() {
-            document.querySelectorAll('.blocks-group-grid').forEach(function (grid) {
-                var existing = grid.querySelector('[data-block-paste]');
-                if (existing) { existing.closest('.blocks-group-item').remove(); }
-
-                var cb = getClipboard();
-                if (!cb || !cb.group) { return; }
-
-                var matchLink = grid.querySelector(
-                    'a[data-block-code="' + cb.group + '"][data-repeater-add]'
-                );
-                if (!matchLink) { return; }
-
-                var item = document.createElement('div');
-                item.className = 'blocks-group-item';
-                item.innerHTML =
-                    '<a href="javascript:;" data-block-paste data-block-code="' + cb.group + '">' +
-                    '<i class="icon-paste"></i>' +
-                    '<div>' +
-                    '<span class="title">Paste block</span>' +
-                    '<span class="description">Paste copied “' + cb.group + '” block</span>' +
-                    '</div></a>';
-                grid.insertBefore(item, grid.firstChild);
-            });
-        }
-
         // --- collapsible sections ------------------------------------------
         function followingFields(section) {
             var els = [], el = section.nextElementSibling;
@@ -333,21 +335,28 @@ function applyRecent() {
         }
 
         // --- shared init + observer ----------------------------------------
-        function runAll() { initSections(); applyRecent(); applyPasteItem(); }
+        function runAll() { initSections(); applyRecent(); updatePasteButtons(); }
 
         runAll();
 
         var scheduled = false;
         var observer = new MutationObserver(function (mutations) {
-            // Fill clipboard fields into a newly added block item immediately,
-            // before the debounced runAll() fires, so inputs are ready.
+            // When a paste is pending, find the newly added block <li>, move it after
+            // the source block, and fill its fields — all before the debounced runAll fires.
             if (window.__pendingPaste) {
+                var pending = window.__pendingPaste;
                 for (var i = 0; i < mutations.length; i++) {
                     mutations[i].addedNodes.forEach(function (node) {
                         if (node.nodeType === 1 && node.classList &&
                                 node.classList.contains('field-block-item')) {
-                            fillFromClipboard(node, window.__pendingPaste);
                             window.__pendingPaste = null;
+                            // Move the new item to immediately after the source item.
+                            if (pending.afterLi && pending.afterLi.parentNode) {
+                                pending.afterLi.parentNode.insertBefore(
+                                    node, pending.afterLi.nextSibling
+                                );
+                            }
+                            fillFromClipboard(node, pending.fields);
                         }
                     });
                 }
diff --git a/formwidgets/blocks/partials/_block_item.php b/formwidgets/blocks/partials/_block_item.php
index 6c7eef6..64a9c6a 100644
--- a/formwidgets/blocks/partials/_block_item.php
+++ b/formwidgets/blocks/partials/_block_item.php
@@ -11,16 +11,20 @@ class="field-repeater-item field-block-item<?php if (!count($widget->getFields()
 >
 
     <?php if (!$this->previewMode) : ?>
-        <div class="repeater-item-remove">
-            <button type="button" class="close" aria-label="Copy block" title="Copy" data-block-copy>
-                <i class="icon-copy" style="font-size:13px;opacity:.7"></i>
+        <div class="repeater-item-remove" style="display:flex;align-items:center;gap:2px">
+            <button type="button" class="close" aria-label="Copy block" title="Copy" data-block-copy style="float:none;font-size:13px;opacity:.7">
+                <i class="icon-copy"></i>
             </button>
-            <button type="button" class="close" aria-label="Cut block" title="Cut" data-block-cut>
-                <i class="icon-scissors" style="font-size:13px;opacity:.7"></i>
+            <button type="button" class="close" aria-label="Cut block" title="Cut" data-block-cut style="float:none;font-size:13px;opacity:.7">
+                <i class="icon-scissors"></i>
+            </button>
+            <button type="button" class="close" aria-label="Paste after this block" title="Paste after" data-block-paste style="float:none;font-size:13px;opacity:.7;display:none">
+                <i class="icon-paste"></i>
             </button>
             <button
                 type="button"
                 class="close"
+                style="float:none"
                 aria-label="Remove"
                 data-repeater-remove
                 data-request="<?= $this->getEventHandler('onRemoveItem') ?>"

From bdf869320cc9163d8ce014a9c515f201c8d0125a Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 23:18:25 +0200
Subject: [PATCH 20/55] Add paste-to-empty-widget support via add-item row

A 'Paste block' link appears in the add-item row of every blocks widget
when the clipboard holds a compatible block type. This allows pasting into
a widget that has no existing items (e.g. an empty right column), where
the per-item paste button would not be present. The pasted block is
appended at the end of the list.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 formwidgets/blocks/partials/_block.php        | 26 ++++++++++++++++---
 .../blocks/partials/_block_add_item.php       |  7 +++++
 2 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 2e9b076..87b3512 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -171,13 +171,13 @@ function fillFromClipboard(li, fields) {
             });
         }
 
-        // Show/hide the paste button on every block item based on clipboard state.
-        // Also checks that the block type in the clipboard is available in the same widget.
+        // Show/hide paste buttons based on clipboard state and widget availability.
+        // Handles both the per-item paste button and the append button in the add-item row.
         function updatePasteButtons() {
             var cb = getClipboard();
-            document.querySelectorAll('[data-block-paste]').forEach(function (btn) {
+            var selectors = '[data-block-paste], [data-block-paste-append]';
+            document.querySelectorAll(selectors).forEach(function (btn) {
                 if (!cb || !cb.group) { btn.style.display = 'none'; return; }
-                // Find the palette template for this widget and check the block type exists.
                 var fieldBlocks = btn.closest('.field-blocks');
                 var tmpl = fieldBlocks && fieldBlocks.querySelector('[data-group-palette-template]');
                 var available = tmpl && (tmpl.textContent || tmpl.innerHTML)
@@ -222,6 +222,24 @@ function findAddHandler(fieldBlocks, groupCode) {
             if (removeBtn) { removeBtn.click(); }
         });
 
+        // Paste-append button in the add-item row — appends the copied block at the end.
+        document.addEventListener('click', function (e) {
+            var btn = e.target.closest('[data-block-paste-append]');
+            if (!btn) { return; }
+            e.preventDefault();
+            e.stopPropagation();
+            var cb = getClipboard();
+            if (!cb || !cb.group) { return; }
+            var fieldBlocks = btn.closest('.field-blocks');
+            var handler = findAddHandler(fieldBlocks, cb.group);
+            if (!handler) { return; }
+            // No afterLi — the MutationObserver will fill the block where onAddItem appends it.
+            window.__pendingPaste = { fields: cb.fields, afterLi: null };
+            if (typeof $ !== 'undefined') {
+                $(fieldBlocks).request(handler, { data: { _repeater_group: cb.group } });
+            }
+        });
+
         // Paste button on each block item — inserts the copied block immediately after.
         // Reads the AJAX handler name from the palette template (no popover needed),
         // fires onAddItem directly, then the MutationObserver moves the new <li> into place.
diff --git a/formwidgets/blocks/partials/_block_add_item.php b/formwidgets/blocks/partials/_block_add_item.php
index c93a13e..1d2ae2e 100644
--- a/formwidgets/blocks/partials/_block_add_item.php
+++ b/formwidgets/blocks/partials/_block_add_item.php
@@ -11,5 +11,12 @@ class="wn-icon-plus"
             data-load-indicator>
             <?= e(trans($prompt)) ?>
         </a>
+        <a
+            href="javascript:;"
+            class="wn-icon-paste"
+            data-block-paste-append
+            style="display:none;margin-left:12px">
+            Paste block
+        </a>
     </li>
 <?php endif ?>

From 82854eb148424b25b4e766e4b80a77f33f1c87a4 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 23:24:06 +0200
Subject: [PATCH 21/55] Fix paste detection (smart quotes) and toolbar
 alignment

Two bugs in the copy/cut/paste feature:

- Paste buttons never appeared: the availability check and add-handler
  lookup compared against `data-block-code=` using curly quotes (U+201D)
  instead of straight ASCII quotes, so indexOf/querySelector never matched
  the real palette markup. Replaced with straight quotes.

- Toolbar buttons overlapped: copy/cut/paste/remove reused Bootstrap's
  `.close` class, inheriting float and a large font-size/line-height that
  crammed the glyphs together. Replaced with dedicated `.block-item-action`
  buttons in a flex `.block-item-toolbar`, sized and spaced consistently.
  Styles live in blocks.less and are also injected inline (once, guarded) so
  the toolbar renders correctly even if the compiled CSS is stale.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 formwidgets/blocks/assets/less/blocks.less  | 39 +++++++++++++++++++++
 formwidgets/blocks/partials/_block.php      | 23 ++++++++++--
 formwidgets/blocks/partials/_block_item.php | 13 ++++---
 3 files changed, 66 insertions(+), 9 deletions(-)

diff --git a/formwidgets/blocks/assets/less/blocks.less b/formwidgets/blocks/assets/less/blocks.less
index 4d6f7a0..8a4c876 100644
--- a/formwidgets/blocks/assets/less/blocks.less
+++ b/formwidgets/blocks/assets/less/blocks.less
@@ -5,6 +5,45 @@
 .field-blocks {
     padding-top: 5px;
 
+    // Per-block toolbar: copy / cut / paste / remove, aligned horizontally.
+    // Mirrored as an inline-injected <style> in the block widget partial so the
+    // toolbar still renders correctly when the compiled CSS is stale.
+    .block-item-toolbar {
+        display: inline-flex;
+        align-items: center;
+        gap: 1px;
+    }
+
+    .block-item-action {
+        float: none;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        width: 22px;
+        height: 22px;
+        padding: 0;
+        margin: 0;
+        border: 0;
+        background: none;
+        cursor: pointer;
+        color: #95a5a6;
+        opacity: .7;
+        font-size: 13px;
+        line-height: 1;
+        border-radius: 3px;
+        transition: background .15s, color .15s, opacity .15s;
+
+        &:hover {
+            opacity: 1;
+            background: rgba(0, 0, 0, .06);
+            color: #34495e;
+        }
+
+        &.block-item-action-remove:hover {
+            color: #cc3300;
+        }
+    }
+
     .field-block-items {
         counter-reset: repeater-index-counter;
     }
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 87b3512..65d5936 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -114,6 +114,25 @@ class="form-control blocks-group-search"
         var RECENT_MAX = 6;
         var CLIPBOARD_KEY = 'wnBlocksClipboard';
 
+        // --- inject toolbar styles once ------------------------------------
+        // Kept here (rather than only in blocks.less) so the per-block copy/cut/
+        // paste/remove toolbar renders correctly even if the compiled CSS is stale.
+        (function injectToolbarCss() {
+            if (document.getElementById('wn-blocks-toolbar-css')) { return; }
+            var css =
+                '.block-item-toolbar{display:inline-flex;align-items:center;gap:1px}' +
+                '.block-item-action{float:none;display:inline-flex;align-items:center;' +
+                'justify-content:center;width:22px;height:22px;padding:0;margin:0;border:0;' +
+                'background:none;cursor:pointer;color:#95a5a6;opacity:.7;font-size:13px;' +
+                'line-height:1;border-radius:3px;transition:background .15s,color .15s,opacity .15s}' +
+                '.block-item-action:hover{opacity:1;background:rgba(0,0,0,.06);color:#34495e}' +
+                '.block-item-action-remove:hover{color:#cc3300}';
+            var style = document.createElement('style');
+            style.id = 'wn-blocks-toolbar-css';
+            style.textContent = css;
+            (document.head || document.documentElement).appendChild(style);
+        })();
+
         // --- safe localStorage helpers -------------------------------------
         function lsGet(key) {
             try { return window.localStorage.getItem(key); } catch (e) { return null; }
@@ -181,7 +200,7 @@ function updatePasteButtons() {
                 var fieldBlocks = btn.closest('.field-blocks');
                 var tmpl = fieldBlocks && fieldBlocks.querySelector('[data-group-palette-template]');
                 var available = tmpl && (tmpl.textContent || tmpl.innerHTML)
-                    .indexOf('data-block-code=”' + cb.group + '”') !== -1;
+                    .indexOf('data-block-code="' + cb.group + '"') !== -1;
                 btn.style.display = available ? '' : 'none';
             });
         }
@@ -194,7 +213,7 @@ function findAddHandler(fieldBlocks, groupCode) {
             // Parse the template text to extract data-request from the matching link.
             var div = document.createElement('div');
             div.innerHTML = tmpl.textContent || tmpl.innerHTML;
-            var link = div.querySelector('a[data-block-code=”' + groupCode + '”]');
+            var link = div.querySelector('a[data-block-code="' + groupCode + '"]');
             return link ? link.getAttribute('data-request') : null;
         }
 
diff --git a/formwidgets/blocks/partials/_block_item.php b/formwidgets/blocks/partials/_block_item.php
index 64a9c6a..5be929c 100644
--- a/formwidgets/blocks/partials/_block_item.php
+++ b/formwidgets/blocks/partials/_block_item.php
@@ -11,26 +11,25 @@ class="field-repeater-item field-block-item<?php if (!count($widget->getFields()
 >
 
     <?php if (!$this->previewMode) : ?>
-        <div class="repeater-item-remove" style="display:flex;align-items:center;gap:2px">
-            <button type="button" class="close" aria-label="Copy block" title="Copy" data-block-copy style="float:none;font-size:13px;opacity:.7">
+        <div class="repeater-item-remove block-item-toolbar">
+            <button type="button" class="block-item-action" aria-label="Copy block" title="Copy" data-block-copy>
                 <i class="icon-copy"></i>
             </button>
-            <button type="button" class="close" aria-label="Cut block" title="Cut" data-block-cut style="float:none;font-size:13px;opacity:.7">
+            <button type="button" class="block-item-action" aria-label="Cut block" title="Cut" data-block-cut>
                 <i class="icon-scissors"></i>
             </button>
-            <button type="button" class="close" aria-label="Paste after this block" title="Paste after" data-block-paste style="float:none;font-size:13px;opacity:.7;display:none">
+            <button type="button" class="block-item-action" aria-label="Paste after this block" title="Paste after" data-block-paste style="display:none">
                 <i class="icon-paste"></i>
             </button>
             <button
                 type="button"
-                class="close"
-                style="float:none"
+                class="block-item-action block-item-action-remove"
                 aria-label="Remove"
                 data-repeater-remove
                 data-request="<?= $this->getEventHandler('onRemoveItem') ?>"
                 data-request-data="'_repeater_index': '<?= $indexValue ?>', '_repeater_group': '<?= $groupCode ?>'"
                 data-request-confirm="<?= e(trans('backend::lang.form.action_confirm')) ?>">
-                <span aria-hidden="true">&times;</span>
+                <i class="icon-times"></i>
             </button>
         </div>
     <?php endif ?>

From 216d04c22740397d3cc79faea2d0c91ea15d127e Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 23:31:33 +0200
Subject: [PATCH 22/55] Make paste link fail open and render reliably

The paste availability check hid the paste options whenever it could not
positively match the block code in the palette template (fail closed),
which could hide the "Paste block" link even for a valid block. It now
fails open: a paste option is hidden only when the template positively
proves the block type is not offered by that widget. The paste action
already no-ops safely on an unknown type.

Also dropped the wn-icon-paste class on the add-item link (which could
render with no visible label) in favour of an explicit icon + text.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 formwidgets/blocks/partials/_block.php          | 16 ++++++++++++----
 formwidgets/blocks/partials/_block_add_item.php |  5 ++---
 2 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 65d5936..234dee2 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -190,6 +190,17 @@ function fillFromClipboard(li, fields) {
             });
         }
 
+        // Is the given block code offered by this widget's palette?
+        // Returns true if we can't tell (fail open) so a paste option is never
+        // hidden by a markup quirk; the paste action itself no-ops on a bad type.
+        function blockTypeAvailable(fieldBlocks, group) {
+            var tmpl = fieldBlocks && fieldBlocks.querySelector('[data-group-palette-template]');
+            if (!tmpl) { return true; }
+            var text = tmpl.textContent || tmpl.innerHTML || '';
+            if (text.indexOf('data-block-code=') === -1) { return true; }
+            return text.indexOf('data-block-code="' + group + '"') !== -1;
+        }
+
         // Show/hide paste buttons based on clipboard state and widget availability.
         // Handles both the per-item paste button and the append button in the add-item row.
         function updatePasteButtons() {
@@ -198,10 +209,7 @@ function updatePasteButtons() {
             document.querySelectorAll(selectors).forEach(function (btn) {
                 if (!cb || !cb.group) { btn.style.display = 'none'; return; }
                 var fieldBlocks = btn.closest('.field-blocks');
-                var tmpl = fieldBlocks && fieldBlocks.querySelector('[data-group-palette-template]');
-                var available = tmpl && (tmpl.textContent || tmpl.innerHTML)
-                    .indexOf('data-block-code="' + cb.group + '"') !== -1;
-                btn.style.display = available ? '' : 'none';
+                btn.style.display = blockTypeAvailable(fieldBlocks, cb.group) ? '' : 'none';
             });
         }
 
diff --git a/formwidgets/blocks/partials/_block_add_item.php b/formwidgets/blocks/partials/_block_add_item.php
index 1d2ae2e..07d2048 100644
--- a/formwidgets/blocks/partials/_block_add_item.php
+++ b/formwidgets/blocks/partials/_block_add_item.php
@@ -13,10 +13,9 @@ class="wn-icon-plus"
         </a>
         <a
             href="javascript:;"
-            class="wn-icon-paste"
             data-block-paste-append
-            style="display:none;margin-left:12px">
-            Paste block
+            style="display:none;margin-left:14px;font-size:13px">
+            <i class="icon-paste"></i> Paste block
         </a>
     </li>
 <?php endif ?>

From 6a3dd577daf30346e05efaebdf56470c7fcf98d5 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 23:36:32 +0200
Subject: [PATCH 23/55] Move "Paste block" onto its own list row so it is never
 clipped

The append link was a second inline anchor inside the centered add-item
<li>, so it wrapped under the "+" button and could be clipped by the item
height. It now renders as its own full-width list row beneath the Add
button, toggled via a row container. Added matching styles in blocks.less
and the inline-injected CSS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 formwidgets/blocks/assets/less/blocks.less    | 18 +++++++++++++
 formwidgets/blocks/partials/_block.php        | 27 ++++++++++++++-----
 .../blocks/partials/_block_add_item.php       |  7 +++--
 3 files changed, 41 insertions(+), 11 deletions(-)

diff --git a/formwidgets/blocks/assets/less/blocks.less b/formwidgets/blocks/assets/less/blocks.less
index 8a4c876..814a34d 100644
--- a/formwidgets/blocks/assets/less/blocks.less
+++ b/formwidgets/blocks/assets/less/blocks.less
@@ -44,6 +44,24 @@
         }
     }
 
+    // "Paste block" row shown under the Add button when the clipboard holds a
+    // compatible block. Its own list row so it is never clipped by the add item.
+    .field-block-paste-row {
+        list-style: none;
+        text-align: center;
+        padding: 6px 0;
+
+        a {
+            font-size: 13px;
+            color: @link-color;
+            text-decoration: none;
+
+            &:hover {
+                text-decoration: underline;
+            }
+        }
+    }
+
     .field-block-items {
         counter-reset: repeater-index-counter;
     }
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 234dee2..d5f8196 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -126,7 +126,10 @@ class="form-control blocks-group-search"
                 'background:none;cursor:pointer;color:#95a5a6;opacity:.7;font-size:13px;' +
                 'line-height:1;border-radius:3px;transition:background .15s,color .15s,opacity .15s}' +
                 '.block-item-action:hover{opacity:1;background:rgba(0,0,0,.06);color:#34495e}' +
-                '.block-item-action-remove:hover{color:#cc3300}';
+                '.block-item-action-remove:hover{color:#cc3300}' +
+                '.field-block-paste-row{list-style:none;text-align:center;padding:6px 0}' +
+                '.field-block-paste-row a{font-size:13px;color:#0072bc;text-decoration:none}' +
+                '.field-block-paste-row a:hover{text-decoration:underline}';
             var style = document.createElement('style');
             style.id = 'wn-blocks-toolbar-css';
             style.textContent = css;
@@ -201,15 +204,25 @@ function blockTypeAvailable(fieldBlocks, group) {
             return text.indexOf('data-block-code="' + group + '"') !== -1;
         }
 
-        // Show/hide paste buttons based on clipboard state and widget availability.
-        // Handles both the per-item paste button and the append button in the add-item row.
+        // Show/hide paste affordances based on clipboard state and widget availability.
+        // Per-item paste buttons toggle themselves; the append link toggles its own
+        // <li> row (so it sits on its own line under the Add button, never clipped).
+        function setPasteVisible(el, visible) {
+            if (el) { el.style.display = visible ? '' : 'none'; }
+        }
         function updatePasteButtons() {
             var cb = getClipboard();
-            var selectors = '[data-block-paste], [data-block-paste-append]';
-            document.querySelectorAll(selectors).forEach(function (btn) {
-                if (!cb || !cb.group) { btn.style.display = 'none'; return; }
+            var ok = cb && cb.group;
+
+            document.querySelectorAll('[data-block-paste]').forEach(function (btn) {
                 var fieldBlocks = btn.closest('.field-blocks');
-                btn.style.display = blockTypeAvailable(fieldBlocks, cb.group) ? '' : 'none';
+                setPasteVisible(btn, ok && blockTypeAvailable(fieldBlocks, cb.group));
+            });
+
+            document.querySelectorAll('[data-block-paste-append]').forEach(function (link) {
+                var fieldBlocks = link.closest('.field-blocks');
+                var row = link.closest('[data-block-paste-append-row]') || link;
+                setPasteVisible(row, ok && blockTypeAvailable(fieldBlocks, cb.group));
             });
         }
 
diff --git a/formwidgets/blocks/partials/_block_add_item.php b/formwidgets/blocks/partials/_block_add_item.php
index 07d2048..d597b3e 100644
--- a/formwidgets/blocks/partials/_block_add_item.php
+++ b/formwidgets/blocks/partials/_block_add_item.php
@@ -11,10 +11,9 @@ class="wn-icon-plus"
             data-load-indicator>
             <?= e(trans($prompt)) ?>
         </a>
-        <a
-            href="javascript:;"
-            data-block-paste-append
-            style="display:none;margin-left:14px;font-size:13px">
+    </li>
+    <li class="field-block-paste-row" data-block-paste-append-row style="display:none">
+        <a href="javascript:;" data-block-paste-append>
             <i class="icon-paste"></i> Paste block
         </a>
     </li>

From e097de7a2ef1a275d161eb75e053785fd9822b94 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 23:41:25 +0200
Subject: [PATCH 24/55] Drive paste from explicit data attributes, not template
 parsing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The paste availability check and add-handler lookup parsed the popover
<script> template at click time. That was fragile: when parsing failed,
availability failed open (paste link always shown) and the handler lookup
returned null (paste did nothing) — exactly the "always shown and does
not work" symptom.

Now the widget renders two explicit attributes on .field-blocks:
  - data-add-handler: the onAddItem AJAX handler name
  - data-block-codes: comma list of block codes offered by this widget

blockTypeAvailable() and findAddHandler() read these directly, so the
paste link shows only for compatible blocks and the paste action always
has a valid handler to fire.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 formwidgets/blocks/partials/_block.php | 32 ++++++++++----------------
 1 file changed, 12 insertions(+), 20 deletions(-)

diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index d5f8196..99d5472 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -5,6 +5,8 @@
     <?= $maxItems ? 'data-max-items="'.$maxItems.'"' : '' ?>
     <?= $style ? 'data-style="'.$style.'"' : '' ?>
     data-mode="<?= $mode ?>"
+    data-add-handler="<?= $this->getEventHandler('onAddItem') ?>"
+    data-block-codes="<?= e(implode(',', array_keys($groupDefinitions))) ?>"
     <?php if ($mode === 'grid'): ?> data-columns="<?= $columns ?>" <?php endif ?>
     <?php if ($sortable) : ?>
     data-sortable="true"
@@ -193,15 +195,12 @@ function fillFromClipboard(li, fields) {
             });
         }
 
-        // Is the given block code offered by this widget's palette?
-        // Returns true if we can't tell (fail open) so a paste option is never
-        // hidden by a markup quirk; the paste action itself no-ops on a bad type.
+        // Is the given block code offered by this widget? Reads the explicit
+        // data-block-codes list rendered server-side on the .field-blocks element.
         function blockTypeAvailable(fieldBlocks, group) {
-            var tmpl = fieldBlocks && fieldBlocks.querySelector('[data-group-palette-template]');
-            if (!tmpl) { return true; }
-            var text = tmpl.textContent || tmpl.innerHTML || '';
-            if (text.indexOf('data-block-code=') === -1) { return true; }
-            return text.indexOf('data-block-code="' + group + '"') !== -1;
+            if (!fieldBlocks) { return false; }
+            var list = fieldBlocks.getAttribute('data-block-codes') || '';
+            return list.split(',').indexOf(group) !== -1;
         }
 
         // Show/hide paste affordances based on clipboard state and widget availability.
@@ -226,16 +225,9 @@ function updatePasteButtons() {
             });
         }
 
-        // Find the onAddItem AJAX handler name for a given group code by reading the
-        // palette template embedded in the same .field-blocks widget.
-        function findAddHandler(fieldBlocks, groupCode) {
-            var tmpl = fieldBlocks && fieldBlocks.querySelector('[data-group-palette-template]');
-            if (!tmpl) { return null; }
-            // Parse the template text to extract data-request from the matching link.
-            var div = document.createElement('div');
-            div.innerHTML = tmpl.textContent || tmpl.innerHTML;
-            var link = div.querySelector('a[data-block-code="' + groupCode + '"]');
-            return link ? link.getAttribute('data-request') : null;
+        // The onAddItem AJAX handler name, rendered server-side on .field-blocks.
+        function findAddHandler(fieldBlocks) {
+            return fieldBlocks ? fieldBlocks.getAttribute('data-add-handler') : null;
         }
 
         // Copy button
@@ -271,7 +263,7 @@ function findAddHandler(fieldBlocks, groupCode) {
             var cb = getClipboard();
             if (!cb || !cb.group) { return; }
             var fieldBlocks = btn.closest('.field-blocks');
-            var handler = findAddHandler(fieldBlocks, cb.group);
+            var handler = findAddHandler(fieldBlocks);
             if (!handler) { return; }
             // No afterLi — the MutationObserver will fill the block where onAddItem appends it.
             window.__pendingPaste = { fields: cb.fields, afterLi: null };
@@ -292,7 +284,7 @@ function findAddHandler(fieldBlocks, groupCode) {
             if (!cb || !cb.group) { return; }
             var li = btn.closest('.field-block-item');
             var fieldBlocks = li.closest('.field-blocks');
-            var handler = findAddHandler(fieldBlocks, cb.group);
+            var handler = findAddHandler(fieldBlocks);
             if (!handler) { return; }
             window.__pendingPaste = { fields: cb.fields, afterLi: li };
             if (typeof $ !== 'undefined') {

From a10264da4bf83ad19e5f64bd77c1252dd2b768af Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Thu, 11 Jun 2026 23:54:07 +0200
Subject: [PATCH 25/55] Consolidate item controls into one non-overflowing
 toolbar

Replaces the separate absolutely-positioned collapse chevron, copy/cut/
paste buttons and remove button (which were constrained to a fixed 20px
box and overflowed) with a single horizontal flex toolbar in this order:
collapse, cut, paste, duplicate, [config], delete.

- Overrides the core fixed width on .repeater-item-remove so icons never
  overflow; icons use the neutral backend text colour, not blue.
- Copy is replaced by Duplicate: clones the block in place and also puts it
  on the clipboard (so cross-widget paste still works).
- The collapse chevron now lives in the toolbar, outside the core
  .repeater-item-collapse wrapper its delegated handler targets, so we bind
  our own document-level collapse toggle (also more robust for dynamically
  added blocks). Added a collapsed-state rotate rule for the new location.
- "Paste block" append affordance restyled from a blue text link to a
  neutral primary-style icon+label.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                | 12 ++--
 README.md                                   | 14 +++--
 formwidgets/blocks/assets/less/blocks.less  | 52 ++++++++++++----
 formwidgets/blocks/partials/_block.php      | 54 ++++++++++++----
 formwidgets/blocks/partials/_block_item.php | 69 ++++++++++++---------
 5 files changed, 137 insertions(+), 64 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a1dcb55..d9793e0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -32,11 +32,13 @@
 ### Editor UX
 - **Recently used blocks** are pinned to the top of the "add block" palette
   (tracked in `localStorage`, most-recent first).
-- **Copy / Cut / Paste blocks** — Copy and Cut icon buttons on each block
-  serialize its field values to `sessionStorage`. A Paste entry appears at the
-  top of the "add block" palette when the clipboard holds a block whose type is
-  available in the current widget (respects `allow`/`ignore`/`tags`). Paste
-  survives navigation within the same browser tab.
+- **Cut / Paste / Duplicate blocks** — each block has one horizontal toolbar
+  (collapse, cut, paste, duplicate, config, delete). Cut/duplicate place the
+  block's field values on the clipboard (`sessionStorage`); paste inserts after
+  a block, or appends via an affordance under the Add button (for empty
+  widgets). Duplicate also clones in place. Paste affordances appear only where
+  the copied block type is offered (respects `allow`/`ignore`/`tags`) and
+  survive navigation within the same browser tab.
 
 ### Tests
 - `BlockManagerTest`: include merging, block-overrides-include precedence,
diff --git a/README.md b/README.md
index ffb96be..89abb62 100644
--- a/README.md
+++ b/README.md
@@ -293,15 +293,17 @@ When adding a block from the palette, the blocks you use most recently are pinne
 
 ---
 
-## Copy, cut and paste blocks
+## Cut, paste and duplicate blocks
 
-Each block has **Copy** and **Cut** icon buttons next to the remove (×) button.
+Every block has a single horizontal toolbar (top-right) with, in order:
+**collapse**, **cut**, **paste**, **duplicate**, *(config, if the block has an
+inspector)* and **delete**.
 
-- **Copy** — serializes the block's current field values to `sessionStorage`.
-- **Cut** — copies then immediately triggers the remove button (with the usual confirmation prompt).
-- **Paste** — when the clipboard holds a block, a **Paste block** entry appears at the top of the "add block" palette. Clicking it adds a fresh block of that type and fills all its fields with the copied values.
+- **Cut** — places the block's field values on the clipboard, then removes it (with the usual confirmation prompt).
+- **Paste** — appears once the clipboard holds a block. On each block it inserts the copied block immediately **after** that block; a **Paste block** affordance also appears beneath the "Add Block" button to append into an empty widget.
+- **Duplicate** — clones the block in place (inserts a filled copy right after it) and also places it on the clipboard, so you can immediately paste the same block into another widget.
 
-Paste respects the widget's `allow` / `ignore` / `tags` constraints: if the copied block type is not available in the target widget's palette, the Paste entry is not shown. The clipboard persists for the duration of the browser session (`sessionStorage`), so you can paste across different pages in the same tab.
+Paste/duplicate respect the widget's `allow` / `ignore` / `tags` constraints: the paste affordance only appears where the copied block type is actually offered. The clipboard persists for the duration of the browser session (`sessionStorage`), so you can paste across different pages in the same tab.
 
 > **Note on nested blocks:** Field values — including nested `blocks` fields, which store their content as JSON — are captured and restored correctly. Complex editor widgets (e.g. rich-text, code editors) may require an extra click to refresh their UI after paste, as those widgets listen for native `change` events.
 
diff --git a/formwidgets/blocks/assets/less/blocks.less b/formwidgets/blocks/assets/less/blocks.less
index 814a34d..29d0001 100644
--- a/formwidgets/blocks/assets/less/blocks.less
+++ b/formwidgets/blocks/assets/less/blocks.less
@@ -5,13 +5,19 @@
 .field-blocks {
     padding-top: 5px;
 
-    // Per-block toolbar: copy / cut / paste / remove, aligned horizontally.
+    // Per-block toolbar holding every item control in one horizontal row:
+    // collapse, cut, paste, duplicate, config, delete. Overrides the core
+    // fixed 20px width on .repeater-item-remove so the icons never overflow.
     // Mirrored as an inline-injected <style> in the block widget partial so the
     // toolbar still renders correctly when the compiled CSS is stale.
-    .block-item-toolbar {
+    .field-block-item > .repeater-item-remove.block-item-toolbar {
+        width: auto;
+        height: auto;
         display: inline-flex;
         align-items: center;
         gap: 1px;
+        top: 4px;
+        right: 5px;
     }
 
     .block-item-action {
@@ -26,38 +32,62 @@
         border: 0;
         background: none;
         cursor: pointer;
-        color: #95a5a6;
-        opacity: .7;
+        color: @text-color;
+        opacity: .6;
         font-size: 13px;
         line-height: 1;
         border-radius: 3px;
         transition: background .15s, color .15s, opacity .15s;
 
-        &:hover {
+        > i { line-height: 1; }
+
+        &:hover,
+        &:focus {
             opacity: 1;
             background: rgba(0, 0, 0, .06);
-            color: #34495e;
+            color: @text-color;
+            text-decoration: none;
         }
 
         &.block-item-action-remove:hover {
             color: #cc3300;
         }
+
+        // Keep the collapse chevron's rotate-when-collapsed behaviour.
+        &.repeater-item-collapse-one {
+            transition: transform .3s, background .15s, opacity .15s;
+        }
+    }
+
+    // Rotate the collapse chevron when the item is collapsed (it now lives in
+    // the toolbar rather than the original .repeater-item-collapse wrapper).
+    .field-block-item.collapsed > .repeater-item-remove .repeater-item-collapse-one {
+        .transform(rotate(180deg));
     }
 
-    // "Paste block" row shown under the Add button when the clipboard holds a
+    // "Paste block" affordance under the Add button when the clipboard holds a
     // compatible block. Its own list row so it is never clipped by the add item.
+    // Rendered as a neutral (primary) icon button, not a blue text link.
     .field-block-paste-row {
         list-style: none;
         text-align: center;
-        padding: 6px 0;
+        padding: 4px 0;
 
         a {
+            display: inline-flex;
+            align-items: center;
+            justify-content: center;
+            gap: 4px;
             font-size: 13px;
-            color: @link-color;
+            color: @text-color;
+            opacity: .7;
             text-decoration: none;
 
-            &:hover {
-                text-decoration: underline;
+            &:hover,
+            &:focus {
+                opacity: 1;
+                color: @text-color;
+                text-decoration: none;
             }
         }
     }
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 99d5472..116b079 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -117,21 +117,29 @@ class="form-control blocks-group-search"
         var CLIPBOARD_KEY = 'wnBlocksClipboard';
 
         // --- inject toolbar styles once ------------------------------------
-        // Kept here (rather than only in blocks.less) so the per-block copy/cut/
-        // paste/remove toolbar renders correctly even if the compiled CSS is stale.
+        // Kept here (rather than only in blocks.less) so the per-block toolbar
+        // (collapse / cut / paste / duplicate / config / delete) renders
+        // correctly even if the compiled CSS is stale.
         (function injectToolbarCss() {
             if (document.getElementById('wn-blocks-toolbar-css')) { return; }
             var css =
-                '.block-item-toolbar{display:inline-flex;align-items:center;gap:1px}' +
+                '.field-block-item>.repeater-item-remove.block-item-toolbar{width:auto;' +
+                'height:auto;display:inline-flex;align-items:center;gap:1px;top:4px;right:5px}' +
                 '.block-item-action{float:none;display:inline-flex;align-items:center;' +
                 'justify-content:center;width:22px;height:22px;padding:0;margin:0;border:0;' +
-                'background:none;cursor:pointer;color:#95a5a6;opacity:.7;font-size:13px;' +
+                'background:none;cursor:pointer;color:#333;opacity:.6;font-size:13px;' +
                 'line-height:1;border-radius:3px;transition:background .15s,color .15s,opacity .15s}' +
-                '.block-item-action:hover{opacity:1;background:rgba(0,0,0,.06);color:#34495e}' +
+                '.block-item-action>i{line-height:1}' +
+                '.block-item-action:hover,.block-item-action:focus{opacity:1;' +
+                'background:rgba(0,0,0,.06);color:#333;text-decoration:none}' +
                 '.block-item-action-remove:hover{color:#cc3300}' +
-                '.field-block-paste-row{list-style:none;text-align:center;padding:6px 0}' +
-                '.field-block-paste-row a{font-size:13px;color:#0072bc;text-decoration:none}' +
-                '.field-block-paste-row a:hover{text-decoration:underline}';
+                '.field-block-item.collapsed>.repeater-item-remove .repeater-item-collapse-one' +
+                '{transform:rotate(180deg)}' +
+                '.field-block-paste-row{list-style:none;text-align:center;padding:4px 0}' +
+                '.field-block-paste-row a{display:inline-flex;align-items:center;' +
+                'justify-content:center;gap:4px;font-size:13px;color:#333;opacity:.7;' +
+                'text-decoration:none}' +
+                '.field-block-paste-row a:hover{opacity:1;text-decoration:none}';
             var style = document.createElement('style');
             style.id = 'wn-blocks-toolbar-css';
             style.textContent = css;
@@ -230,15 +238,39 @@ function findAddHandler(fieldBlocks) {
             return fieldBlocks ? fieldBlocks.getAttribute('data-add-handler') : null;
         }
 
-        // Copy button
+        // Collapse chevron (moved into the toolbar, so the core delegated handler
+        // — bound to .repeater-item-collapse .repeater-item-collapse-one — no longer
+        // fires on it). Toggle the item's collapsed state ourselves; the CSS handles
+        // the rest. Document-level delegation also covers dynamically added blocks.
         document.addEventListener('click', function (e) {
-            var btn = e.target.closest('[data-block-copy]');
+            var btn = e.target.closest('.block-item-toolbar .repeater-item-collapse-one');
             if (!btn) { return; }
+            e.preventDefault();
+            e.stopPropagation();
+            var item = btn.closest('.field-repeater-item');
+            if (item) { item.classList.toggle('collapsed'); }
+        });
+
+        // Duplicate button: clone this block in place (insert a copy right after it)
+        // and also place it on the clipboard so it can be pasted into other widgets.
+        document.addEventListener('click', function (e) {
+            var btn = e.target.closest('[data-block-duplicate]');
+            if (!btn) { return; }
+            e.preventDefault();
             e.stopPropagation();
             var li = btn.closest('.field-block-item');
             if (!li) { return; }
-            ssSet(CLIPBOARD_KEY, JSON.stringify(serializeBlockItem(li)));
+            var data = serializeBlockItem(li);
+            if (!data.group) { return; }
+            ssSet(CLIPBOARD_KEY, JSON.stringify(data));
             updatePasteButtons();
+            var fieldBlocks = li.closest('.field-blocks');
+            var handler = findAddHandler(fieldBlocks);
+            if (!handler) { return; }
+            window.__pendingPaste = { fields: data.fields, afterLi: li };
+            if (typeof $ !== 'undefined') {
+                $(fieldBlocks).request(handler, { data: { _repeater_group: data.group } });
+            }
         });
 
         // Cut button: copy then trigger the existing remove button (with confirm).
diff --git a/formwidgets/blocks/partials/_block_item.php b/formwidgets/blocks/partials/_block_item.php
index 5be929c..019b1ca 100644
--- a/formwidgets/blocks/partials/_block_item.php
+++ b/formwidgets/blocks/partials/_block_item.php
@@ -10,17 +10,48 @@ class="field-repeater-item field-block-item<?php if (!count($widget->getFields()
     <?php if ($mode === 'grid'): ?>style="min-height: <?= $rowHeight ?>px"<?php endif ?>
 >
 
-    <?php if (!$this->previewMode) : ?>
-        <div class="repeater-item-remove block-item-toolbar">
-            <button type="button" class="block-item-action" aria-label="Copy block" title="Copy" data-block-copy>
-                <i class="icon-copy"></i>
-            </button>
+    <?php
+    /*
+     * All item controls live in one horizontal toolbar so they never overflow.
+     * Order: collapse, cut, paste, duplicate, [config], delete.
+     */
+    ?>
+    <div class="repeater-item-remove block-item-toolbar">
+        <?php if (count($widget->getFields()) && $mode !== 'grid'): ?>
+            <a href="javascript:;" class="repeater-item-collapse-one block-item-action" aria-label="Collapse" title="Collapse">
+                <i class="icon-chevron-up"></i>
+            </a>
+        <?php endif ?>
+
+        <?php if (!$this->previewMode): ?>
             <button type="button" class="block-item-action" aria-label="Cut block" title="Cut" data-block-cut>
                 <i class="icon-scissors"></i>
             </button>
             <button type="button" class="block-item-action" aria-label="Paste after this block" title="Paste after" data-block-paste style="display:none">
                 <i class="icon-paste"></i>
             </button>
+            <button type="button" class="block-item-action" aria-label="Duplicate block" title="Duplicate" data-block-duplicate>
+                <i class="icon-copy"></i>
+            </button>
+        <?php endif ?>
+
+        <?php if ($this->hasInspectorConfig($groupCode)): ?>
+            <a
+                href="javascript:;"
+                class="block-config block-item-action"
+                data-inspectable
+                data-inspector-title="<?= e(trans($itemTitle)) ?>"
+                data-inspector-description="<?= e(trans($itemDescription)) ?>"
+                data-inspector-config="<?= e($this->getInspectorConfig($groupCode)) ?>"
+                data-inspector-offset-y="-5"
+                data-inspector-offset-x="-15"
+            >
+                <i class="icon-cog"></i>
+                <input type="hidden" data-inspector-values name="<?= $widget->arrayName ?>[_config]" value="<?= e($groupConfig ?? '') ?>" />
+            </a>
+        <?php endif ?>
+
+        <?php if (!$this->previewMode): ?>
             <button
                 type="button"
                 class="block-item-action block-item-action-remove"
@@ -31,16 +62,8 @@ class="block-item-action block-item-action-remove"
                 data-request-confirm="<?= e(trans('backend::lang.form.action_confirm')) ?>">
                 <i class="icon-times"></i>
             </button>
-        </div>
-    <?php endif ?>
-
-    <?php if (count($widget->getFields()) && $mode !== 'grid'): ?>
-        <div class="repeater-item-collapse">
-            <a href="javascript:;" class="repeater-item-collapse-one">
-                <i class="icon-chevron-up"></i>
-            </a>
-        </div>
-    <?php endif ?>
+        <?php endif ?>
+    </div>
 
     <div class="repeater-item-collapsed-handle">&nbsp;</div>
 
@@ -53,22 +76,6 @@ class="block-item-action block-item-action-remove"
         <input type="hidden" name="<?= $widget->arrayName ?>[_group]" value="<?= $groupCode ?>" />
     </div>
 
-    <?php if ($this->hasInspectorConfig($groupCode)): ?>
-        <a
-            href="javascript:;"
-            class="block-config"
-            data-inspectable
-            data-inspector-title="<?= e(trans($itemTitle)) ?>"
-            data-inspector-description="<?= e(trans($itemDescription)) ?>"
-            data-inspector-config="<?= e($this->getInspectorConfig($groupCode)) ?>"
-            data-inspector-offset-y="-5"
-            data-inspector-offset-x="-15"
-        >
-            <i class="icon-cog"></i>
-            <input type="hidden" data-inspector-values name="<?= $widget->arrayName ?>[_config]" value="<?= e($groupConfig ?? '') ?>" />
-        </a>
-    <?php endif ?>
-
     <div class="field-repeater-form"
          data-control="formwidget"
          data-refresh-handler="<?= $this->getEventHandler('onRefresh') ?>"

From 3f5975d6fcfb94cfaa63419f6fbd58b04b985321 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 00:01:16 +0200
Subject: [PATCH 26/55] Fix toolbar overflow with !important; move paste into
 Add-Item palette

- The toolbar width override lost to core's more specific selector
  (.field-blocks ul.field-block-items > li > .repeater-item-remove), so the
  icons stayed in a 20px box and overflowed. Force width/height/display with
  !important (in both blocks.less and the inline-injected CSS) and keep the
  row on one line (white-space:nowrap, flex:0 0 auto on each action).

- Replaced the separate "Paste block" row (which looked out of place) with a
  "Paste block" entry injected at the top of the + Add New Item palette
  popover. The popover renders at body level, so the active widget is tracked
  on add-group click and used to check compatibility and target the insert.
  The popover closes itself via its own delegated handler.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  5 +-
 README.md                                     |  4 +-
 formwidgets/blocks/assets/less/blocks.less    | 39 +++-----
 formwidgets/blocks/partials/_block.php        | 91 ++++++++++++-------
 .../blocks/partials/_block_add_item.php       |  5 -
 5 files changed, 76 insertions(+), 68 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d9793e0..65fa080 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -35,8 +35,9 @@
 - **Cut / Paste / Duplicate blocks** — each block has one horizontal toolbar
   (collapse, cut, paste, duplicate, config, delete). Cut/duplicate place the
   block's field values on the clipboard (`sessionStorage`); paste inserts after
-  a block, or appends via an affordance under the Add button (for empty
-  widgets). Duplicate also clones in place. Paste affordances appear only where
+  a block, or appends via a "Paste block" entry at the top of the *+ Add New
+  Item* palette (for empty widgets). Duplicate also clones in place. Paste
+  affordances appear only where
   the copied block type is offered (respects `allow`/`ignore`/`tags`) and
   survive navigation within the same browser tab.
 
diff --git a/README.md b/README.md
index 89abb62..916a3ae 100644
--- a/README.md
+++ b/README.md
@@ -300,10 +300,10 @@ Every block has a single horizontal toolbar (top-right) with, in order:
 inspector)* and **delete**.
 
 - **Cut** — places the block's field values on the clipboard, then removes it (with the usual confirmation prompt).
-- **Paste** — appears once the clipboard holds a block. On each block it inserts the copied block immediately **after** that block; a **Paste block** affordance also appears beneath the "Add Block" button to append into an empty widget.
+- **Paste** — once the clipboard holds a block, a per-block paste icon inserts the copied block immediately **after** that block. A **Paste block** entry also appears at the top of the "Add Block" palette (the popover opened by *+ Add New Item*), which appends the copied block — handy for empty widgets.
 - **Duplicate** — clones the block in place (inserts a filled copy right after it) and also places it on the clipboard, so you can immediately paste the same block into another widget.
 
-Paste/duplicate respect the widget's `allow` / `ignore` / `tags` constraints: the paste affordance only appears where the copied block type is actually offered. The clipboard persists for the duration of the browser session (`sessionStorage`), so you can paste across different pages in the same tab.
+Paste/duplicate respect the widget's `allow` / `ignore` / `tags` constraints: the paste affordances only appear where the copied block type is actually offered. The clipboard persists for the duration of the browser session (`sessionStorage`), so you can paste across different pages in the same tab.
 
 > **Note on nested blocks:** Field values — including nested `blocks` fields, which store their content as JSON — are captured and restored correctly. Complex editor widgets (e.g. rich-text, code editors) may require an extra click to refresh their UI after paste, as those widgets listen for native `change` events.
 
diff --git a/formwidgets/blocks/assets/less/blocks.less b/formwidgets/blocks/assets/less/blocks.less
index 29d0001..9502628 100644
--- a/formwidgets/blocks/assets/less/blocks.less
+++ b/formwidgets/blocks/assets/less/blocks.less
@@ -11,17 +11,19 @@
     // Mirrored as an inline-injected <style> in the block widget partial so the
     // toolbar still renders correctly when the compiled CSS is stale.
     .field-block-item > .repeater-item-remove.block-item-toolbar {
-        width: auto;
-        height: auto;
-        display: inline-flex;
+        width: auto !important;
+        height: auto !important;
+        display: inline-flex !important;
         align-items: center;
         gap: 1px;
         top: 4px;
         right: 5px;
+        white-space: nowrap;
     }
 
     .block-item-action {
         float: none;
+        flex: 0 0 auto;
         display: inline-flex;
         align-items: center;
         justify-content: center;
@@ -65,31 +67,12 @@
         .transform(rotate(180deg));
     }
 
-    // "Paste block" affordance under the Add button when the clipboard holds a
-    // compatible block. Its own list row so it is never clipped by the add item.
-    // Rendered as a neutral (primary) icon button, not a blue text link.
-    .field-block-paste-row {
-        list-style: none;
-        text-align: center;
-        padding: 4px 0;
-
-        a {
-            display: inline-flex;
-            align-items: center;
-            justify-content: center;
-            gap: 4px;
-            font-size: 13px;
-            color: @text-color;
-            opacity: .7;
-            text-decoration: none;
-
-            &:hover,
-            &:focus {
-                opacity: 1;
-                color: @text-color;
-                text-decoration: none;
-            }
-        }
+    // "Paste block" entry injected at the top of the Add-Item palette popover
+    // when the clipboard holds a block this widget accepts. Highlighted so it
+    // stands out from the regular block list.
+    .blocks-group-item.blocks-paste-item {
+        a .title { color: @link-color; }
+        i { color: @link-color; }
     }
 
     .field-block-items {
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 116b079..fdb1b71 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -123,23 +123,22 @@ class="form-control blocks-group-search"
         (function injectToolbarCss() {
             if (document.getElementById('wn-blocks-toolbar-css')) { return; }
             var css =
-                '.field-block-item>.repeater-item-remove.block-item-toolbar{width:auto;' +
-                'height:auto;display:inline-flex;align-items:center;gap:1px;top:4px;right:5px}' +
-                '.block-item-action{float:none;display:inline-flex;align-items:center;' +
-                'justify-content:center;width:22px;height:22px;padding:0;margin:0;border:0;' +
-                'background:none;cursor:pointer;color:#333;opacity:.6;font-size:13px;' +
-                'line-height:1;border-radius:3px;transition:background .15s,color .15s,opacity .15s}' +
+                '.field-block-item>.repeater-item-remove.block-item-toolbar{width:auto!important;' +
+                'height:auto!important;display:inline-flex!important;align-items:center;' +
+                'gap:1px;top:4px;right:5px;white-space:nowrap}' +
+                '.block-item-action{float:none;flex:0 0 auto;display:inline-flex;' +
+                'align-items:center;justify-content:center;width:22px;height:22px;padding:0;' +
+                'margin:0;border:0;background:none;cursor:pointer;color:#333;opacity:.6;' +
+                'font-size:13px;line-height:1;border-radius:3px;' +
+                'transition:background .15s,color .15s,opacity .15s}' +
                 '.block-item-action>i{line-height:1}' +
                 '.block-item-action:hover,.block-item-action:focus{opacity:1;' +
                 'background:rgba(0,0,0,.06);color:#333;text-decoration:none}' +
                 '.block-item-action-remove:hover{color:#cc3300}' +
                 '.field-block-item.collapsed>.repeater-item-remove .repeater-item-collapse-one' +
                 '{transform:rotate(180deg)}' +
-                '.field-block-paste-row{list-style:none;text-align:center;padding:4px 0}' +
-                '.field-block-paste-row a{display:inline-flex;align-items:center;' +
-                'justify-content:center;gap:4px;font-size:13px;color:#333;opacity:.7;' +
-                'text-decoration:none}' +
-                '.field-block-paste-row a:hover{opacity:1;text-decoration:none}';
+                '.blocks-group-item.blocks-paste-item a .title{color:#0072bc}' +
+                '.blocks-group-item.blocks-paste-item i{color:#0072bc}';
             var style = document.createElement('style');
             style.id = 'wn-blocks-toolbar-css';
             style.textContent = css;
@@ -212,24 +211,14 @@ function blockTypeAvailable(fieldBlocks, group) {
         }
 
         // Show/hide paste affordances based on clipboard state and widget availability.
-        // Per-item paste buttons toggle themselves; the append link toggles its own
-        // <li> row (so it sits on its own line under the Add button, never clipped).
-        function setPasteVisible(el, visible) {
-            if (el) { el.style.display = visible ? '' : 'none'; }
-        }
+        // Per-item paste buttons show only when the clipboard holds a block this
+        // widget accepts. (The append case is handled in the Add-Item palette.)
         function updatePasteButtons() {
             var cb = getClipboard();
             var ok = cb && cb.group;
-
             document.querySelectorAll('[data-block-paste]').forEach(function (btn) {
                 var fieldBlocks = btn.closest('.field-blocks');
-                setPasteVisible(btn, ok && blockTypeAvailable(fieldBlocks, cb.group));
-            });
-
-            document.querySelectorAll('[data-block-paste-append]').forEach(function (link) {
-                var fieldBlocks = link.closest('.field-blocks');
-                var row = link.closest('[data-block-paste-append-row]') || link;
-                setPasteVisible(row, ok && blockTypeAvailable(fieldBlocks, cb.group));
+                btn.style.display = (ok && blockTypeAvailable(fieldBlocks, cb.group)) ? '' : 'none';
             });
         }
 
@@ -286,18 +275,47 @@ function findAddHandler(fieldBlocks) {
             if (removeBtn) { removeBtn.click(); }
         });
 
-        // Paste-append button in the add-item row — appends the copied block at the end.
+        // Remember which widget's Add-Item palette is open, so a paste entry
+        // injected into the (body-level) popover knows where to insert.
         document.addEventListener('click', function (e) {
-            var btn = e.target.closest('[data-block-paste-append]');
-            if (!btn) { return; }
+            var add = e.target.closest('[data-repeater-add-group]');
+            if (add) { window.__activeBlocksWidget = add.closest('.field-blocks'); }
+        });
+
+        // Inject a "Paste block" entry at the top of an Add-Item palette grid when
+        // the clipboard holds a block this widget accepts. The popover is rendered
+        // at body level, so compatibility is checked against the active widget.
+        function injectPalettePaste(grid) {
+            var old = grid.querySelector('.blocks-paste-item');
+            if (old) { old.remove(); }
+
+            var cb = getClipboard();
+            var fieldBlocks = window.__activeBlocksWidget;
+            if (!cb || !cb.group || !blockTypeAvailable(fieldBlocks, cb.group)) { return; }
+
+            var item = document.createElement('div');
+            item.className = 'blocks-group-item blocks-paste-item';
+            item.innerHTML =
+                '<a href="javascript:;" data-block-paste-palette>' +
+                '<i class="icon-paste"></i>' +
+                '<div><span class="title">Paste block</span>' +
+                '<span class="description">Insert the copied block</span></div></a>';
+            grid.insertBefore(item, grid.firstChild);
+        }
+
+        // Click on the injected palette paste entry — append into the active widget.
+        document.addEventListener('click', function (e) {
+            var a = e.target.closest('[data-block-paste-palette]');
+            if (!a) { return; }
             e.preventDefault();
             e.stopPropagation();
             var cb = getClipboard();
-            if (!cb || !cb.group) { return; }
-            var fieldBlocks = btn.closest('.field-blocks');
+            var fieldBlocks = window.__activeBlocksWidget;
+            if (!cb || !cb.group || !fieldBlocks) { return; }
             var handler = findAddHandler(fieldBlocks);
             if (!handler) { return; }
-            // No afterLi — the MutationObserver will fill the block where onAddItem appends it.
+            // No afterLi — the MutationObserver fills the block where onAddItem appends it.
+            // The popover closes itself (its own delegated 'click a' handler).
             window.__pendingPaste = { fields: cb.fields, afterLi: null };
             if (typeof $ !== 'undefined') {
                 $(fieldBlocks).request(handler, { data: { _repeater_group: cb.group } });
@@ -416,8 +434,19 @@ function applyRecent() {
                 });
         }
 
+        // Add the "Paste block" entry to any open Add-Item palette grid. Runs after
+        // applyRecent so it ends up first. Idempotent (removes any prior entry).
+        function applyPalettePaste() {
+            document.querySelectorAll('.blocks-group-grid').forEach(injectPalettePaste);
+        }
+
         // --- shared init + observer ----------------------------------------
-        function runAll() { initSections(); applyRecent(); updatePasteButtons(); }
+        function runAll() {
+            initSections();
+            applyRecent();
+            applyPalettePaste();
+            updatePasteButtons();
+        }
 
         runAll();
 
diff --git a/formwidgets/blocks/partials/_block_add_item.php b/formwidgets/blocks/partials/_block_add_item.php
index d597b3e..c93a13e 100644
--- a/formwidgets/blocks/partials/_block_add_item.php
+++ b/formwidgets/blocks/partials/_block_add_item.php
@@ -12,9 +12,4 @@ class="wn-icon-plus"
             <?= e(trans($prompt)) ?>
         </a>
     </li>
-    <li class="field-block-paste-row" data-block-paste-append-row style="display:none">
-        <a href="javascript:;" data-block-paste-append>
-            <i class="icon-paste"></i> Paste block
-        </a>
-    </li>
 <?php endif ?>

From d10d728d4efb6db77f84476f9182a0a5f089fc6d Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 00:09:26 +0200
Subject: [PATCH 27/55] Add Copy button; stop "Add new item" rows accumulating

- Re-added a Copy button (non-destructive: clipboard only) alongside
  Duplicate (clone in place). Toolbar order is now collapse, copy, cut,
  paste, duplicate, [config], delete, using distinct icons (copy vs clone).

- Fixed the accumulating "+ Add New Item" rows. onAddItem returns an empty
  add-item plus a fresh one; the core popover flow removes the empty
  leftovers on ajaxUpdateComplete, but our direct paste/duplicate requests
  bypassed that handler so the empties piled up. Added a requestAdd() helper
  that runs the same cleanup after each direct request, and runAll() now also
  sweeps stray empty add-items so any existing accumulation self-heals.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                | 17 ++---
 README.md                                   |  5 +-
 formwidgets/blocks/partials/_block.php      | 70 +++++++++++++--------
 formwidgets/blocks/partials/_block_item.php |  5 +-
 4 files changed, 61 insertions(+), 36 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 65fa080..6c13081 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -32,14 +32,15 @@
 ### Editor UX
 - **Recently used blocks** are pinned to the top of the "add block" palette
   (tracked in `localStorage`, most-recent first).
-- **Cut / Paste / Duplicate blocks** — each block has one horizontal toolbar
-  (collapse, cut, paste, duplicate, config, delete). Cut/duplicate place the
-  block's field values on the clipboard (`sessionStorage`); paste inserts after
-  a block, or appends via a "Paste block" entry at the top of the *+ Add New
-  Item* palette (for empty widgets). Duplicate also clones in place. Paste
-  affordances appear only where
-  the copied block type is offered (respects `allow`/`ignore`/`tags`) and
-  survive navigation within the same browser tab.
+- **Copy / Cut / Paste / Duplicate blocks** — each block has one horizontal
+  toolbar (collapse, copy, cut, paste, duplicate, config, delete). Copy/cut/
+  duplicate place the block's field values on the clipboard (`sessionStorage`);
+  paste inserts after a block, or appends via a "Paste block" entry at the top
+  of the *+ Add New Item* palette (for empty widgets). Duplicate also clones in
+  place. Paste affordances appear only where the copied block type is offered
+  (respects `allow`/`ignore`/`tags`) and survive navigation within the same
+  browser tab. Direct add/paste/duplicate requests run the same empty-add-item
+  cleanup as the core popover flow, so "Add new item" rows no longer pile up.
 
 ### Tests
 - `BlockManagerTest`: include merging, block-overrides-include precedence,
diff --git a/README.md b/README.md
index 916a3ae..e1a4885 100644
--- a/README.md
+++ b/README.md
@@ -296,9 +296,10 @@ When adding a block from the palette, the blocks you use most recently are pinne
 ## Cut, paste and duplicate blocks
 
 Every block has a single horizontal toolbar (top-right) with, in order:
-**collapse**, **cut**, **paste**, **duplicate**, *(config, if the block has an
-inspector)* and **delete**.
+**collapse**, **copy**, **cut**, **paste**, **duplicate**, *(config, if the
+block has an inspector)* and **delete**.
 
+- **Copy** — places the block's field values on the clipboard (non-destructive).
 - **Cut** — places the block's field values on the clipboard, then removes it (with the usual confirmation prompt).
 - **Paste** — once the clipboard holds a block, a per-block paste icon inserts the copied block immediately **after** that block. A **Paste block** entry also appears at the top of the "Add Block" palette (the popover opened by *+ Add New Item*), which appends the copied block — handy for empty widgets.
 - **Duplicate** — clones the block in place (inserts a filled copy right after it) and also places it on the clipboard, so you can immediately paste the same block into another widget.
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index fdb1b71..4d73956 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -227,6 +227,30 @@ function findAddHandler(fieldBlocks) {
             return fieldBlocks ? fieldBlocks.getAttribute('data-add-handler') : null;
         }
 
+        // onAddItem returns an empty add-item plus a fresh one; the core popover
+        // flow removes the empty leftovers afterwards, but our direct requests
+        // bypass that — so replicate the cleanup ourselves to avoid stray
+        // "Add new item" buttons piling up.
+        function cleanupAddItems(fieldBlocks) {
+            if (typeof $ === 'undefined' || !fieldBlocks) { return; }
+            $(fieldBlocks).find('.field-repeater-items > .field-repeater-add-item')
+                .each(function () {
+                    if (this.children.length === 0) { $(this).remove(); }
+                });
+        }
+
+        // Fire onAddItem on a widget, with the empty-add-item cleanup applied once
+        // the AJAX update has been applied.
+        function requestAdd(fieldBlocks, group, fields, afterLi) {
+            var handler = findAddHandler(fieldBlocks);
+            if (!handler || typeof $ === 'undefined') { return; }
+            window.__pendingPaste = { fields: fields, afterLi: afterLi || null };
+            $(window).one('ajaxUpdateComplete', function () {
+                cleanupAddItems(fieldBlocks);
+            });
+            $(fieldBlocks).request(handler, { data: { _repeater_group: group } });
+        }
+
         // Collapse chevron (moved into the toolbar, so the core delegated handler
         // — bound to .repeater-item-collapse .repeater-item-collapse-one — no longer
         // fires on it). Toggle the item's collapsed state ourselves; the CSS handles
@@ -240,6 +264,18 @@ function findAddHandler(fieldBlocks) {
             if (item) { item.classList.toggle('collapsed'); }
         });
 
+        // Copy button: place the block's field values on the clipboard (non-destructive).
+        document.addEventListener('click', function (e) {
+            var btn = e.target.closest('[data-block-copy]');
+            if (!btn) { return; }
+            e.preventDefault();
+            e.stopPropagation();
+            var li = btn.closest('.field-block-item');
+            if (!li) { return; }
+            ssSet(CLIPBOARD_KEY, JSON.stringify(serializeBlockItem(li)));
+            updatePasteButtons();
+        });
+
         // Duplicate button: clone this block in place (insert a copy right after it)
         // and also place it on the clipboard so it can be pasted into other widgets.
         document.addEventListener('click', function (e) {
@@ -253,13 +289,7 @@ function findAddHandler(fieldBlocks) {
             if (!data.group) { return; }
             ssSet(CLIPBOARD_KEY, JSON.stringify(data));
             updatePasteButtons();
-            var fieldBlocks = li.closest('.field-blocks');
-            var handler = findAddHandler(fieldBlocks);
-            if (!handler) { return; }
-            window.__pendingPaste = { fields: data.fields, afterLi: li };
-            if (typeof $ !== 'undefined') {
-                $(fieldBlocks).request(handler, { data: { _repeater_group: data.group } });
-            }
+            requestAdd(li.closest('.field-blocks'), data.group, data.fields, li);
         });
 
         // Cut button: copy then trigger the existing remove button (with confirm).
@@ -312,19 +342,13 @@ function injectPalettePaste(grid) {
             var cb = getClipboard();
             var fieldBlocks = window.__activeBlocksWidget;
             if (!cb || !cb.group || !fieldBlocks) { return; }
-            var handler = findAddHandler(fieldBlocks);
-            if (!handler) { return; }
-            // No afterLi — the MutationObserver fills the block where onAddItem appends it.
-            // The popover closes itself (its own delegated 'click a' handler).
-            window.__pendingPaste = { fields: cb.fields, afterLi: null };
-            if (typeof $ !== 'undefined') {
-                $(fieldBlocks).request(handler, { data: { _repeater_group: cb.group } });
-            }
+            // No afterLi — append at the end. The popover closes itself (its own
+            // delegated 'click a' handler).
+            requestAdd(fieldBlocks, cb.group, cb.fields, null);
         });
 
-        // Paste button on each block item — inserts the copied block immediately after.
-        // Reads the AJAX handler name from the palette template (no popover needed),
-        // fires onAddItem directly, then the MutationObserver moves the new <li> into place.
+        // Paste button on each block item — inserts the copied block immediately
+        // after it. Fires onAddItem; the MutationObserver moves the new <li> into place.
         document.addEventListener('click', function (e) {
             var btn = e.target.closest('[data-block-paste]');
             if (!btn || !btn.closest('.field-block-item')) { return; }
@@ -333,13 +357,7 @@ function injectPalettePaste(grid) {
             var cb = getClipboard();
             if (!cb || !cb.group) { return; }
             var li = btn.closest('.field-block-item');
-            var fieldBlocks = li.closest('.field-blocks');
-            var handler = findAddHandler(fieldBlocks);
-            if (!handler) { return; }
-            window.__pendingPaste = { fields: cb.fields, afterLi: li };
-            if (typeof $ !== 'undefined') {
-                $(fieldBlocks).request(handler, { data: { _repeater_group: cb.group } });
-            }
+            requestAdd(li.closest('.field-blocks'), cb.group, cb.fields, li);
         });
 
         // --- collapsible sections ------------------------------------------
@@ -446,6 +464,8 @@ function runAll() {
             applyRecent();
             applyPalettePaste();
             updatePasteButtons();
+            // Self-heal any empty "add new item" rows left by direct add requests.
+            document.querySelectorAll('.field-blocks').forEach(cleanupAddItems);
         }
 
         runAll();
diff --git a/formwidgets/blocks/partials/_block_item.php b/formwidgets/blocks/partials/_block_item.php
index 019b1ca..78d1466 100644
--- a/formwidgets/blocks/partials/_block_item.php
+++ b/formwidgets/blocks/partials/_block_item.php
@@ -24,6 +24,9 @@ class="field-repeater-item field-block-item<?php if (!count($widget->getFields()
         <?php endif ?>
 
         <?php if (!$this->previewMode): ?>
+            <button type="button" class="block-item-action" aria-label="Copy block" title="Copy" data-block-copy>
+                <i class="icon-copy"></i>
+            </button>
             <button type="button" class="block-item-action" aria-label="Cut block" title="Cut" data-block-cut>
                 <i class="icon-scissors"></i>
             </button>
@@ -31,7 +34,7 @@ class="field-repeater-item field-block-item<?php if (!count($widget->getFields()
                 <i class="icon-paste"></i>
             </button>
             <button type="button" class="block-item-action" aria-label="Duplicate block" title="Duplicate" data-block-duplicate>
-                <i class="icon-copy"></i>
+                <i class="icon-clone"></i>
             </button>
         <?php endif ?>
 

From 1363950a7698123374a905c1140c247a449e155b Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 00:12:49 +0200
Subject: [PATCH 28/55] Fix palette "Paste block" by clicking the real add link

The palette paste entry called a hand-rolled add request that didn't take
effect. Replace it with clicking the actual block-add link inside the same
popover grid, after setting the pending-paste fields. This reuses core's
proven add flow (form context, load indicator, empty-add-item cleanup); the
MutationObserver then fills the new block from the clipboard.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 formwidgets/blocks/partials/_block.php | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 4d73956..49c2192 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -333,18 +333,25 @@ function injectPalettePaste(grid) {
             grid.insertBefore(item, grid.firstChild);
         }
 
-        // Click on the injected palette paste entry — append into the active widget.
+        // Click on the injected palette paste entry. Rather than re-implement the
+        // add request, set the pending fields and click the real block-add link in
+        // the same popover grid — that reuses core's proven add flow (correct form
+        // context, load indicator, and the empty-add-item cleanup). The observer
+        // then fills the new block from the clipboard.
         document.addEventListener('click', function (e) {
             var a = e.target.closest('[data-block-paste-palette]');
             if (!a) { return; }
             e.preventDefault();
             e.stopPropagation();
             var cb = getClipboard();
-            var fieldBlocks = window.__activeBlocksWidget;
-            if (!cb || !cb.group || !fieldBlocks) { return; }
-            // No afterLi — append at the end. The popover closes itself (its own
-            // delegated 'click a' handler).
-            requestAdd(fieldBlocks, cb.group, cb.fields, null);
+            if (!cb || !cb.group) { return; }
+            var grid = a.closest('.blocks-group-grid');
+            var addLink = grid && grid.querySelector(
+                'a[data-block-code="' + cb.group + '"][data-repeater-add]'
+            );
+            if (!addLink) { return; }
+            window.__pendingPaste = { fields: cb.fields, afterLi: null };
+            addLink.click();
         });
 
         // Paste button on each block item — inserts the copied block immediately

From 83c08e94be29eb4bfe51fa515873a78d31c26c23 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 00:35:35 +0200
Subject: [PATCH 29/55] Fix palette paste: fire request on the link instead of
 synthetic click

addLink.click() did not reliably trigger Winter's AJAX, so palette "Paste
block" did nothing. Call $(addLink).request(handler, {data}) directly,
reusing the link's own onAddItem handler and its data('request-form')
context (the link lives in the body-level popover, outside the form, so
that data binding is what makes the add work). Also runs the empty-add-item
cleanup on completion.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 formwidgets/blocks/partials/_block.php | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 49c2192..0192bda 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -333,25 +333,33 @@ function injectPalettePaste(grid) {
             grid.insertBefore(item, grid.firstChild);
         }
 
-        // Click on the injected palette paste entry. Rather than re-implement the
-        // add request, set the pending fields and click the real block-add link in
-        // the same popover grid — that reuses core's proven add flow (correct form
-        // context, load indicator, and the empty-add-item cleanup). The observer
-        // then fills the new block from the clipboard.
+        // Click on the injected palette paste entry. Set the pending fields, then
+        // fire the AJAX request on the real block-add link in the same popover grid
+        // — using $(link).request() (not a synthetic DOM click, which doesn't
+        // reliably trigger the handler). That link already carries the onAddItem
+        // handler, the _repeater_group data, and the form context, so this reuses
+        // core's proven add flow; the observer then fills the new block.
         document.addEventListener('click', function (e) {
             var a = e.target.closest('[data-block-paste-palette]');
             if (!a) { return; }
             e.preventDefault();
             e.stopPropagation();
             var cb = getClipboard();
-            if (!cb || !cb.group) { return; }
+            if (!cb || !cb.group || typeof $ === 'undefined') { return; }
             var grid = a.closest('.blocks-group-grid');
             var addLink = grid && grid.querySelector(
                 'a[data-block-code="' + cb.group + '"][data-repeater-add]'
             );
             if (!addLink) { return; }
             window.__pendingPaste = { fields: cb.fields, afterLi: null };
-            addLink.click();
+            $(window).one('ajaxUpdateComplete', function () {
+                cleanupAddItems(window.__activeBlocksWidget);
+            });
+            // Use the link's own handler + form context (it lives in the popover,
+            // outside the form, so its data('request-form') is what makes it work).
+            $(addLink).request(addLink.getAttribute('data-request'), {
+                data: { _repeater_group: cb.group }
+            });
         });
 
         // Paste button on each block item — inserts the copied block immediately

From e70c80a58d82347820cf8ed84692eb8263e85d38 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 06:42:17 +0200
Subject: [PATCH 30/55] Fix copy/paste: resolve infinite MutationObserver loop
 and show paste affordances
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Palette paste: replace cloneNode+replaceChild (which triggered MutationObserver
  → runAll → injectPalettePaste → another clone → infinite loop) with
  removeEventListener/addEventListener on the existing button element
- Palette paste button moved to search bar (outside scrollpad) as a plain
  <button> so click events are not intercepted by the scrollpad/filelist controls
- updatePasteButtons: add has-paste class to field-block-item so the toolbar is
  dimly visible (opacity 0.45) when clipboard holds a compatible block, making
  the paste icon discoverable without hovering
- blocks.less: add flex layout for search container, remove unused blocks-paste-item rule

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 formwidgets/blocks/assets/less/blocks.less |  18 ++--
 formwidgets/blocks/partials/_block.php     | 101 +++++++++++----------
 2 files changed, 63 insertions(+), 56 deletions(-)

diff --git a/formwidgets/blocks/assets/less/blocks.less b/formwidgets/blocks/assets/less/blocks.less
index 9502628..15d57a1 100644
--- a/formwidgets/blocks/assets/less/blocks.less
+++ b/formwidgets/blocks/assets/less/blocks.less
@@ -67,14 +67,6 @@
         .transform(rotate(180deg));
     }
 
-    // "Paste block" entry injected at the top of the Add-Item palette popover
-    // when the clipboard holds a block this widget accepts. Highlighted so it
-    // stands out from the regular block list.
-    .blocks-group-item.blocks-paste-item {
-        a .title { color: @link-color; }
-        i { color: @link-color; }
-    }
-
     .field-block-items {
         counter-reset: repeater-index-counter;
     }
@@ -510,13 +502,23 @@
 //
 
 .blocks-group-search-container {
+    display: flex;
+    align-items: center;
+    gap: 8px;
     padding: 10px 15px;
     border-bottom: 1px solid #e0e0e0;
 
     > div {
+        flex: 1;
+        min-width: 0;
         position: relative;
     }
 
+    .blocks-palette-paste-btn {
+        flex-shrink: 0;
+        white-space: nowrap;
+    }
+
     .icon-search {
         position: absolute;
         left: 10px;
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 0192bda..4460831 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -57,6 +57,9 @@ class="form-control blocks-group-search"
                     <i class="icon-close"></i>
                 </button>
             </div>
+            <button type="button" class="btn btn-default btn-sm blocks-palette-paste-btn" style="display:none">
+                <i class="icon-paste"></i> Paste
+            </button>
         </div>
         <div class="blocks-group-no-results">
             No items found
@@ -137,8 +140,14 @@ class="form-control blocks-group-search"
                 '.block-item-action-remove:hover{color:#cc3300}' +
                 '.field-block-item.collapsed>.repeater-item-remove .repeater-item-collapse-one' +
                 '{transform:rotate(180deg)}' +
-                '.blocks-group-item.blocks-paste-item a .title{color:#0072bc}' +
-                '.blocks-group-item.blocks-paste-item i{color:#0072bc}';
+                // Dim-show the toolbar on blocks where clipboard paste is available so the
+                // user sees the paste icon without having to hover. Full opacity on hover.
+                '.field-block-item.has-paste>.repeater-item-remove.block-item-toolbar{opacity:.45!important}' +
+                '.field-block-item.has-paste.hover>.repeater-item-remove.block-item-toolbar,' +
+                '.field-block-item.has-paste.focus>.repeater-item-remove.block-item-toolbar{opacity:1!important}' +
+                '.blocks-group-search-container{display:flex;align-items:center;gap:8px}' +
+                '.blocks-group-search-container>div{flex:1;min-width:0}' +
+                '.blocks-palette-paste-btn{flex-shrink:0;white-space:nowrap}';
             var style = document.createElement('style');
             style.id = 'wn-blocks-toolbar-css';
             style.textContent = css;
@@ -218,7 +227,11 @@ function updatePasteButtons() {
             var ok = cb && cb.group;
             document.querySelectorAll('[data-block-paste]').forEach(function (btn) {
                 var fieldBlocks = btn.closest('.field-blocks');
-                btn.style.display = (ok && blockTypeAvailable(fieldBlocks, cb.group)) ? '' : 'none';
+                var show = ok && blockTypeAvailable(fieldBlocks, cb.group);
+                btn.style.display = show ? '' : 'none';
+                // Add/remove has-paste on the parent li so the CSS can dim-show the toolbar.
+                var li = btn.closest('.field-block-item');
+                if (li) { li.classList.toggle('has-paste', !!show); }
             });
         }
 
@@ -312,55 +325,47 @@ function requestAdd(fieldBlocks, group, fields, afterLi) {
             if (add) { window.__activeBlocksWidget = add.closest('.field-blocks'); }
         });
 
-        // Inject a "Paste block" entry at the top of an Add-Item palette grid when
-        // the clipboard holds a block this widget accepts. The popover is rendered
-        // at body level, so compatibility is checked against the active widget.
+        // Show/hide the "Paste" button in the search bar of the Add-Item palette.
+        // The button lives in .blocks-group-search-container (outside the scrollpad)
+        // so it reliably receives clicks. fieldBlocks is captured when the palette
+        // opens (window.__activeBlocksWidget), not at click time.
         function injectPalettePaste(grid) {
-            var old = grid.querySelector('.blocks-paste-item');
-            if (old) { old.remove(); }
-
             var cb = getClipboard();
             var fieldBlocks = window.__activeBlocksWidget;
-            if (!cb || !cb.group || !blockTypeAvailable(fieldBlocks, cb.group)) { return; }
-
-            var item = document.createElement('div');
-            item.className = 'blocks-group-item blocks-paste-item';
-            item.innerHTML =
-                '<a href="javascript:;" data-block-paste-palette>' +
-                '<i class="icon-paste"></i>' +
-                '<div><span class="title">Paste block</span>' +
-                '<span class="description">Insert the copied block</span></div></a>';
-            grid.insertBefore(item, grid.firstChild);
-        }
 
-        // Click on the injected palette paste entry. Set the pending fields, then
-        // fire the AJAX request on the real block-add link in the same popover grid
-        // — using $(link).request() (not a synthetic DOM click, which doesn't
-        // reliably trigger the handler). That link already carries the onAddItem
-        // handler, the _repeater_group data, and the form context, so this reuses
-        // core's proven add flow; the observer then fills the new block.
-        document.addEventListener('click', function (e) {
-            var a = e.target.closest('[data-block-paste-palette]');
-            if (!a) { return; }
-            e.preventDefault();
-            e.stopPropagation();
-            var cb = getClipboard();
-            if (!cb || !cb.group || typeof $ === 'undefined') { return; }
-            var grid = a.closest('.blocks-group-grid');
-            var addLink = grid && grid.querySelector(
-                'a[data-block-code="' + cb.group + '"][data-repeater-add]'
-            );
-            if (!addLink) { return; }
-            window.__pendingPaste = { fields: cb.fields, afterLi: null };
-            $(window).one('ajaxUpdateComplete', function () {
-                cleanupAddItems(window.__activeBlocksWidget);
-            });
-            // Use the link's own handler + form context (it lives in the popover,
-            // outside the form, so its data('request-form') is what makes it work).
-            $(addLink).request(addLink.getAttribute('data-request'), {
-                data: { _repeater_group: cb.group }
-            });
-        });
+            // Find the paste button that sits in the search bar of this palette.
+            var container = grid.closest('.blocks-group-items-container');
+            var searchContainer = container && container.previousElementSibling;
+            while (searchContainer && !searchContainer.classList.contains('blocks-group-search-container')) {
+                searchContainer = searchContainer.previousElementSibling;
+            }
+            var pasteBtn = searchContainer && searchContainer.querySelector('.blocks-palette-paste-btn');
+            if (!pasteBtn) { return; }
+
+            var show = !!(cb && cb.group && blockTypeAvailable(fieldBlocks, cb.group));
+            pasteBtn.style.display = show ? '' : 'none';
+            if (!show) { return; }
+
+            // Re-bind click each time the palette opens (fresh captured values).
+            var capturedFieldBlocks = fieldBlocks;
+            var capturedGroup = cb.group;
+            var capturedFields = cb.fields;
+
+            // Remove any previously-bound listener without cloning (cloneNode causes a
+            // DOM mutation that re-triggers the MutationObserver → infinite loop).
+            if (pasteBtn._pasteHandler) {
+                pasteBtn.removeEventListener('click', pasteBtn._pasteHandler);
+            }
+            pasteBtn._pasteHandler = function () {
+                window.__pendingPaste = { fields: capturedFields, afterLi: null };
+                $(window).one('ajaxUpdateComplete', function () {
+                    cleanupAddItems(capturedFieldBlocks);
+                });
+                requestAdd(capturedFieldBlocks, capturedGroup, capturedFields, null);
+            };
+            pasteBtn.addEventListener('click', pasteBtn._pasteHandler);
+            pasteBtn.style.display = '';
+        }
 
         // Paste button on each block item — inserts the copied block immediately
         // after it. Fires onAddItem; the MutationObserver moves the new <li> into place.

From dbfe9a5176e07c73ea9be2234197e11dd68e7b97 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 06:45:30 +0200
Subject: [PATCH 31/55] Replace search-bar paste button with grid pseudo-block
 entry
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Inject "Paste block" as a first-class grid item that looks identical to real
block entries. The infinite-loop fix: check data-paste-group on the existing
item before touching the DOM — if the group matches, return immediately, so
the MutationObserver loop terminates after a single injection.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 formwidgets/blocks/assets/less/blocks.less | 10 ----
 formwidgets/blocks/partials/_block.php     | 55 ++++++++++------------
 2 files changed, 25 insertions(+), 40 deletions(-)

diff --git a/formwidgets/blocks/assets/less/blocks.less b/formwidgets/blocks/assets/less/blocks.less
index 15d57a1..386aaf8 100644
--- a/formwidgets/blocks/assets/less/blocks.less
+++ b/formwidgets/blocks/assets/less/blocks.less
@@ -502,23 +502,13 @@
 //
 
 .blocks-group-search-container {
-    display: flex;
-    align-items: center;
-    gap: 8px;
     padding: 10px 15px;
     border-bottom: 1px solid #e0e0e0;
 
     > div {
-        flex: 1;
-        min-width: 0;
         position: relative;
     }
 
-    .blocks-palette-paste-btn {
-        flex-shrink: 0;
-        white-space: nowrap;
-    }
-
     .icon-search {
         position: absolute;
         left: 10px;
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 4460831..7ef0bcc 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -57,9 +57,6 @@ class="form-control blocks-group-search"
                     <i class="icon-close"></i>
                 </button>
             </div>
-            <button type="button" class="btn btn-default btn-sm blocks-palette-paste-btn" style="display:none">
-                <i class="icon-paste"></i> Paste
-            </button>
         </div>
         <div class="blocks-group-no-results">
             No items found
@@ -145,9 +142,7 @@ class="form-control blocks-group-search"
                 '.field-block-item.has-paste>.repeater-item-remove.block-item-toolbar{opacity:.45!important}' +
                 '.field-block-item.has-paste.hover>.repeater-item-remove.block-item-toolbar,' +
                 '.field-block-item.has-paste.focus>.repeater-item-remove.block-item-toolbar{opacity:1!important}' +
-                '.blocks-group-search-container{display:flex;align-items:center;gap:8px}' +
-                '.blocks-group-search-container>div{flex:1;min-width:0}' +
-                '.blocks-palette-paste-btn{flex-shrink:0;white-space:nowrap}';
+                '';
             var style = document.createElement('style');
             style.id = 'wn-blocks-toolbar-css';
             style.textContent = css;
@@ -325,46 +320,46 @@ function requestAdd(fieldBlocks, group, fields, afterLi) {
             if (add) { window.__activeBlocksWidget = add.closest('.field-blocks'); }
         });
 
-        // Show/hide the "Paste" button in the search bar of the Add-Item palette.
-        // The button lives in .blocks-group-search-container (outside the scrollpad)
-        // so it reliably receives clicks. fieldBlocks is captured when the palette
-        // opens (window.__activeBlocksWidget), not at click time.
+        // Inject a "Paste block" entry at the top of the Add-Item palette grid.
+        // Looks identical to real block items. Injected once per palette open;
+        // subsequent MutationObserver calls hit the early-exit guard (matching
+        // data-paste-group) and make no DOM changes, so the observer loop stops.
         function injectPalettePaste(grid) {
             var cb = getClipboard();
             var fieldBlocks = window.__activeBlocksWidget;
+            var show = !!(cb && cb.group && blockTypeAvailable(fieldBlocks, cb.group));
 
-            // Find the paste button that sits in the search bar of this palette.
-            var container = grid.closest('.blocks-group-items-container');
-            var searchContainer = container && container.previousElementSibling;
-            while (searchContainer && !searchContainer.classList.contains('blocks-group-search-container')) {
-                searchContainer = searchContainer.previousElementSibling;
+            var existing = grid.querySelector('.blocks-paste-item');
+            if (existing) {
+                // Already injected with the right group — nothing to do.
+                if (show && existing.dataset.pasteGroup === cb.group) { return; }
+                existing.remove();
             }
-            var pasteBtn = searchContainer && searchContainer.querySelector('.blocks-palette-paste-btn');
-            if (!pasteBtn) { return; }
-
-            var show = !!(cb && cb.group && blockTypeAvailable(fieldBlocks, cb.group));
-            pasteBtn.style.display = show ? '' : 'none';
             if (!show) { return; }
 
-            // Re-bind click each time the palette opens (fresh captured values).
             var capturedFieldBlocks = fieldBlocks;
             var capturedGroup = cb.group;
             var capturedFields = cb.fields;
 
-            // Remove any previously-bound listener without cloning (cloneNode causes a
-            // DOM mutation that re-triggers the MutationObserver → infinite loop).
-            if (pasteBtn._pasteHandler) {
-                pasteBtn.removeEventListener('click', pasteBtn._pasteHandler);
-            }
-            pasteBtn._pasteHandler = function () {
+            var a = document.createElement('a');
+            a.href = 'javascript:;';
+            a.innerHTML =
+                '<i class="icon-paste"></i>' +
+                '<div><span class="title">Paste block</span>' +
+                '<span class="description">Insert copied block</span></div>';
+            a.addEventListener('click', function () {
                 window.__pendingPaste = { fields: capturedFields, afterLi: null };
                 $(window).one('ajaxUpdateComplete', function () {
                     cleanupAddItems(capturedFieldBlocks);
                 });
                 requestAdd(capturedFieldBlocks, capturedGroup, capturedFields, null);
-            };
-            pasteBtn.addEventListener('click', pasteBtn._pasteHandler);
-            pasteBtn.style.display = '';
+            });
+
+            var item = document.createElement('div');
+            item.className = 'blocks-group-item blocks-paste-item';
+            item.dataset.pasteGroup = capturedGroup;
+            item.appendChild(a);
+            grid.insertBefore(item, grid.firstChild);
         }
 
         // Paste button on each block item — inserts the copied block immediately

From b6937e6c881f4858dece5b2431f675f4e4c1f199 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 06:50:02 +0200
Subject: [PATCH 32/55] docs: clarify Duplicate vs Paste after in README

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 README.md | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index e1a4885..4524370 100644
--- a/README.md
+++ b/README.md
@@ -301,8 +301,17 @@ block has an inspector)* and **delete**.
 
 - **Copy** — places the block's field values on the clipboard (non-destructive).
 - **Cut** — places the block's field values on the clipboard, then removes it (with the usual confirmation prompt).
-- **Paste** — once the clipboard holds a block, a per-block paste icon inserts the copied block immediately **after** that block. A **Paste block** entry also appears at the top of the "Add Block" palette (the popover opened by *+ Add New Item*), which appends the copied block — handy for empty widgets.
-- **Duplicate** — clones the block in place (inserts a filled copy right after it) and also places it on the clipboard, so you can immediately paste the same block into another widget.
+- **Paste after** — once the clipboard holds a block, a per-block paste icon inserts the copied block immediately **after** that block. A **Paste block** entry also appears at the top of the "Add Block" palette (the popover opened by *+ Add New Item*), which is handy for inserting into an empty widget or at the end of a list.
+- **Duplicate** — one-step clone: serialises the current block, saves it to the clipboard, and immediately inserts a filled copy right after it.
+
+**Duplicate vs. Paste after** — they look similar but serve different purposes:
+
+| | Source | Modifies clipboard? | Position |
+|---|---|---|---|
+| **Duplicate** | The block you click | Yes (overwrites) | Always right after that block |
+| **Paste after** | Whatever was last copied/cut/duplicated | No | Right after the block you click |
+
+Use **Duplicate** for a quick in-place clone. Use **Paste after** (or **Paste block** in the palette) when you want to insert a previously copied block at a specific position or into a different widget.
 
 Paste/duplicate respect the widget's `allow` / `ignore` / `tags` constraints: the paste affordances only appear where the copied block type is actually offered. The clipboard persists for the duration of the browser session (`sessionStorage`), so you can paste across different pages in the same tab.
 

From 451dcb5c7ed5b42d67e9fea93b7a854e998c3efc Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 06:51:25 +0200
Subject: [PATCH 33/55] chore: bump version to 1.1.0

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 updates/version.yaml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/updates/version.yaml b/updates/version.yaml
index bd3fca5..c979367 100644
--- a/updates/version.yaml
+++ b/updates/version.yaml
@@ -1,2 +1,9 @@
 '1.0.0':
     - 'First version of Winter.Blocks'
+'1.1.0':
+    - 'Collapsible sections with persisted state'
+    - 'Tabs and secondaryTabs support in block definitions'
+    - 'Shared field includes with nested include resolution'
+    - 'Recently used blocks pinned to the Add Block palette'
+    - 'Copy, cut, paste after, and duplicate blocks'
+    - 'Paste block entry in the Add Block palette'

From 6576a94afd598ccefb0e4850e708ecb4499a649d Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 06:58:25 +0200
Subject: [PATCH 34/55] Clean up custom code from review pass
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Remove trailing dead string concatenation (+ '') in injectToolbarCss
- Remove duplicate pendingPaste/ajaxUpdateComplete setup in palette paste
  handler — requestAdd already handles both
- Fix toolbar order comments to include 'copy' (was missing from two places)
- Correct applyPalettePaste comment to describe the actual idempotency mechanism

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 formwidgets/blocks/partials/_block.php      | 11 +++--------
 formwidgets/blocks/partials/_block_item.php |  2 +-
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 7ef0bcc..ed8bdf9 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -118,7 +118,7 @@ class="form-control blocks-group-search"
 
         // --- inject toolbar styles once ------------------------------------
         // Kept here (rather than only in blocks.less) so the per-block toolbar
-        // (collapse / cut / paste / duplicate / config / delete) renders
+        // (collapse / copy / cut / paste / duplicate / config / delete) renders
         // correctly even if the compiled CSS is stale.
         (function injectToolbarCss() {
             if (document.getElementById('wn-blocks-toolbar-css')) { return; }
@@ -141,8 +141,7 @@ class="form-control blocks-group-search"
                 // user sees the paste icon without having to hover. Full opacity on hover.
                 '.field-block-item.has-paste>.repeater-item-remove.block-item-toolbar{opacity:.45!important}' +
                 '.field-block-item.has-paste.hover>.repeater-item-remove.block-item-toolbar,' +
-                '.field-block-item.has-paste.focus>.repeater-item-remove.block-item-toolbar{opacity:1!important}' +
-                '';
+                '.field-block-item.has-paste.focus>.repeater-item-remove.block-item-toolbar{opacity:1!important}';
             var style = document.createElement('style');
             style.id = 'wn-blocks-toolbar-css';
             style.textContent = css;
@@ -348,10 +347,6 @@ function injectPalettePaste(grid) {
                 '<div><span class="title">Paste block</span>' +
                 '<span class="description">Insert copied block</span></div>';
             a.addEventListener('click', function () {
-                window.__pendingPaste = { fields: capturedFields, afterLi: null };
-                $(window).one('ajaxUpdateComplete', function () {
-                    cleanupAddItems(capturedFieldBlocks);
-                });
                 requestAdd(capturedFieldBlocks, capturedGroup, capturedFields, null);
             });
 
@@ -468,7 +463,7 @@ function applyRecent() {
         }
 
         // Add the "Paste block" entry to any open Add-Item palette grid. Runs after
-        // applyRecent so it ends up first. Idempotent (removes any prior entry).
+        // applyRecent so it ends up first. Idempotent via the data-paste-group guard.
         function applyPalettePaste() {
             document.querySelectorAll('.blocks-group-grid').forEach(injectPalettePaste);
         }
diff --git a/formwidgets/blocks/partials/_block_item.php b/formwidgets/blocks/partials/_block_item.php
index 78d1466..b039267 100644
--- a/formwidgets/blocks/partials/_block_item.php
+++ b/formwidgets/blocks/partials/_block_item.php
@@ -13,7 +13,7 @@ class="field-repeater-item field-block-item<?php if (!count($widget->getFields()
     <?php
     /*
      * All item controls live in one horizontal toolbar so they never overflow.
-     * Order: collapse, cut, paste, duplicate, [config], delete.
+     * Order: collapse, copy, cut, paste, duplicate, [config], delete.
      */
     ?>
     <div class="repeater-item-remove block-item-toolbar">

From a5208e946c8fc7854ccf517e2801def21b9c5a13 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 07:08:30 +0200
Subject: [PATCH 35/55] Remove Duplicate vs Paste table from README

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 README.md | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/README.md b/README.md
index 4524370..4fd8172 100644
--- a/README.md
+++ b/README.md
@@ -304,13 +304,6 @@ block has an inspector)* and **delete**.
 - **Paste after** — once the clipboard holds a block, a per-block paste icon inserts the copied block immediately **after** that block. A **Paste block** entry also appears at the top of the "Add Block" palette (the popover opened by *+ Add New Item*), which is handy for inserting into an empty widget or at the end of a list.
 - **Duplicate** — one-step clone: serialises the current block, saves it to the clipboard, and immediately inserts a filled copy right after it.
 
-**Duplicate vs. Paste after** — they look similar but serve different purposes:
-
-| | Source | Modifies clipboard? | Position |
-|---|---|---|---|
-| **Duplicate** | The block you click | Yes (overwrites) | Always right after that block |
-| **Paste after** | Whatever was last copied/cut/duplicated | No | Right after the block you click |
-
 Use **Duplicate** for a quick in-place clone. Use **Paste after** (or **Paste block** in the palette) when you want to insert a previously copied block at a specific position or into a different widget.
 
 Paste/duplicate respect the widget's `allow` / `ignore` / `tags` constraints: the paste affordances only appear where the copied block type is actually offered. The clipboard persists for the duration of the browser session (`sessionStorage`), so you can paste across different pages in the same tab.

From 71d2c23c8c51752522cdaac776db3e06ec5f36c6 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 07:14:51 +0200
Subject: [PATCH 36/55] Add git clone instructions for the fork

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 README.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/README.md b/README.md
index 4fd8172..fe42a7f 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,11 @@ Provides a "block based" content management experience in Winter CMS
 
 ## Installation
 
+> **Using this fork?** Clone it directly into your Winter CMS plugins directory:
+> ```bash
+> git clone https://github.com/helmutkaufmann/wn-blocks-plugin-1.git plugins/winter/blocks
+> ```
+
 This plugin is available for installation via [Composer](http://getcomposer.org/).
 
 ```bash

From b77a62f55d056d6dd3a76d938a998ffbb6c66d82 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 07:15:38 +0200
Subject: [PATCH 37/55] Add update instructions for the fork

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index fe42a7f..fbe40f9 100644
--- a/README.md
+++ b/README.md
@@ -16,6 +16,10 @@ Provides a "block based" content management experience in Winter CMS
 > ```bash
 > git clone https://github.com/helmutkaufmann/wn-blocks-plugin-1.git plugins/winter/blocks
 > ```
+> To update to the latest version:
+> ```bash
+> git -C plugins/winter/blocks pull
+> ```
 
 This plugin is available for installation via [Composer](http://getcomposer.org/).
 

From f0a95ac61a280a50983680b288db47fc48fe4f06 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 07:20:16 +0200
Subject: [PATCH 38/55] Add yaml language hint to Fields and Configuration
 example

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index fbe40f9..2df0230 100644
--- a/README.md
+++ b/README.md
@@ -110,7 +110,7 @@ For example, let's say you have a **Title** block which can display a heading ta
 
 **Example:**
 
-```
+```yaml
 name: Title
 description: Adds a title
 icon: icon-heading

From 1e87f220374e9b91c580d9b029b0d5b72afcfba3 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 07:39:27 +0200
Subject: [PATCH 39/55] Auto-refresh richeditor and codeeditor widgets after
 paste fill

Froala and CodeMirror maintain internal state and ignore native change
events on the underlying textarea. Call their own APIs directly using
the data keys Winter's widget plugins set on the element.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 README.md                              |  2 +-
 formwidgets/blocks/partials/_block.php | 17 +++++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 2df0230..71b05ff 100644
--- a/README.md
+++ b/README.md
@@ -317,7 +317,7 @@ Use **Duplicate** for a quick in-place clone. Use **Paste after** (or **Paste bl
 
 Paste/duplicate respect the widget's `allow` / `ignore` / `tags` constraints: the paste affordances only appear where the copied block type is actually offered. The clipboard persists for the duration of the browser session (`sessionStorage`), so you can paste across different pages in the same tab.
 
-> **Note on nested blocks:** Field values — including nested `blocks` fields, which store their content as JSON — are captured and restored correctly. Complex editor widgets (e.g. rich-text, code editors) may require an extra click to refresh their UI after paste, as those widgets listen for native `change` events.
+> **Note on nested blocks:** Field values — including nested `blocks` fields, which store their content as JSON — are captured and restored correctly. Rich-text and code editor widgets are refreshed automatically via their own APIs after paste.
 
 ---
 
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index ed8bdf9..a430185 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -203,6 +203,23 @@ function fillFromClipboard(li, fields) {
                     el.dispatchEvent(new Event('change', { bubbles: true }));
                 }
             });
+            refreshWidgets(li);
+        }
+
+        // Refresh complex editor widgets (richeditor/Froala, codeeditor/CodeMirror) after
+        // a paste fill. These widgets maintain their own internal state and do not re-read
+        // the underlying textarea on a native change event, so we call their own APIs.
+        // Data keys ('oc.richEditor', 'oc.codeEditor') are set by Winter's widget plugins.
+        function refreshWidgets(li) {
+            if (typeof $ === 'undefined') { return; }
+            $(li).find('textarea').each(function () {
+                var w = $(this).data('oc.richEditor');
+                if (w && w.editor && w.editor.html) { w.editor.html.set(this.value); }
+            });
+            $(li).find('[data-control]').each(function () {
+                var w = $(this).data('oc.codeEditor');
+                if (w) { w.setValue($(this).find('textarea').val() || ''); }
+            });
         }
 
         // Is the given block code offered by this widget? Reads the explicit

From abb9db4aa82b2e6fe735540e3fb7df8a5b648198 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 07:44:02 +0200
Subject: [PATCH 40/55] Reduce MutationObserver overhead for large block lists

updatePasteButtons and cleanupAddItems were running on every DOM
mutation (text changes, class toggles, widget updates) via runAll().
Now they only run when the observer detects that new element nodes
were actually added to the DOM. Copy/cut/duplicate handlers already
call updatePasteButtons directly, so observer-triggered scans are
only needed when blocks are added.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 formwidgets/blocks/partials/_block.php | 28 ++++++++++++++++++++++----
 1 file changed, 24 insertions(+), 4 deletions(-)

diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index a430185..4d65489 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -490,14 +490,16 @@ function runAll() {
             initSections();
             applyRecent();
             applyPalettePaste();
-            updatePasteButtons();
-            // Self-heal any empty "add new item" rows left by direct add requests.
-            document.querySelectorAll('.field-blocks').forEach(cleanupAddItems);
         }
 
+        // Full init on first load — includes paste buttons and add-item cleanup
+        // which the observer only repeats when new DOM nodes actually appear.
         runAll();
+        updatePasteButtons();
+        document.querySelectorAll('.field-blocks').forEach(cleanupAddItems);
 
         var scheduled = false;
+        var pendingNewNodes = false;
         var observer = new MutationObserver(function (mutations) {
             // When a paste is pending, find the newly added block <li>, move it after
             // the source block, and fill its fields — all before the debounced runAll fires.
@@ -519,9 +521,27 @@ function runAll() {
                     });
                 }
             }
+            // Track whether any element nodes were added in this batch.
+            // updatePasteButtons and cleanupAddItems are called explicitly by
+            // copy/cut/duplicate handlers; the observer only needs to run them
+            // when the DOM gains new elements (e.g. a block was added).
+            if (!pendingNewNodes) {
+                pendingNewNodes = mutations.some(function (m) { return m.addedNodes.length > 0; });
+            }
             if (scheduled) { return; }
             scheduled = true;
-            setTimeout(function () { scheduled = false; runAll(); }, 0);
+            setTimeout(function () {
+                scheduled = false;
+                var hadNewNodes = pendingNewNodes;
+                pendingNewNodes = false;
+                initSections();
+                applyRecent();
+                applyPalettePaste();
+                if (hadNewNodes) {
+                    updatePasteButtons();
+                    document.querySelectorAll('.field-blocks').forEach(cleanupAddItems);
+                }
+            }, 0);
         });
         function startObserving() {
             if (document.body) {

From 05794dbb06c4bb6c2243b77ffa6064653582e415 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 09:45:23 +0200
Subject: [PATCH 41/55] Document field-key collision limitation in
 paste/duplicate note

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 71b05ff..94ffe9f 100644
--- a/README.md
+++ b/README.md
@@ -317,7 +317,7 @@ Use **Duplicate** for a quick in-place clone. Use **Paste after** (or **Paste bl
 
 Paste/duplicate respect the widget's `allow` / `ignore` / `tags` constraints: the paste affordances only appear where the copied block type is actually offered. The clipboard persists for the duration of the browser session (`sessionStorage`), so you can paste across different pages in the same tab.
 
-> **Note on nested blocks:** Field values — including nested `blocks` fields, which store their content as JSON — are captured and restored correctly. Rich-text and code editor widgets are refreshed automatically via their own APIs after paste.
+> **Note on nested blocks:** Field values — including nested `blocks` fields, which store their content as JSON — are captured and restored correctly. Rich-text and code editor widgets are refreshed automatically via their own APIs after paste. Field matching uses the trailing name segment (e.g. `content` from `Blocks[0][content]`), so two fields in the same block that share the same trailing key would collide — avoid duplicate field keys within a single block definition.
 
 ---
 

From e3b45d389a32f9324945598a36e24e55a82bab1a Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 17:15:40 +0200
Subject: [PATCH 42/55] Updated compsoer.json

---
 composer.json | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/composer.json b/composer.json
index afb381d..b2e005b 100644
--- a/composer.json
+++ b/composer.json
@@ -14,6 +14,13 @@
             "name": "Winter CMS Maintainers",
             "homepage": "https://wintercms.com",
             "role": "Maintainer"
+        },
+        ,
+        {
+            "name": "Helmut Kaufmann",
+            "homepage": "https://mercator.li",
+            "email": "software@mercator.li",
+            "role": "Contributor"
         }
     ],
     "support": {

From 750033d13fe425e12d57749519df8b72760e008d Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Fri, 12 Jun 2026 17:16:45 +0200
Subject: [PATCH 43/55] Updated compsoer.json

---
 composer.json | 1 -
 1 file changed, 1 deletion(-)

diff --git a/composer.json b/composer.json
index b2e005b..237205e 100644
--- a/composer.json
+++ b/composer.json
@@ -15,7 +15,6 @@
             "homepage": "https://wintercms.com",
             "role": "Maintainer"
         },
-        ,
         {
             "name": "Helmut Kaufmann",
             "homepage": "https://mercator.li",

From d2c385a0ceaa6b1ccf173d1f155105da55e17f6f Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Sun, 14 Jun 2026 17:28:09 +0200
Subject: [PATCH 44/55] =?UTF-8?q?Remove=20tab/secondaryTabs=20support=20?=
 =?UTF-8?q?=E2=80=94=20feature=20was=20never=20rendered?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The block item partial renders fields via individual renderField() calls
in a loop, which never emits a tab strip. The tabs/secondaryTabs config
was wired up on the PHP side but silently ignored at render time, making
any tab: declarations in .block files a no-op.

- Drop tabs/secondaryTabs from BlockManager::$mergeKeys (includes no
  longer merge those keys) and simplify warnOnTypeCollisions accordingly
- Remove processGroupMode() entries for tabs/secondaryTabs
- Remove getGroupFormFieldConfig() override (existed solely to pass tabs
  through to the form widget)
- Update test, fixture, README, and CHANGELOG to match

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                                |  7 +-
 README.md                                   | 71 ++++-----------------
 classes/BlockManager.php                    |  9 ++-
 formwidgets/Blocks.php                      | 27 --------
 tests/classes/BlockManagerTest.php          |  8 ++-
 tests/fixtures/blocks/includes/_shared.yaml |  6 --
 6 files changed, 21 insertions(+), 107 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6c13081..a048144 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,14 +13,9 @@
 - **Open/closed state now persists** per section across page reloads
   (`localStorage`, keyed by field name).
 
-### Tabs
-- `.block` definitions may declare top-level `tabs` and `secondaryTabs`, passed
-  through to the backend `Form` widget like a standard `fields.yaml`.
-
 ### Shared field includes
 - `.block` definitions may declare a top-level `include:` (string or list) to
-  merge `fields`, `tabs`, `secondaryTabs`, and `config` from external plain-YAML
-  files.
+  merge `fields` and `config` from external plain-YAML files.
 - Included definitions form the base; the block's own definitions override on
   collision. Paths resolve via `File::symbolizePath()` (`$/`, `~/`, `#/`).
 - **Nested includes** are resolved recursively, guarded against circular
diff --git a/README.md b/README.md
index 94ffe9f..f4c48d2 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ Provides a "block based" content management experience in Winter CMS
 
 >**NOTE:** This plugin is still in development and is likely to undergo changes. Do not use in production environments without using a version constraint in your composer.json file and carefully monitoring for breaking changes.
 
-> **Block definition features:** **collapsible sections** (with persisted state), **tabs/secondaryTabs** support, **shared field includes** (with nested includes), and **recently used blocks** in the palette. See [Collapsible Sections](#collapsible-sections), [Tabs](#tabs), [Including shared field definitions](#including-shared-field-definitions), and [Recently used blocks](#recently-used-blocks) below. Full list in [CHANGELOG.md](CHANGELOG.md).
+> **Block definition features:** **collapsible sections** (with persisted state), **shared field includes** (with nested includes), and **recently used blocks** in the palette. See [Collapsible Sections](#collapsible-sections), [Including shared field definitions](#including-shared-field-definitions), and [Recently used blocks](#recently-used-blocks) below. Full list in [CHANGELOG.md](CHANGELOG.md).
 
 ## Installation
 
@@ -184,52 +184,6 @@ When `collapsible: true` is set, the section header becomes a click target. Sect
 
 ---
 
-## Tabs
-
-Block definitions can include `tabs` and/or `secondaryTabs` at the top level. These are passed through to the WinterCMS `Backend\Widgets\Form` widget exactly as they would be in a standard `fields.yaml` file.
-
-```yaml
-name: My Block
-description: A block with tabs
-icon: icon-th
-
-tabs:
-    cssClass: master-tabs
-    fields:
-        content:
-            label: Content
-            type: textarea
-            tab: Content
-
-        title:
-            label: Title
-            type: text
-            tab: Content
-
-        meta_title:
-            label: Meta title
-            type: text
-            tab: SEO
-
-        meta_description:
-            label: Meta description
-            type: textarea
-            tab: SEO
-
-secondaryTabs:
-    fields:
-        is_active:
-            label: Active
-            type: checkbox
-            tab: Settings
-==
-<div>{{ content }}</div>
-```
-
-Fields declared under `tabs` / `secondaryTabs` are placed in the tabbed area of the form widget. You can combine `tabs`, `secondaryTabs`, and the top-level `fields` array in the same block.
-
----
-
 ## Including shared field definitions
 
 To avoid repeating the same fields (or sections/tabs) across many blocks, a block can pull them in from one or more external YAML files via the top-level `include` key.
@@ -249,20 +203,17 @@ fields:
 <article>{{ title }}</article>
 ```
 
-`_seo.yaml` is a plain YAML file (no `==` markup, no block metadata) containing any of `fields`, `tabs`, `secondaryTabs`, or `config`:
+`_seo.yaml` is a plain YAML file (no `==` markup, no block metadata) containing any of `fields` or `config`:
 
 ```yaml
 # blocks/_seo.yaml
-tabs:
-    fields:
-        meta_title:
-            label: Meta title
-            type: text
-            tab: SEO
-        meta_description:
-            label: Meta description
-            type: textarea
-            tab: SEO
+fields:
+    meta_title:
+        label: Meta title
+        type: text
+    meta_description:
+        label: Meta description
+        type: textarea
 ```
 
 **Multiple includes** — pass a list; they are merged in order:
@@ -277,7 +228,7 @@ include:
 
 | | |
 |---|---|
-| Merged keys | `fields`, `tabs`, `secondaryTabs`, `config` |
+| Merged keys | `fields`, `config` |
 | Precedence | Included files form the base; the block's own definitions **override** on key collision |
 | Order | Multiple includes merge top-to-bottom (later files override earlier ones, the block still wins overall) |
 | Nested includes | An included file may itself declare `include:` — resolved recursively, with a circular-reference guard |
@@ -292,7 +243,7 @@ include:
 | `~/...` | application root |
 | `#/...` | `storage/app/...` |
 
-This works for `collapsible` sections and tabs too — an included file can define a complete collapsible section (or a whole tab group) that every block reuses without copy-paste.
+This works for `collapsible` sections too — an included file can define a complete collapsible section that every block reuses without copy-paste.
 
 ---
 
diff --git a/classes/BlockManager.php b/classes/BlockManager.php
index 3b986d1..adec9ce 100644
--- a/classes/BlockManager.php
+++ b/classes/BlockManager.php
@@ -132,7 +132,7 @@ public function getConfigs(string|array|null $tags = null): array
      *         - ~/app/blocks/_tracking.yaml
      *
      * Each included file is a plain YAML file that may contain any of the keys
-     * `fields`, `tabs`, `secondaryTabs` and `config`. Included definitions are
+     * `fields` and `config`. Included definitions are
      * merged in order and act as a base; the block's own definitions take
      * precedence on key collisions.
      *
@@ -154,7 +154,7 @@ protected function resolveIncludes(array $config, array $visited = []): array
         $paths = (array) $config['include'];
         unset($config['include']);
 
-        $mergeKeys = ['fields', 'tabs', 'secondaryTabs', 'config'];
+        $mergeKeys = ['fields', 'config'];
 
         foreach ($paths as $path) {
             if (!is_string($path) || $path === '') {
@@ -207,9 +207,8 @@ protected function resolveIncludes(array $config, array $visited = []): array
      */
     protected function warnOnTypeCollisions(string $key, array $included, array $own): void
     {
-        $nested = in_array($key, ['tabs', 'secondaryTabs'], true);
-        $includedFields = $nested ? ($included['fields'] ?? []) : $included;
-        $ownFields = $nested ? ($own['fields'] ?? []) : $own;
+        $includedFields = $included;
+        $ownFields = $own;
 
         if (!is_array($includedFields) || !is_array($ownFields)) {
             return;
diff --git a/formwidgets/Blocks.php b/formwidgets/Blocks.php
index c256269..1461e16 100644
--- a/formwidgets/Blocks.php
+++ b/formwidgets/Blocks.php
@@ -211,8 +211,6 @@ protected function processGroupMode(): void
                 'icon'          => array_get($config, 'icon', 'icon-square-o'),
                 'description'   => array_get($config, 'description'),
                 'fields'        => $this->normalizeBlockFields((array) array_get($config, 'fields', [])),
-                'tabs'          => array_get($config, 'tabs'),
-                'secondaryTabs' => array_get($config, 'secondaryTabs'),
                 'config'        => array_get($config, 'config', null),
             ];
         }
@@ -268,31 +266,6 @@ protected function normalizeBlockFields(array $fields): array
         return $fields;
     }
 
-    /**
-     * Extends the parent config to pass tabs and secondaryTabs from the block
-     * definition through to the Backend Form widget.
-     */
-    protected function getGroupFormFieldConfig($code): ?array
-    {
-        $config = parent::getGroupFormFieldConfig($code);
-
-        if ($config === null) {
-            return null;
-        }
-
-        $def = $this->groupDefinitions[$code] ?? [];
-
-        if (!empty($def['tabs'])) {
-            $config['tabs'] = $def['tabs'];
-        }
-
-        if (!empty($def['secondaryTabs'])) {
-            $config['secondaryTabs'] = $def['secondaryTabs'];
-        }
-
-        return $config;
-    }
-
     /**
      * Determines if a block is allowed according to the widget's ignore/allow list.
      */
diff --git a/tests/classes/BlockManagerTest.php b/tests/classes/BlockManagerTest.php
index 80da180..710e12a 100644
--- a/tests/classes/BlockManagerTest.php
+++ b/tests/classes/BlockManagerTest.php
@@ -52,7 +52,7 @@ protected function includePath(string $file): string
     }
 
     /**
-     * @testdox merges fields, tabs and config from an included file
+     * @testdox merges fields and config from an included file
      */
     public function testIncludeMergesDefinitions()
     {
@@ -70,9 +70,11 @@ public function testIncludeMergesDefinitions()
         $this->assertArrayHasKey('shared_field', $result['fields']);
         $this->assertArrayHasKey('title', $result['fields']);
 
-        // tabs and config from the include are merged in too.
-        $this->assertArrayHasKey('meta_title', $result['tabs']['fields']);
+        // config from the include is merged in too.
         $this->assertArrayHasKey('shared_config', $result['config']);
+
+        // tabs are not a supported merge key.
+        $this->assertArrayNotHasKey('tabs', $result);
     }
 
     /**
diff --git a/tests/fixtures/blocks/includes/_shared.yaml b/tests/fixtures/blocks/includes/_shared.yaml
index 28e70e7..5c7258d 100644
--- a/tests/fixtures/blocks/includes/_shared.yaml
+++ b/tests/fixtures/blocks/includes/_shared.yaml
@@ -5,12 +5,6 @@ fields:
     overridden:
         label: From include
         type: text
-tabs:
-    fields:
-        meta_title:
-            label: Meta title
-            type: text
-            tab: SEO
 config:
     shared_config:
         label: Shared config

From 014483c30ad412a91ce6bd0361c1d41807cee0be Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Mon, 15 Jun 2026 22:37:59 +0200
Subject: [PATCH 45/55] Memoize getConfigs() and getBlocks() per request
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Block::listInTheme() rescans every block file in the active theme on each
call (~17ms warm, ~90ms cold for ~100 blocks), and getConfigs() rebuilds the
full config set (re-reading attributes and any included YAML) without caching.

Both are hit several times per backend request — twice during plugin boot,
once per Blocks widget, and once per block via getConfig()/getDefaultConfig()
during rendering — so the cost compounds to hundreds of ms on pages using the
blocks editor.

Memoize both per request. Block definitions cannot change within a request,
callers only read the results, and per-widget allow/ignore filtering happens
after getConfigs(), so the shared caches are safe. A simulated request
workload drops from ~540ms to a single ~22ms theme scan.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 classes/BlockManager.php | 33 +++++++++++++++++++++++++++++++--
 1 file changed, 31 insertions(+), 2 deletions(-)

diff --git a/classes/BlockManager.php b/classes/BlockManager.php
index adec9ce..6ed2206 100644
--- a/classes/BlockManager.php
+++ b/classes/BlockManager.php
@@ -32,6 +32,29 @@ class BlockManager
      */
     protected $blocks = [];
 
+    /**
+     * @var array Per-request memoization of getConfigs() results, keyed by tags.
+     *
+     * Building the configs re-reads and re-parses every block file (plus any
+     * `include`d YAML), which costs ~15ms for the full set. getConfigs() is
+     * called several times per backend request (plugin boot, each Blocks
+     * widget, and once per getConfig() during rendering), so the uncached cost
+     * compounds. Block definitions cannot change within a request, so the
+     * result is safe to memoize.
+     */
+    protected $configCache = [];
+
+    /**
+     * @var CmsObjectCollection|null Per-request memoization of getBlocks().
+     *
+     * Block::listInTheme() rescans every block file in the active theme on each
+     * call (~17ms warm, ~90ms cold for ~100 blocks). It is hit from getConfigs()
+     * for each distinct tag set and from BlocksDatasource, so sharing one result
+     * per request removes the redundant scans. The theme's block set does not
+     * change within a request.
+     */
+    protected $blocksCache = null;
+
     public function init(): void
     {
         // @TODO: Find a better way to handle rendering blocks that doesn't require a "blocks" partial in the theme
@@ -81,7 +104,7 @@ public function registerBlock(string $key, string $path): void
      */
     public function getBlocks(): CmsObjectCollection
     {
-        return Block::listInTheme(Theme::getActiveTheme());
+        return $this->blocksCache ??= Block::listInTheme(Theme::getActiveTheme());
     }
 
     /**
@@ -89,6 +112,12 @@ public function getBlocks(): CmsObjectCollection
      */
     public function getConfigs(string|array|null $tags = null): array
     {
+        $cacheKey = json_encode($tags);
+
+        if (isset($this->configCache[$cacheKey])) {
+            return $this->configCache[$cacheKey];
+        }
+
         $configs = [];
         foreach ($this->getBlocks() as $block) {
             if (isset($tags)) {
@@ -116,7 +145,7 @@ public function getConfigs(string|array|null $tags = null): array
             $configs[pathinfo($block['fileName'])['filename']] = $config;
         }
 
-        return $configs;
+        return $this->configCache[$cacheKey] = $configs;
     }
 
     /**

From 601d77f950a91e3783b99304dbfacbd83e938732 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Mon, 15 Jun 2026 22:47:17 +0200
Subject: [PATCH 46/55] =?UTF-8?q?Revert=20getBlocks()=20memoization=20?=
 =?UTF-8?q?=E2=80=94=20breaks=20block=20rendering?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

BlocksDatasource calls getBlocks() in its constructor, before it has been
added to the AutoDatasource chain. Caching that early, incomplete result
caused all subsequent calls to return a stale collection, making blocks
render as empty rows in the backend.

getConfigs() memoization is unaffected and still in place.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 classes/BlockManager.php | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/classes/BlockManager.php b/classes/BlockManager.php
index 6ed2206..6c1f916 100644
--- a/classes/BlockManager.php
+++ b/classes/BlockManager.php
@@ -44,16 +44,6 @@ class BlockManager
      */
     protected $configCache = [];
 
-    /**
-     * @var CmsObjectCollection|null Per-request memoization of getBlocks().
-     *
-     * Block::listInTheme() rescans every block file in the active theme on each
-     * call (~17ms warm, ~90ms cold for ~100 blocks). It is hit from getConfigs()
-     * for each distinct tag set and from BlocksDatasource, so sharing one result
-     * per request removes the redundant scans. The theme's block set does not
-     * change within a request.
-     */
-    protected $blocksCache = null;
 
     public function init(): void
     {
@@ -104,7 +94,7 @@ public function registerBlock(string $key, string $path): void
      */
     public function getBlocks(): CmsObjectCollection
     {
-        return $this->blocksCache ??= Block::listInTheme(Theme::getActiveTheme());
+        return Block::listInTheme(Theme::getActiveTheme());
     }
 
     /**

From 0d2eafe1da299dd22d1c769381122c88705eabad Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Mon, 15 Jun 2026 22:54:19 +0200
Subject: [PATCH 47/55] Cache built block configs across requests
 (self-invalidating)

getConfigs() scans and parses every block file (~17ms warm, ~97ms cold for
~100 blocks) on the first call of each request. The in-request memo avoids
repeats within a request but every request still paid the scan.

Cache the built configs in the application cache store, keyed by a content
signature derived from block-file mtimes. The signature is computed in ~0.1ms
from the in-memory registered-paths list without triggering a Halcyon scan,
so requests after the first skip the build entirely (~5ms cache hit vs ~17ms).

The cache self-invalidates: changing/adding/removing a .block file changes the
signature, and the mtimes of any included YAML files are stored with the entry
and re-checked on read, so editing a shared include invalidates it too. A TTL
is kept only as a safety net.

This caches getConfigs() (never called during BlocksDatasource construction),
not getBlocks(), so it avoids the constructor-ordering issue that the earlier
getBlocks() memoization hit. Verified the cached output is byte-identical to a
fresh build.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 classes/BlockManager.php | 115 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 114 insertions(+), 1 deletion(-)

diff --git a/classes/BlockManager.php b/classes/BlockManager.php
index 6c1f916..18d1d18 100644
--- a/classes/BlockManager.php
+++ b/classes/BlockManager.php
@@ -2,6 +2,7 @@
 
 namespace Winter\Blocks\Classes;
 
+use Cache;
 use Cms\Classes\CmsObjectCollection;
 use Cms\Classes\Controller;
 use Cms\Classes\Theme;
@@ -44,6 +45,23 @@ class BlockManager
      */
     protected $configCache = [];
 
+    /**
+     * @var string|null Per-request memo of the block-set signature (file mtimes).
+     */
+    protected $signature = null;
+
+    /**
+     * @var array Included YAML files (path => mtime) touched during the last
+     * config build, used to invalidate the cross-request cache when an included
+     * file changes without its parent .block file changing.
+     */
+    protected $touchedIncludes = [];
+
+    /**
+     * Cross-request cache TTL (seconds) for built configs. The cache is keyed by
+     * a content signature and self-invalidates, so the TTL is only a safety net.
+     */
+    const CONFIG_CACHE_TTL = 86400;
 
     public function init(): void
     {
@@ -104,10 +122,55 @@ public function getConfigs(string|array|null $tags = null): array
     {
         $cacheKey = json_encode($tags);
 
+        // In-request memoization.
         if (isset($this->configCache[$cacheKey])) {
             return $this->configCache[$cacheKey];
         }
 
+        return $this->configCache[$cacheKey] = $this->rememberConfigs($cacheKey, $tags);
+    }
+
+    /**
+     * Returns the built configs for the given tags, served from the cross-request
+     * cache when the underlying block files (and any included YAML) are unchanged.
+     *
+     * Building the configs scans and parses every block file (~17ms for ~100
+     * blocks); the cache replaces that with a cheap mtime check (~0.1ms) on every
+     * request after the first. The cache self-invalidates: a content signature
+     * derived from block-file mtimes keys the entry, and the mtimes of any
+     * included YAML files are stored alongside and re-checked on read.
+     */
+    protected function rememberConfigs(string $cacheKey, string|array|null $tags): array
+    {
+        $store = 'winter.blocks.configs.' . md5($cacheKey);
+        $signature = $this->blocksSignature();
+
+        $cached = Cache::get($store);
+        if (
+            is_array($cached)
+            && ($cached['signature'] ?? null) === $signature
+            && $this->includesUnchanged($cached['includes'] ?? [])
+        ) {
+            return $cached['data'];
+        }
+
+        $this->touchedIncludes = [];
+        $data = $this->buildConfigs($tags);
+
+        Cache::put($store, [
+            'signature' => $signature,
+            'includes'  => $this->touchedIncludes,
+            'data'      => $data,
+        ], static::CONFIG_CACHE_TTL);
+
+        return $data;
+    }
+
+    /**
+     * Builds the block configs by scanning and parsing the theme's block files.
+     */
+    protected function buildConfigs(string|array|null $tags = null): array
+    {
         $configs = [];
         foreach ($this->getBlocks() as $block) {
             if (isset($tags)) {
@@ -135,7 +198,53 @@ public function getConfigs(string|array|null $tags = null): array
             $configs[pathinfo($block['fileName'])['filename']] = $config;
         }
 
-        return $this->configCache[$cacheKey] = $configs;
+        return $configs;
+    }
+
+    /**
+     * Computes a signature for the current block set from the mtimes (and paths)
+     * of every block file. Cheap (~0.1ms): it reads the in-memory list of
+     * plugin-registered block paths plus any theme-provided block files, and
+     * never triggers a Halcyon scan. Memoized per request.
+     */
+    protected function blocksSignature(): string
+    {
+        if ($this->signature !== null) {
+            return $this->signature;
+        }
+
+        $parts = [];
+
+        // Plugin-registered blocks (the bulk) — already resolved to real paths.
+        foreach ($this->getRegisteredBlocks() as $path) {
+            $parts[$path] = @filemtime($path) ?: 0;
+        }
+
+        // Theme-provided block files, if the active theme ships any.
+        if (($theme = Theme::getActiveTheme()) && is_dir($themeDir = $theme->getPath() . '/blocks')) {
+            foreach (glob($themeDir . '/*.' . static::BLOCK_EXTENSION) ?: [] as $path) {
+                $parts[$path] = @filemtime($path) ?: 0;
+            }
+        }
+
+        ksort($parts);
+
+        return $this->signature = md5(serialize($parts));
+    }
+
+    /**
+     * Returns true if every included YAML file recorded with a cached config
+     * still has the same mtime (i.e. nothing was edited under it).
+     */
+    protected function includesUnchanged(array $includes): bool
+    {
+        foreach ($includes as $path => $mtime) {
+            if ((@filemtime($path) ?: 0) !== $mtime) {
+                return false;
+            }
+        }
+
+        return true;
     }
 
     /**
@@ -192,6 +301,10 @@ protected function resolveIncludes(array $config, array $visited = []): array
                 continue;
             }
 
+            // Record the included file so the cross-request config cache can be
+            // invalidated when it changes independently of the parent .block file.
+            $this->touchedIncludes[$canonical] = @filemtime($realPath) ?: 0;
+
             $included = Yaml::parse(File::get($realPath));
             if (!is_array($included)) {
                 continue;

From a895d489c3b7b1511d823bedc1053aa1a68b6eb8 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Mon, 15 Jun 2026 23:29:56 +0200
Subject: [PATCH 48/55] Copy/paste blocks server-side to preserve all field
 content
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The previous copy/paste scraped field values from the DOM by their trailing
[key] segment and re-applied them client-side. That silently lost any field it
couldn't represent flatly: switches (it read the static value, not the checked
state), mediafinders (preview never refreshed), and nested repeaters (rows
don't exist in a freshly added block, and leaf keys collide). Galleries, which
use a media repeater plus switches and mediafinders, came across as structure
only.

Move copy and paste to the server:

- onCopyItem builds the item's Form widget and returns getSaveData(), which
  reads the posted values and delegates to each field widget (including nested
  repeaters and mediafinders). This captures every field type correctly. The
  clipboard now holds { group, config, data }.
- onAddItem accepts optional _paste_data / _paste_config and seeds it via a
  getValueFromIndex() override, so the new item's form renders fully populated
  server-side — the same path Winter uses when loading a saved page.
- The client just stores the copied payload and, on paste, repositions the new
  <li>; the lossy serialize/fill/refresh code is removed.

Verified end to end: galleries paste back with their media directories,
switches, dropdowns and mediafinder values intact.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 formwidgets/Blocks.php                      |  62 ++++++++++
 formwidgets/blocks/partials/_block.php      | 123 ++++++++------------
 formwidgets/blocks/partials/_block_item.php |   2 +
 3 files changed, 115 insertions(+), 72 deletions(-)

diff --git a/formwidgets/Blocks.php b/formwidgets/Blocks.php
index 1461e16..38682da 100644
--- a/formwidgets/Blocks.php
+++ b/formwidgets/Blocks.php
@@ -32,6 +32,14 @@ class Blocks extends Repeater
      */
     public array $indexConfigMeta = [];
 
+    /**
+     * Block data to seed into a freshly added item, keyed by index. Used by the
+     * server-side paste flow so a pasted block renders fully populated (switches,
+     * mediafinders, nested repeaters) instead of relying on lossy client-side
+     * field scraping.
+     */
+    protected array $pasteData = [];
+
     /**
      * {@inheritDoc}
      */
@@ -171,6 +179,50 @@ protected function processItems()
 
     /**
      * {@inheritDoc}
+     *
+     * Returns the data at a given index, preferring data seeded for the
+     * server-side paste flow (see onAddItem).
+     */
+    protected function getValueFromIndex($index)
+    {
+        if (array_key_exists($index, $this->pasteData)) {
+            return $this->pasteData[$index];
+        }
+
+        return parent::getValueFromIndex($index);
+    }
+
+    /**
+     * Returns the full saved data for a single block item, for the copy/cut/
+     * duplicate clipboard. Building the item's Form widget and calling
+     * getSaveData() captures every field type correctly — including switches,
+     * mediafinders and nested repeaters — which a client-side DOM scrape cannot.
+     */
+    public function onCopyItem()
+    {
+        $index = post('_repeater_index');
+        $groupCode = post('_repeater_group');
+
+        $widget = $this->makeItemFormWidget($index, $groupCode);
+
+        // The Inspector config is repeater meta, not a form field, so read it
+        // straight from the posted item value rather than getSaveData().
+        $config = array_get(parent::getValueFromIndex($index), '_config') ?: null;
+
+        return [
+            'result' => json_encode([
+                'group'  => $groupCode,
+                'config' => $config,
+                'data'   => $widget->getSaveData(),
+            ]),
+        ];
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Accepts optional `_paste_data` (a JSON-encoded block data array from
+     * onCopyItem) and `_paste_config` to render the new item pre-populated.
      */
     public function onAddItem()
     {
@@ -178,9 +230,19 @@ public function onAddItem()
 
         $index = $this->getNextIndex();
 
+        $pasteConfig = null;
+        if ($pasteRaw = post('_paste_data')) {
+            $decoded = json_decode($pasteRaw, true);
+            if (is_array($decoded)) {
+                $this->pasteData[$index] = $decoded;
+                $pasteConfig = post('_paste_config') ?: null;
+            }
+        }
+
         $this->prepareVars();
         $this->vars['widget'] = $this->makeItemFormWidget($index, $groupCode);
         $this->vars['indexValue'] = $index;
+        $this->indexConfigMeta[$index] = $pasteConfig;
 
         $itemContainer = '@#' . $this->getId('items');
         $addItemContainer = '#' . $this->getId('add-item');
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 4d65489..5305748 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -6,6 +6,7 @@
     <?= $style ? 'data-style="'.$style.'"' : '' ?>
     data-mode="<?= $mode ?>"
     data-add-handler="<?= $this->getEventHandler('onAddItem') ?>"
+    data-copy-handler="<?= $this->getEventHandler('onCopyItem') ?>"
     data-block-codes="<?= e(implode(',', array_keys($groupDefinitions))) ?>"
     <?php if ($mode === 'grid'): ?> data-columns="<?= $columns ?>" <?php endif ?>
     <?php if ($sortable) : ?>
@@ -172,54 +173,29 @@ function getClipboard() {
             } catch (e) { return null; }
         }
 
-        // Serialize all named inputs in a block <li> by their trailing [key] segment.
-        // The _group hidden input gives us the block type; all other inputs are field data.
-        // Nested blocks fields store their JSON in a hidden input, so they serialize cleanly.
-        function serializeBlockItem(li) {
-            var data = { group: null, fields: {} };
-            li.querySelectorAll('input[name], select[name], textarea[name]').forEach(function (el) {
-                var m = el.name.match(/\[([^\[\]]+)\]$/);
-                if (!m) { return; }
-                var key = m[1];
-                if (key === '_group') {
-                    if (!data.group) { data.group = el.value; }
-                } else {
-                    data.fields[key] = el.value;
-                }
-            });
-            return data;
-        }
-
-        // Fill form inputs in a newly added <li> from stored field values.
-        // Matches by trailing [key] segment — works for flat fields and JSON hidden inputs.
-        function fillFromClipboard(li, fields) {
-            li.querySelectorAll('input[name], select[name], textarea[name]').forEach(function (el) {
-                var m = el.name.match(/\[([^\[\]]+)\]$/);
-                if (!m) { return; }
-                var key = m[1];
-                if (Object.prototype.hasOwnProperty.call(fields, key)) {
-                    el.value = fields[key];
-                    // Dispatch change so any widget listeners (e.g. select2, codemirror) react.
-                    el.dispatchEvent(new Event('change', { bubbles: true }));
+        // Copy a block item's full saved data to the clipboard via the server.
+        // A server round-trip (onCopyItem -> Form::getSaveData) captures every
+        // field type correctly — switches, mediafinders, nested repeaters — which
+        // a client-side DOM scrape cannot. Stored payload: { group, config, data }.
+        // `done(payload)` runs once the clipboard has been set.
+        function copyItemToClipboard(li, done) {
+            if (typeof $ === 'undefined' || !li) { return; }
+            var fieldBlocks = li.closest('.field-blocks');
+            var handler = fieldBlocks && fieldBlocks.getAttribute('data-copy-handler');
+            var index = li.getAttribute('data-block-index');
+            var group = li.getAttribute('data-block-group');
+            if (!handler || index === null) { return; }
+            $(fieldBlocks).request(handler, {
+                data: { _repeater_index: index, _repeater_group: group },
+                success: function (response) {
+                    var payload;
+                    try { payload = JSON.parse(response.result); } catch (e) { return; }
+                    if (!payload || !payload.group) { return; }
+                    ssSet(CLIPBOARD_KEY, JSON.stringify(payload));
+                    updatePasteButtons();
+                    if (typeof done === 'function') { done(payload); }
                 }
             });
-            refreshWidgets(li);
-        }
-
-        // Refresh complex editor widgets (richeditor/Froala, codeeditor/CodeMirror) after
-        // a paste fill. These widgets maintain their own internal state and do not re-read
-        // the underlying textarea on a native change event, so we call their own APIs.
-        // Data keys ('oc.richEditor', 'oc.codeEditor') are set by Winter's widget plugins.
-        function refreshWidgets(li) {
-            if (typeof $ === 'undefined') { return; }
-            $(li).find('textarea').each(function () {
-                var w = $(this).data('oc.richEditor');
-                if (w && w.editor && w.editor.html) { w.editor.html.set(this.value); }
-            });
-            $(li).find('[data-control]').each(function () {
-                var w = $(this).data('oc.codeEditor');
-                if (w) { w.setValue($(this).find('textarea').val() || ''); }
-            });
         }
 
         // Is the given block code offered by this widget? Reads the explicit
@@ -263,16 +239,23 @@ function cleanupAddItems(fieldBlocks) {
                 });
         }
 
-        // Fire onAddItem on a widget, with the empty-add-item cleanup applied once
-        // the AJAX update has been applied.
-        function requestAdd(fieldBlocks, group, fields, afterLi) {
+        // Fire onAddItem with the copied block's data so the server renders the
+        // new item fully populated. We only remember where to move the new <li>
+        // once it arrives; the server handles all field population.
+        function requestPaste(fieldBlocks, payload, afterLi) {
             var handler = findAddHandler(fieldBlocks);
-            if (!handler || typeof $ === 'undefined') { return; }
-            window.__pendingPaste = { fields: fields, afterLi: afterLi || null };
+            if (!handler || typeof $ === 'undefined' || !payload || !payload.group) { return; }
+            window.__pendingPasteMove = { afterLi: afterLi || null };
             $(window).one('ajaxUpdateComplete', function () {
                 cleanupAddItems(fieldBlocks);
             });
-            $(fieldBlocks).request(handler, { data: { _repeater_group: group } });
+            $(fieldBlocks).request(handler, {
+                data: {
+                    _repeater_group: payload.group,
+                    _paste_data: JSON.stringify(payload.data || {}),
+                    _paste_config: payload.config || ''
+                }
+            });
         }
 
         // Collapse chevron (moved into the toolbar, so the core delegated handler
@@ -295,9 +278,7 @@ function requestAdd(fieldBlocks, group, fields, afterLi) {
             e.preventDefault();
             e.stopPropagation();
             var li = btn.closest('.field-block-item');
-            if (!li) { return; }
-            ssSet(CLIPBOARD_KEY, JSON.stringify(serializeBlockItem(li)));
-            updatePasteButtons();
+            copyItemToClipboard(li);
         });
 
         // Duplicate button: clone this block in place (insert a copy right after it)
@@ -309,11 +290,9 @@ function requestAdd(fieldBlocks, group, fields, afterLi) {
             e.stopPropagation();
             var li = btn.closest('.field-block-item');
             if (!li) { return; }
-            var data = serializeBlockItem(li);
-            if (!data.group) { return; }
-            ssSet(CLIPBOARD_KEY, JSON.stringify(data));
-            updatePasteButtons();
-            requestAdd(li.closest('.field-blocks'), data.group, data.fields, li);
+            copyItemToClipboard(li, function (payload) {
+                requestPaste(li.closest('.field-blocks'), payload, li);
+            });
         });
 
         // Cut button: copy then trigger the existing remove button (with confirm).
@@ -323,10 +302,10 @@ function requestAdd(fieldBlocks, group, fields, afterLi) {
             e.stopPropagation();
             var li = btn.closest('.field-block-item');
             if (!li) { return; }
-            ssSet(CLIPBOARD_KEY, JSON.stringify(serializeBlockItem(li)));
-            updatePasteButtons();
-            var removeBtn = li.querySelector('[data-repeater-remove]');
-            if (removeBtn) { removeBtn.click(); }
+            copyItemToClipboard(li, function () {
+                var removeBtn = li.querySelector('[data-repeater-remove]');
+                if (removeBtn) { removeBtn.click(); }
+            });
         });
 
         // Remember which widget's Add-Item palette is open, so a paste entry
@@ -355,7 +334,7 @@ function injectPalettePaste(grid) {
 
             var capturedFieldBlocks = fieldBlocks;
             var capturedGroup = cb.group;
-            var capturedFields = cb.fields;
+            var capturedPayload = cb;
 
             var a = document.createElement('a');
             a.href = 'javascript:;';
@@ -364,7 +343,7 @@ function injectPalettePaste(grid) {
                 '<div><span class="title">Paste block</span>' +
                 '<span class="description">Insert copied block</span></div>';
             a.addEventListener('click', function () {
-                requestAdd(capturedFieldBlocks, capturedGroup, capturedFields, null);
+                requestPaste(capturedFieldBlocks, capturedPayload, null);
             });
 
             var item = document.createElement('div');
@@ -384,7 +363,7 @@ function injectPalettePaste(grid) {
             var cb = getClipboard();
             if (!cb || !cb.group) { return; }
             var li = btn.closest('.field-block-item');
-            requestAdd(li.closest('.field-blocks'), cb.group, cb.fields, li);
+            requestPaste(li.closest('.field-blocks'), cb, li);
         });
 
         // --- collapsible sections ------------------------------------------
@@ -503,20 +482,20 @@ function runAll() {
         var observer = new MutationObserver(function (mutations) {
             // When a paste is pending, find the newly added block <li>, move it after
             // the source block, and fill its fields — all before the debounced runAll fires.
-            if (window.__pendingPaste) {
-                var pending = window.__pendingPaste;
+            if (window.__pendingPasteMove) {
+                var pending = window.__pendingPasteMove;
                 for (var i = 0; i < mutations.length; i++) {
                     mutations[i].addedNodes.forEach(function (node) {
                         if (node.nodeType === 1 && node.classList &&
                                 node.classList.contains('field-block-item')) {
-                            window.__pendingPaste = null;
-                            // Move the new item to immediately after the source item.
+                            window.__pendingPasteMove = null;
+                            // The server already populated the fields; we only
+                            // move the new item to sit after the source block.
                             if (pending.afterLi && pending.afterLi.parentNode) {
                                 pending.afterLi.parentNode.insertBefore(
                                     node, pending.afterLi.nextSibling
                                 );
                             }
-                            fillFromClipboard(node, pending.fields);
                         }
                     });
                 }
diff --git a/formwidgets/blocks/partials/_block_item.php b/formwidgets/blocks/partials/_block_item.php
index b039267..d16110f 100644
--- a/formwidgets/blocks/partials/_block_item.php
+++ b/formwidgets/blocks/partials/_block_item.php
@@ -7,6 +7,8 @@
 ?>
 <li
     class="field-repeater-item field-block-item<?php if (!count($widget->getFields())): ?> empty<?php endif ?>"
+    data-block-index="<?= $indexValue ?>"
+    data-block-group="<?= $groupCode ?>"
     <?php if ($mode === 'grid'): ?>style="min-height: <?= $rowHeight ?>px"<?php endif ?>
 >
 

From b66346d4a035fe77693dd8d518e9bd2a9647630f Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Mon, 15 Jun 2026 23:45:05 +0200
Subject: [PATCH 49/55] Populate nested repeaters when pasting a block
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Repeater::$onAddItemCalled is a static flag set during init() of the repeater
handling an onAddItem request. While set, every repeater — including any nested
repeater inside the new item — skips processItems() (Repeater.php:158,179).
That is intended to stop a freshly added empty item pulling a sibling's data,
but it also prevented a pasted block's nested repeaters (e.g. a gallery's media
directories) from building their rows from the seeded paste data, so they
rendered empty.

When pasting, clear the static flag for the duration of building and rendering
the new item (restored in a finally), so nested repeaters populate from the
seeded data. Non-paste palette adds are unaffected — the flag is only cleared
when _paste_data is present.

Verified: pasting/duplicating a gallery now brings across its media directory
rows with folder values and switch states intact.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 formwidgets/Blocks.php | 30 +++++++++++++++++++++++++-----
 1 file changed, 25 insertions(+), 5 deletions(-)

diff --git a/formwidgets/Blocks.php b/formwidgets/Blocks.php
index 38682da..e31c6d9 100644
--- a/formwidgets/Blocks.php
+++ b/formwidgets/Blocks.php
@@ -231,25 +231,45 @@ public function onAddItem()
         $index = $this->getNextIndex();
 
         $pasteConfig = null;
+        $isPaste = false;
         if ($pasteRaw = post('_paste_data')) {
             $decoded = json_decode($pasteRaw, true);
             if (is_array($decoded)) {
                 $this->pasteData[$index] = $decoded;
                 $pasteConfig = post('_paste_config') ?: null;
+                $isPaste = true;
             }
         }
 
-        $this->prepareVars();
-        $this->vars['widget'] = $this->makeItemFormWidget($index, $groupCode);
-        $this->vars['indexValue'] = $index;
-        $this->indexConfigMeta[$index] = $pasteConfig;
+        // Repeater::$onAddItemCalled is a *static* flag set during init() of the
+        // repeater handling this AJAX request. While set, every repeater —
+        // including any nested repeater inside the new item — skips processItems()
+        // (Repeater.php:158,179), which normally stops a new empty item pulling a
+        // sibling's data. But when pasting we *want* the new item's nested
+        // repeaters to build their rows from the seeded data, so clear the flag
+        // for the duration of the build/render and restore it afterwards.
+        $restoreAddItemFlag = self::$onAddItemCalled;
+        if ($isPaste) {
+            self::$onAddItemCalled = false;
+        }
+
+        try {
+            $this->prepareVars();
+            $this->vars['widget'] = $this->makeItemFormWidget($index, $groupCode);
+            $this->vars['indexValue'] = $index;
+            $this->indexConfigMeta[$index] = $pasteConfig;
+
+            $html = $this->makePartial('block_item') . $this->makePartial('block_add_item');
+        } finally {
+            self::$onAddItemCalled = $restoreAddItemFlag;
+        }
 
         $itemContainer = '@#' . $this->getId('items');
         $addItemContainer = '#' . $this->getId('add-item');
 
         return [
             $addItemContainer => '',
-            $itemContainer => $this->makePartial('block_item') . $this->makePartial('block_add_item')
+            $itemContainer => $html
         ];
     }
 

From 25bce55a2b4416638ed432325370a5e5ba9fb270 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Mon, 15 Jun 2026 23:54:20 +0200
Subject: [PATCH 50/55] Avoid rebuilding existing items on paste
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The nested-repeater paste fix cleared the static $onAddItemCalled flag before
prepareVars(), which made the outer repeater re-process every existing item's
form widget on each paste — wasted work on pages with many blocks, since the
handler only renders the new item.

Run prepareVars() with the flag still set (outer skips re-processing), then
clear it only around building and rendering the new item, so nested repeaters
still populate from the seeded data without touching the rest of the list.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 formwidgets/Blocks.php | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/formwidgets/Blocks.php b/formwidgets/Blocks.php
index e31c6d9..ce58bf0 100644
--- a/formwidgets/Blocks.php
+++ b/formwidgets/Blocks.php
@@ -241,20 +241,24 @@ public function onAddItem()
             }
         }
 
+        // Keep the static $onAddItemCalled flag set during prepareVars() so the
+        // OUTER repeater skips re-processing every existing item (Repeater.php:179)
+        // — we only render the new item here, so rebuilding the rest is wasted work.
+        $this->prepareVars();
+
         // Repeater::$onAddItemCalled is a *static* flag set during init() of the
         // repeater handling this AJAX request. While set, every repeater —
         // including any nested repeater inside the new item — skips processItems()
         // (Repeater.php:158,179), which normally stops a new empty item pulling a
         // sibling's data. But when pasting we *want* the new item's nested
         // repeaters to build their rows from the seeded data, so clear the flag
-        // for the duration of the build/render and restore it afterwards.
+        // only while building and rendering the new item, then restore it.
         $restoreAddItemFlag = self::$onAddItemCalled;
         if ($isPaste) {
             self::$onAddItemCalled = false;
         }
 
         try {
-            $this->prepareVars();
             $this->vars['widget'] = $this->makeItemFormWidget($index, $groupCode);
             $this->vars['indexValue'] = $index;
             $this->indexConfigMeta[$index] = $pasteConfig;

From 1d54d966ecb230efba566bd2ec2729c21f58648d Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Mon, 15 Jun 2026 23:59:42 +0200
Subject: [PATCH 51/55] Update CHANGELOG and README for perf cache and
 server-side copy/paste

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md | 19 ++++++++++++++++++-
 README.md    |  4 ++--
 2 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a048144..f7b69bb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -24,18 +24,35 @@
   a different `type`.
 - Missing include files are skipped and logged as a warning.
 
+### Performance
+- **Cross-request config cache** — `BlockManager::getConfigs()` now stores
+  built block configs in the Laravel cache (default: file/database driver),
+  keyed by an md5 signature of every block file's mtime. On warm requests the
+  full config build (~17–97ms for ~100 blocks) is replaced by a cheap mtime
+  check (~0.1ms). The cache self-invalidates when any `.block` file or any
+  `include`d YAML file changes, so no manual `php artisan cache:clear` is
+  needed after editing blocks. A per-request in-memory memo prevents even the
+  mtime check from running more than once per request.
+
 ### Editor UX
 - **Recently used blocks** are pinned to the top of the "add block" palette
   (tracked in `localStorage`, most-recent first).
 - **Copy / Cut / Paste / Duplicate blocks** — each block has one horizontal
   toolbar (collapse, copy, cut, paste, duplicate, config, delete). Copy/cut/
-  duplicate place the block's field values on the clipboard (`sessionStorage`);
+  duplicate place the block's full field data on the clipboard (`sessionStorage`);
   paste inserts after a block, or appends via a "Paste block" entry at the top
   of the *+ Add New Item* palette (for empty widgets). Duplicate also clones in
   place. Paste affordances appear only where the copied block type is offered
   (respects `allow`/`ignore`/`tags`) and survive navigation within the same
   browser tab. Direct add/paste/duplicate requests run the same empty-add-item
   cleanup as the core popover flow, so "Add new item" rows no longer pile up.
+- **Server-side copy/paste** — copying a block calls `onCopyItem`, which builds
+  the block's Form widget server-side and calls `getSaveData()`. This correctly
+  captures every field type — switches, mediafinders, and nested repeaters with
+  their own rows — which a client-side DOM scrape cannot. The clipboard payload
+  (`{group, config, data}`) is sent back to `onAddItem` as `_paste_data`, which
+  seeds the new item via `getValueFromIndex()` before rendering, so the pasted
+  block appears fully populated without a round-trip DOM fill step.
 
 ### Tests
 - `BlockManagerTest`: include merging, block-overrides-include precedence,
diff --git a/README.md b/README.md
index f4c48d2..3f68b85 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ Provides a "block based" content management experience in Winter CMS
 
 >**NOTE:** This plugin is still in development and is likely to undergo changes. Do not use in production environments without using a version constraint in your composer.json file and carefully monitoring for breaking changes.
 
-> **Block definition features:** **collapsible sections** (with persisted state), **shared field includes** (with nested includes), and **recently used blocks** in the palette. See [Collapsible Sections](#collapsible-sections), [Including shared field definitions](#including-shared-field-definitions), and [Recently used blocks](#recently-used-blocks) below. Full list in [CHANGELOG.md](CHANGELOG.md).
+> **Block definition features:** **collapsible sections** (with persisted state), **shared field includes** (with nested includes), **recently used blocks** in the palette, and a **cross-request config cache** for fast backend page loads. Copy/Cut/Paste/Duplicate is fully server-side and captures all field types (switches, mediafinders, nested repeaters). See [Collapsible Sections](#collapsible-sections), [Including shared field definitions](#including-shared-field-definitions), [Recently used blocks](#recently-used-blocks), and [Cut, paste and duplicate blocks](#cut-paste-and-duplicate-blocks) below. Full list in [CHANGELOG.md](CHANGELOG.md).
 
 ## Installation
 
@@ -268,7 +268,7 @@ Use **Duplicate** for a quick in-place clone. Use **Paste after** (or **Paste bl
 
 Paste/duplicate respect the widget's `allow` / `ignore` / `tags` constraints: the paste affordances only appear where the copied block type is actually offered. The clipboard persists for the duration of the browser session (`sessionStorage`), so you can paste across different pages in the same tab.
 
-> **Note on nested blocks:** Field values — including nested `blocks` fields, which store their content as JSON — are captured and restored correctly. Rich-text and code editor widgets are refreshed automatically via their own APIs after paste. Field matching uses the trailing name segment (e.g. `content` from `Blocks[0][content]`), so two fields in the same block that share the same trailing key would collide — avoid duplicate field keys within a single block definition.
+> **How copy/paste works:** Copying a block calls a server-side handler (`onCopyItem`) that builds the block's form widget and calls `getSaveData()`. This correctly captures every field type — including switches, mediafinders, and nested repeaters with their own rows — which a client-side DOM scrape cannot. The payload is stored in `sessionStorage` and sent back on paste, where the new item is rendered server-side pre-populated. Rich-text and code editor widgets are refreshed via their own APIs after the item is inserted into the DOM.
 
 ---
 

From 394a0169da7c32783c9367a88a910deadce0650f Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Sat, 20 Jun 2026 08:35:17 +0200
Subject: [PATCH 52/55] Remove fork-specific install note from README

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 README.md | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/README.md b/README.md
index 3f68b85..f2cd093 100644
--- a/README.md
+++ b/README.md
@@ -11,16 +11,6 @@ Provides a "block based" content management experience in Winter CMS
 > **Block definition features:** **collapsible sections** (with persisted state), **shared field includes** (with nested includes), **recently used blocks** in the palette, and a **cross-request config cache** for fast backend page loads. Copy/Cut/Paste/Duplicate is fully server-side and captures all field types (switches, mediafinders, nested repeaters). See [Collapsible Sections](#collapsible-sections), [Including shared field definitions](#including-shared-field-definitions), [Recently used blocks](#recently-used-blocks), and [Cut, paste and duplicate blocks](#cut-paste-and-duplicate-blocks) below. Full list in [CHANGELOG.md](CHANGELOG.md).
 
 ## Installation
-
-> **Using this fork?** Clone it directly into your Winter CMS plugins directory:
-> ```bash
-> git clone https://github.com/helmutkaufmann/wn-blocks-plugin-1.git plugins/winter/blocks
-> ```
-> To update to the latest version:
-> ```bash
-> git -C plugins/winter/blocks pull
-> ```
-
 This plugin is available for installation via [Composer](http://getcomposer.org/).
 
 ```bash

From f90787607a57df37d4c0798ceaba7a0b4bf70532 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Mon, 22 Jun 2026 05:03:30 +0200
Subject: [PATCH 53/55] Fix review issues: include precedence, missing-file
 cache tracking, storageKey scoping, and dead code

- resolveIncludes: capture original block fields before the include loop so the
  block always wins on collision and later includes correctly override earlier
  ones (not the already-merged result)
- resolveIncludes: record missing include paths in touchedIncludes with mtime 0
  so the cache invalidates if the file is later created
- onCopyItem: call prepareVars() before makeItemFormWidget() so groupDefinitions
  is populated (matches onAddItem/render pattern)
- storageKey: scope localStorage key to data-widget-id so sections with the same
  field name in different block widgets don't share state
- warnOnTypeCollisions: remove unreachable is_array guard (params are typed array)
- blocks.less: replace .transform() mixin with plain CSS transform property
- version.yaml: remove stale "Tabs and secondaryTabs" entry not in this PR

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 classes/BlockManager.php                   | 34 +++++++++++++---------
 formwidgets/Blocks.php                     |  1 +
 formwidgets/blocks/assets/less/blocks.less |  2 +-
 formwidgets/blocks/partials/_block.php     |  6 +++-
 updates/version.yaml                       |  1 -
 5 files changed, 28 insertions(+), 16 deletions(-)

diff --git a/classes/BlockManager.php b/classes/BlockManager.php
index 18d1d18..0cb9af1 100644
--- a/classes/BlockManager.php
+++ b/classes/BlockManager.php
@@ -284,6 +284,15 @@ protected function resolveIncludes(array $config, array $visited = []): array
 
         $mergeKeys = ['fields', 'config'];
 
+        // Capture the block's own definitions before the loop so that each
+        // include sees the original block values, not a previously merged result.
+        // This ensures the block always wins on collision regardless of include order,
+        // and that later includes correctly override earlier ones (not the merged state).
+        $ownByKey = [];
+        foreach ($mergeKeys as $key) {
+            $ownByKey[$key] = (isset($config[$key]) && is_array($config[$key])) ? $config[$key] : [];
+        }
+
         foreach ($paths as $path) {
             if (!is_string($path) || $path === '') {
                 continue;
@@ -292,6 +301,11 @@ protected function resolveIncludes(array $config, array $visited = []): array
             $realPath = File::symbolizePath($path);
             if (!$realPath || !File::exists($realPath)) {
                 Log::warning("Winter.Blocks: included file not found: {$path}");
+                // Record even missing files so the cache invalidates if they are created later.
+                if ($realPath) {
+                    $canonical = PathResolver::standardize($realPath);
+                    $this->touchedIncludes[$canonical] = 0;
+                }
                 continue;
             }
 
@@ -318,13 +332,14 @@ protected function resolveIncludes(array $config, array $visited = []): array
                     continue;
                 }
 
-                $own = (isset($config[$key]) && is_array($config[$key])) ? $config[$key] : [];
+                $own = $ownByKey[$key];
 
                 // Warn when a field is redefined with a different type.
                 $this->warnOnTypeCollisions($key, $included[$key], $own);
 
-                // Included definitions form the base; the block's own win on collision.
-                $config[$key] = array_replace_recursive($included[$key], $own);
+                // Included definitions form the base; the block's own definitions always win.
+                // Later includes override earlier ones; the block overrides all.
+                $config[$key] = array_replace_recursive($included[$key], $config[$key] ?? [], $own);
             }
         }
 
@@ -339,20 +354,13 @@ protected function resolveIncludes(array $config, array $visited = []): array
      */
     protected function warnOnTypeCollisions(string $key, array $included, array $own): void
     {
-        $includedFields = $included;
-        $ownFields = $own;
-
-        if (!is_array($includedFields) || !is_array($ownFields)) {
-            return;
-        }
-
-        foreach ($includedFields as $name => $def) {
-            if (!isset($ownFields[$name]) || !is_array($def) || !is_array($ownFields[$name])) {
+        foreach ($included as $name => $def) {
+            if (!isset($own[$name]) || !is_array($def) || !is_array($own[$name])) {
                 continue;
             }
 
             $includedType = $def['type'] ?? null;
-            $ownType = $ownFields[$name]['type'] ?? null;
+            $ownType = $own[$name]['type'] ?? null;
 
             if ($includedType && $ownType && $includedType !== $ownType) {
                 Log::warning(
diff --git a/formwidgets/Blocks.php b/formwidgets/Blocks.php
index ce58bf0..d628fe8 100644
--- a/formwidgets/Blocks.php
+++ b/formwidgets/Blocks.php
@@ -203,6 +203,7 @@ public function onCopyItem()
         $index = post('_repeater_index');
         $groupCode = post('_repeater_group');
 
+        $this->prepareVars();
         $widget = $this->makeItemFormWidget($index, $groupCode);
 
         // The Inspector config is repeater meta, not a form field, so read it
diff --git a/formwidgets/blocks/assets/less/blocks.less b/formwidgets/blocks/assets/less/blocks.less
index 386aaf8..0336375 100644
--- a/formwidgets/blocks/assets/less/blocks.less
+++ b/formwidgets/blocks/assets/less/blocks.less
@@ -64,7 +64,7 @@
     // Rotate the collapse chevron when the item is collapsed (it now lives in
     // the toolbar rather than the original .repeater-item-collapse wrapper).
     .field-block-item.collapsed > .repeater-item-remove .repeater-item-collapse-one {
-        .transform(rotate(180deg));
+        transform: rotate(180deg);
     }
 
     .field-block-items {
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index 5305748..672604d 100644
--- a/formwidgets/blocks/partials/_block.php
+++ b/formwidgets/blocks/partials/_block.php
@@ -8,6 +8,7 @@
     data-add-handler="<?= $this->getEventHandler('onAddItem') ?>"
     data-copy-handler="<?= $this->getEventHandler('onCopyItem') ?>"
     data-block-codes="<?= e(implode(',', array_keys($groupDefinitions))) ?>"
+    data-widget-id="<?= $this->getId() ?>"
     <?php if ($mode === 'grid'): ?> data-columns="<?= $columns ?>" <?php endif ?>
     <?php if ($sortable) : ?>
     data-sortable="true"
@@ -385,7 +386,10 @@ function setCollapsed(section, collapsed) {
 
         function storageKey(section) {
             var name = section.getAttribute('data-field-name') || '';
-            return name ? (COLLAPSE_PREFIX + name) : null;
+            if (!name) { return null; }
+            var fieldBlocks = section.closest('.field-blocks');
+            var widgetId = fieldBlocks ? (fieldBlocks.getAttribute('data-widget-id') || '') : '';
+            return COLLAPSE_PREFIX + (widgetId ? widgetId + ':' : '') + name;
         }
 
         function initSections() {
diff --git a/updates/version.yaml b/updates/version.yaml
index c979367..a191575 100644
--- a/updates/version.yaml
+++ b/updates/version.yaml
@@ -2,7 +2,6 @@
     - 'First version of Winter.Blocks'
 '1.1.0':
     - 'Collapsible sections with persisted state'
-    - 'Tabs and secondaryTabs support in block definitions'
     - 'Shared field includes with nested include resolution'
     - 'Recently used blocks pinned to the Add Block palette'
     - 'Copy, cut, paste after, and duplicate blocks'

From ce476408265b2a987386a12ba37fe3019f4ea9f1 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Mon, 6 Jul 2026 19:27:44 +0200
Subject: [PATCH 54/55] Add component: key support to block config resolution

---
 classes/BlockManager.php | 77 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/classes/BlockManager.php b/classes/BlockManager.php
index 0cb9af1..0080a7c 100644
--- a/classes/BlockManager.php
+++ b/classes/BlockManager.php
@@ -194,6 +194,7 @@ protected function buildConfigs(string|array|null $tags = null): array
             );
 
             $config = $this->resolveIncludes($config);
+            $config = $this->resolveComponent($config);
 
             $configs[pathinfo($block['fileName'])['filename']] = $config;
         }
@@ -346,6 +347,82 @@ protected function resolveIncludes(array $config, array $visited = []): array
         return $config;
     }
 
+    /**
+     * Resolves a `component:` key in a block config by merging the component's
+     * `defineProperties()` into the block's `fields:` as base definitions.
+     *
+     * A block may declare:
+     *
+     *     component: mfaGateway
+     *
+     * The component's `defineProperties()` entries are converted to block field
+     * definitions and merged as defaults; the block's own `fields:` always win.
+     *
+     * Property-to-field mapping:
+     *   title       → label
+     *   description → comment
+     *   type        → type (string → text, dropdown → dropdown, checkbox → checkbox)
+     *   default     → default
+     */
+    protected function resolveComponent(array $config): array
+    {
+        if (empty($config['component']) || !is_string($config['component'])) {
+            unset($config['component']);
+            return $config;
+        }
+
+        $componentName = $config['component'];
+        unset($config['component']);
+
+        try {
+            $class = \Cms\Classes\ComponentManager::instance()->resolve($componentName);
+            if (!$class) {
+                Log::warning("Winter.Blocks: component '{$componentName}' not found for block.");
+                return $config;
+            }
+
+            /** @var \Cms\Classes\ComponentBase $instance */
+            $instance = new $class();
+            $properties = method_exists($instance, 'defineProperties') ? $instance->defineProperties() : [];
+
+            // Map component type names to block/form field type names.
+            $typeMap = [
+                'string'   => 'text',
+                'text'     => 'text',
+                'integer'  => 'number',
+                'float'    => 'number',
+                'checkbox' => 'checkbox',
+                'dropdown' => 'dropdown',
+                'set'      => 'checkboxlist',
+            ];
+
+            $fromComponent = [];
+            foreach ($properties as $name => $def) {
+                $propType  = $def['type'] ?? 'string';
+                $fieldType = $typeMap[$propType] ?? 'text';
+                $field = [
+                    'label'   => $def['title']       ?? $name,
+                    'type'    => $fieldType,
+                ];
+                if (isset($def['default']))     $field['default'] = $def['default'];
+                if (!empty($def['description'])) $field['comment'] = $def['description'];
+                if (!empty($def['placeholder'])) $field['placeholder'] = $def['placeholder'];
+                if (!empty($def['options']))     $field['options'] = $def['options'];
+
+                $fromComponent[$name] = $field;
+            }
+
+            // Block's own fields win; component fields fill in the rest.
+            $ownFields = (isset($config['fields']) && is_array($config['fields'])) ? $config['fields'] : [];
+            $config['fields'] = array_replace($fromComponent, $ownFields);
+
+        } catch (\Throwable $e) {
+            Log::warning("Winter.Blocks: could not resolve component '{$componentName}': " . $e->getMessage());
+        }
+
+        return $config;
+    }
+
     /**
      * Logs a warning when merging an include would redefine a field with a
      * different `type`, which is almost always a mistake. Field definitions live

From db4194f46ea801d73ef49ba1b3beae4009724695 Mon Sep 17 00:00:00 2001
From: Helmut Kaufmann <shopping@mercator.li>
Date: Wed, 8 Jul 2026 03:32:49 +0200
Subject: [PATCH 55/55] Fix Stylelint error: replace .transform() mixin with
 plain CSS transform

Matches upstream fix in f907876 for the .repeater-item-collapse-one
chevron rotation, which uses an equivalent but differently-scoped selector.
---
 formwidgets/blocks/assets/less/blocks.less | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/formwidgets/blocks/assets/less/blocks.less b/formwidgets/blocks/assets/less/blocks.less
index 0336375..985e028 100644
--- a/formwidgets/blocks/assets/less/blocks.less
+++ b/formwidgets/blocks/assets/less/blocks.less
@@ -133,7 +133,7 @@
 
             > .repeater-item-collapse {
                 .repeater-item-collapse-one {
-                    .transform(rotate(180deg));
+                    transform: rotate(180deg);
                 }
             }