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/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..a048144
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,52 @@
+# Changelog
+
+## Unreleased
+
+### 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).
+
+### Shared field includes
+- `.block` definitions may declare a top-level `include:` (string or list) to
+  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
+  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).
+- **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,
+  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.
+- Stopped tracking `.DS_Store` files.
diff --git a/README.md b/README.md
index ba775ce..f4c48d2 100644
--- a/README.md
+++ b/README.md
@@ -8,8 +8,19 @@ 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).
+
 ## 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
@@ -99,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
@@ -144,6 +155,123 @@ config:
 </{{ config.size }}>
 ```
 
+## Collapsible Sections
+
+Block fields that use `type: section` can be made collapsible directly in the block YAML.
+
+```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. 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 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.
+
+---
+
+## 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` or `config`:
+
+```yaml
+# blocks/_seo.yaml
+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:
+
+```yaml
+include:
+    - $/myauthor/myplugin/blocks/_seo.yaml
+    - ~/app/blocks/_tracking.yaml
+```
+
+**Merge rules:**
+
+| | |
+|---|---|
+| 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 |
+| 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()`:
+
+| Symbol | Resolves to |
+|---|---|
+| `$/author/plugin/...` | `plugins/author/plugin/...` |
+| `~/...` | application root |
+| `#/...` | `storage/app/...` |
+
+This works for `collapsible` sections too — an included file can define a complete collapsible section that every block reuses without copy-paste.
+
+---
+
+## 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.
+
+---
+
+## Cut, paste and duplicate blocks
+
+Every block has a single horizontal toolbar (top-right) with, in order:
+**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 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.
+
+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.
+
+> **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.
+
+---
+
 ## 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..adec9ce 100644
--- a/classes/BlockManager.php
+++ b/classes/BlockManager.php
@@ -7,6 +7,8 @@
 use Cms\Classes\Theme;
 use Event;
 use File;
+use Log;
+use Yaml;
 use System\Classes\PluginManager;
 use Winter\Storm\Support\Traits\Singleton;
 use Winter\Storm\Support\Str;
@@ -98,7 +100,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 +110,127 @@ 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` and `config`. Included definitions are
+     * 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 $visited = []): array
+    {
+        if (empty($config['include'])) {
+            unset($config['include']);
+            return $config;
+        }
+
+        $paths = (array) $config['include'];
+        unset($config['include']);
+
+        $mergeKeys = ['fields', 'config'];
+
+        foreach ($paths as $path) {
+            if (!is_string($path) || $path === '') {
+                continue;
+            }
+
+            $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;
+            }
+
+            $included = Yaml::parse(File::get($realPath));
+            if (!is_array($included)) {
+                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], $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
+    {
+        $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])) {
+                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/composer.json b/composer.json
index afb381d..237205e 100644
--- a/composer.json
+++ b/composer.json
@@ -14,6 +14,12 @@
             "name": "Winter CMS Maintainers",
             "homepage": "https://wintercms.com",
             "role": "Maintainer"
+        },
+        {
+            "name": "Helmut Kaufmann",
+            "homepage": "https://mercator.li",
+            "email": "software@mercator.li",
+            "role": "Contributor"
         }
     ],
     "support": {
diff --git a/formwidgets/Blocks.php b/formwidgets/Blocks.php
index 04b2391..1461e16 100644
--- a/formwidgets/Blocks.php
+++ b/formwidgets/Blocks.php
@@ -53,6 +53,9 @@ protected function loadAssets()
     {
         $this->addCss('css/blocks.css', 'Winter.Blocks');
         $this->addJs('js/blocks.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.
     }
 
     /**
@@ -203,12 +206,12 @@ 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', [])),
+                'config'        => array_get($config, 'config', null),
             ];
         }
 
@@ -219,6 +222,50 @@ 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;
+
+                // 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-block-collapsible' => 1]
+                );
+
+                if (!$startCollapsed) {
+                    $field['containerAttributes']['data-block-collapsible-open'] = 1;
+                }
+            }
+
+            unset($field['collapsible'], $field['collapsed']);
+        }
+
+        return $fields;
+    }
+
     /**
      * Determines if a block is allowed according to the widget's ignore/allow list.
      */
diff --git a/formwidgets/blocks/assets/less/blocks.less b/formwidgets/blocks/assets/less/blocks.less
index 4d6f7a0..386aaf8 100644
--- a/formwidgets/blocks/assets/less/blocks.less
+++ b/formwidgets/blocks/assets/less/blocks.less
@@ -5,6 +5,68 @@
 .field-blocks {
     padding-top: 5px;
 
+    // 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.
+    .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: @text-color;
+        opacity: .6;
+        font-size: 13px;
+        line-height: 1;
+        border-radius: 3px;
+        transition: background .15s, color .15s, opacity .15s;
+
+        > i { line-height: 1; }
+
+        &:hover,
+        &:focus {
+            opacity: 1;
+            background: rgba(0, 0, 0, .06);
+            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));
+    }
+
     .field-block-items {
         counter-reset: repeater-index-counter;
     }
diff --git a/formwidgets/blocks/partials/_block.php b/formwidgets/blocks/partials/_block.php
index c4d2f04..4d65489 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"
@@ -69,6 +71,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>
@@ -85,4 +88,469 @@ class="form-control blocks-group-search"
             </div>
         </div>
     </script>
+
+    <?php
+    /*
+     * 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.
+     *
+     * 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.__blockEnhancementsInit) { return; }
+        window.__blockEnhancementsInit = true;
+
+        var READY = 'block-collapsible-ready';
+        var COLLAPSE_PREFIX = 'wnBlocksCollapse:';
+        var RECENT_KEY = 'wnBlocksRecent';
+        var RECENT_MAX = 6;
+        var CLIPBOARD_KEY = 'wnBlocksClipboard';
+
+        // --- inject toolbar styles once ------------------------------------
+        // Kept here (rather than only in blocks.less) so the per-block toolbar
+        // (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; }
+            var css =
+                '.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)}' +
+                // 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}';
+            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; }
+        }
+        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 }));
+                }
+            });
+            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
+        // data-block-codes list rendered server-side on the .field-blocks element.
+        function blockTypeAvailable(fieldBlocks, group) {
+            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.
+        // 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');
+                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); }
+            });
+        }
+
+        // The onAddItem AJAX handler name, rendered server-side on .field-blocks.
+        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
+        // the rest. Document-level delegation also covers dynamically added blocks.
+        document.addEventListener('click', function (e) {
+            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'); }
+        });
+
+        // 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) {
+            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; }
+            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);
+        });
+
+        // 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)));
+            updatePasteButtons();
+            var removeBtn = li.querySelector('[data-repeater-remove]');
+            if (removeBtn) { removeBtn.click(); }
+        });
+
+        // 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 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 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));
+
+            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();
+            }
+            if (!show) { return; }
+
+            var capturedFieldBlocks = fieldBlocks;
+            var capturedGroup = cb.group;
+            var capturedFields = cb.fields;
+
+            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 () {
+                requestAdd(capturedFieldBlocks, capturedGroup, capturedFields, null);
+            });
+
+            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
+        // 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; }
+            e.preventDefault();
+            e.stopPropagation();
+            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);
+        });
+
+        // --- collapsible sections ------------------------------------------
+        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 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 + ')'
+            ).forEach(function (section) {
+                section.classList.add(READY);
+                var header = section.querySelector('.field-section');
+                if (header) { header.classList.add('is-collapsible'); }
+
+                // 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; }
+            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'));
+        });
+
+        // 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);
+                        }
+                    });
+                });
+        }
+
+        // Add the "Paste block" entry to any open Add-Item palette grid. Runs after
+        // applyRecent so it ends up first. Idempotent via the data-paste-group guard.
+        function applyPalettePaste() {
+            document.querySelectorAll('.blocks-group-grid').forEach(injectPalettePaste);
+        }
+
+        // --- shared init + observer ----------------------------------------
+        function runAll() {
+            initSections();
+            applyRecent();
+            applyPalettePaste();
+        }
+
+        // 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.
+            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')) {
+                            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);
+                        }
+                    });
+                }
+            }
+            // 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;
+                var hadNewNodes = pendingNewNodes;
+                pendingNewNodes = false;
+                initSections();
+                applyRecent();
+                applyPalettePaste();
+                if (hadNewNodes) {
+                    updatePasteButtons();
+                    document.querySelectorAll('.field-blocks').forEach(cleanupAddItems);
+                }
+            }, 0);
+        });
+        function startObserving() {
+            if (document.body) {
+                observer.observe(document.body, { childList: true, subtree: true });
+            } else {
+                document.addEventListener('DOMContentLoaded', startObserving);
+            }
+        }
+        startObserving();
+    })();
+    </script>
 </div>
diff --git a/formwidgets/blocks/partials/_block_item.php b/formwidgets/blocks/partials/_block_item.php
index 1268bd4..b039267 100644
--- a/formwidgets/blocks/partials/_block_item.php
+++ b/formwidgets/blocks/partials/_block_item.php
@@ -10,28 +10,63 @@ 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">
+    <?php
+    /*
+     * All item controls live in one horizontal toolbar so they never overflow.
+     * Order: collapse, copy, 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="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>
+            <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-clone"></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="close"
+                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 ?>
-
-    <?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>
 
@@ -44,22 +79,6 @@ class="close"
         <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') ?>"
diff --git a/tests/classes/BlockManagerTest.php b/tests/classes/BlockManagerTest.php
index 7851af0..710e12a 100644
--- a/tests/classes/BlockManagerTest.php
+++ b/tests/classes/BlockManagerTest.php
@@ -35,6 +35,151 @@ 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 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']);
+
+        // 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);
+    }
+
+    /**
+     * @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..5c7258d
--- /dev/null
+++ b/tests/fixtures/blocks/includes/_shared.yaml
@@ -0,0 +1,11 @@
+fields:
+    shared_field:
+        label: Shared
+        type: text
+    overridden:
+        label: From include
+        type: text
+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');
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'
diff --git a/winter.mix.js b/winter.mix.js
index 082f4b8..73e437c 100644
--- a/winter.mix.js
+++ b/winter.mix.js
@@ -1,5 +1,12 @@
 const mix = require('laravel-mix');
 
+/*
+ * 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)
     .js('assets/src/js/blocks.js', 'assets/dist/js/blocks.js')