diff --git a/composer.json b/composer.json
index a9cb3037df9..dda863ad389 100644
--- a/composer.json
+++ b/composer.json
@@ -53,6 +53,7 @@
     "laravel/wayfinder": "^0.1.12",
     "league/commonmark": "^2.8",
     "league/flysystem-path-prefixing": "^3.31",
+    "league/fractal": "^0.21.0",
     "league/uri": "^7.0",
     "moneyphp/money": "^4.0",
     "phpoffice/phpspreadsheet": "^5.3",
diff --git a/composer.lock b/composer.lock
index 9854d798af5..62aa45b8da6 100644
--- a/composer.lock
+++ b/composer.lock
@@ -2976,6 +2976,76 @@
             },
             "time": "2026-01-23T15:30:45+00:00"
         },
+        {
+            "name": "league/fractal",
+            "version": "0.21",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/thephpleague/fractal.git",
+                "reference": "9e817358dc451dfdcf656d6757f0c04e92dea0e8"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/thephpleague/fractal/zipball/9e817358dc451dfdcf656d6757f0c04e92dea0e8",
+                "reference": "9e817358dc451dfdcf656d6757f0c04e92dea0e8",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=7.4"
+            },
+            "require-dev": {
+                "doctrine/orm": "^2.5",
+                "friendsofphp/php-cs-fixer": "^3.91",
+                "illuminate/contracts": "~5.0",
+                "laminas/laminas-paginator": "~2.12",
+                "mockery/mockery": "^1.3",
+                "pagerfanta/pagerfanta": "~1.0.0|~4.0.0",
+                "phpstan/phpstan": "^1.4",
+                "phpunit/phpunit": "^9.5",
+                "vimeo/psalm": "^4.30"
+            },
+            "suggest": {
+                "illuminate/pagination": "The Illuminate Pagination component.",
+                "laminas/laminas-paginator": "Laminas Framework Paginator",
+                "pagerfanta/pagerfanta": "Pagerfanta Paginator"
+            },
+            "type": "library",
+            "extra": {
+                "branch-alias": {
+                    "dev-master": "0.20.x-dev"
+                }
+            },
+            "autoload": {
+                "psr-4": {
+                    "League\\Fractal\\": "src"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Phil Sturgeon",
+                    "email": "me@philsturgeon.uk",
+                    "homepage": "http://philsturgeon.uk/",
+                    "role": "Developer"
+                }
+            ],
+            "description": "Handle the output of complex data structures ready for API output.",
+            "homepage": "http://fractal.thephpleague.com/",
+            "keywords": [
+                "api",
+                "json",
+                "league",
+                "rest"
+            ],
+            "support": {
+                "issues": "https://github.com/thephpleague/fractal/issues",
+                "source": "https://github.com/thephpleague/fractal/tree/0.21"
+            },
+            "time": "2025-12-08T21:14:52+00:00"
+        },
         {
             "name": "league/mime-type-detection",
             "version": "1.17.0",
diff --git a/docs/importing.md b/docs/importing.md
new file mode 100644
index 00000000000..0e53dbd14c2
--- /dev/null
+++ b/docs/importing.md
@@ -0,0 +1,363 @@
+# Craft CMS Import feature — current state on `feature/import`
+
+## 1. What the feature does
+
+Bulk-imports data from a JSON, CSV or XML file into Craft elements (entries, assets, users,
+addresses-as-nested-content) or into opted-in Eloquent models. It can create new records or find
+and update existing ones, and it understands nested content (Matrix, Addresses, Content Blocks)
+to arbitrary depth.
+
+Three ways to drive it: the control panel, a PHP config file, or the CLI.
+
+---
+
+## 2. Import configs
+
+An **import config** is one importer instance: source file, target class, mapping,
+match criteria, clearable items, keep-missing flags. Two flavours:
+
+- **Editable** — created in the CP, stored in `import_configs`. Has a `uid`.
+- **Non-editable** — defined in `config/craft/import.php`, read via
+  `Config::get('craft.import')`. No `uid`.
+
+`BaseImporter::isEditable()` is literally `isset($this->uid)`, which is what splits
+the two lists in the CP. `ImportConfig::getAllConfigs()` (`src/Import/ImportConfig.php:60`)
+merges DB rows with file closures, keys by handle, sorts by name, and memoises.
+An invalid file-based config is **skipped and logged** as a warning rather than
+blowing up the list.
+
+### File-based config shape
+
+Returns an array of closures, each returning a configured importer:
+
+```php
+return [
+    'myElementImport' => fn() => EntryImporter::create()
+        ->name('file - entry with plain text')
+        ->handle('fileEntryWithPlainText')
+        ->site('default')
+        ->file('resources/import/entry-with-plain-text.json')
+        ->matchCriteria(['title' => 'title']),
+];
+```
+
+The array key is only a fallback — configs are re-keyed by `handle`. File-based
+configs typically set no `->map()` and no `->fieldLayout()`; the transformer (or the
+per-row `type`/`sectionId` data) does that work, which is why one file-based config
+can span multiple sections and entry types in a single run.
+
+### What's persisted for an editable config
+
+`settings` JSON holds: `file`, `className`, `transformer`, `map`, `matchCriteria`,
+`clearableItems`, `keepMissingNestedElements`, plus `site` (uid) and `fieldLayout`.
+`createImporter()` replays these through the fluent setters on load — except `className`, whose
+target class is fixed at construction time by the importer subclass and has no setter at all; it's
+stored for display/introspection only and skipped on replay.
+
+---
+
+## 3. Import runs
+
+A **run** (`import_runs`) chains ordered steps. Each step is
+`['config' => <uid|handle>, 'file' => <optional>, 'batchSize' => <int|null>]`.
+
+`Import::dispatchImport()` resolves each step's config, builds an `Import` job, fires
+`ImportRunDispatching` (cancellable), then dispatches a single `ImportPipeline` job so
+the whole run shows as one named queue item. `ImportPipeline` wraps each step in its
+own `Bus::batch(...)->allowFailures()` and chains them, so steps run sequentially and
+one bad step doesn't kill the run.
+
+The `Import` job re-reads the file each time, slices off already-processed rows,
+processes `batchSize` items (default 5; **0 disables batching** and does everything in
+one job), and re-adds itself to the batch for the remainder. Per-item failures are
+logged and skipped, not fatal.
+
+---
+
+## 4. The two importers
+
+- **`ElementImporter`** is abstract. Each importable element type is represented by its own
+  concrete subclass, which implements `elementClass()` to name its target type: `EntryImporter`,
+  `AssetImporter`, `UserImporter` are the built-ins (there's no `UserTransformer`, so
+  `UserImporter` uses the default `ElementTransformer`). Adds `site` (required) and `fieldLayout`.
+  An element type is importable if and only if an `ElementImporter` subclass is registered for
+  it — `Address` has none, so it's never a standalone import target, only reachable as nested
+  content (Addresses field / User addresses container). `Import::getElementImporterTypeFor(string
+  $elementClass): ?string` looks up the registered subclass for a given element FQCN, returning
+  `null` if none is registered.
+- **`ModelImporter`** is abstract too, and works exactly the same way: each importable Eloquent
+  model is represented by its own concrete subclass, which implements `modelClass()` to name its
+  target. `SystemMessageImporter` is the only built-in. A model is importable if and only if a
+  `ModelImporter` subclass is registered for it — there's no marker interface. `ModelImporter`
+  still defaults `matchCriteria` to `['id' => 'id']`, though a subclass can override that in its
+  constructor (`SystemMessageImporter` matches on `key` + `language`, since incoming data won't
+  carry Craft's IDs). `Import::getModelImporterTypeFor(string $modelClass): ?string` looks up the
+  registered subclass for a given model FQCN, returning `null` if none is registered.
+
+Extra importer types — including importers for plugin-defined element types and models — register
+via the `RegisterImporterTypes` event (`$event->importers`).
+
+---
+
+## 5. Per-item pipeline
+
+`Import::importItem()` (`src/Import/Import.php:138`):
+
+1. `DataImporting` event (cancellable, can rewrite `$data`).
+2. Apply the map via `ImportHelper::remapData()` — only if a map is set.
+3. Collect `additionalMatchCriteria()` from the transformer.
+4. Resolve match criteria.
+5. Apply clearable items.
+6. Hand to the importer's `importItem()`.
+7. `DataImported` event.
+
+### 
+
+Resolution recurses through containers: rows carrying a `type` (Matrix blocks) look
+their criteria up under that type; untyped rows (addresses) use the container's criteria
+directly. It deliberately walks keys present in *either* the criteria or the data, so
+inline criteria on a container the config never configured still resolve.
+
+`matchCriteria` set to `null` means don't match at all — import everything as new.
+
+### Clearable items
+
+A tree of truthy leaves mirroring the match-criteria shape (a flat dot-notation list
+is accepted and expanded). Behaviour:
+
+- Marked clearable + value missing/empty → forced to `null` so it's explicitly applied.
+- **Not** marked clearable + value empty → the key is `unset()` entirely, so the
+  existing value is left untouched.
+
+"Empty" means null, whitespace-only string, or `[]`.
+
+---
+
+## 6. Saving an element
+
+`ElementImporter::importItem()` (`src/Element/Import/ElementImporter.php`):
+
+1. `getRootElement()` calls `$this->prepareNewRootElementForImport($data)` on the importer to get
+   a new element instance (per-type subclasses like `EntryImporter`/`AssetImporter` resolve the
+   entry type/volume here). If there are match criteria, it then queries with
+   `->drafts(null)->status(null)`, lets the importer adjust the query
+   (`$this->prepareRootElementImportQuery($element, $query)`) — scoping it by type/volume, for
+   example — typecasts criteria, and **forces the config's siteId** so it always wins over
+   anything in the criteria. If a match is found, the resolved element is passed back through
+   `prepareNewRootElementForImport()` so per-type subclasses can finish preparing it without
+   re-deriving the type.
+2. `markAsImporting()` — for existing and new elements alike.
+3. Transformer runs *after* the element is resolved, so it can see the existing element
+   via Fractal meta.
+4. Split the result into native attributes, custom fields, and container properties. Attributes
+   are applied via `$this->setAttributesForImport($element, $attributes)` on the importer (base
+   implementation strips `id`/`uid` and applies the rest via `setAttributesFromRequest()`;
+   `AssetImporter` overrides it to resolve filename/folder/temp-file handling and download).
+5. **Skip-unchanged optimisation**: snapshots attribute values and serialized field
+   values; if nothing changed, the element is never saved. Skipped for new elements or
+   when container data is present. A special case catches content blocks, whose
+   `serializeValue()` returns null while the block has no id.
+6. Validation scenario: `SCENARIO_LIVE` when `enabled && getEnabledForSite()`,
+   otherwise `SCENARIO_ESSENTIALS`.
+7. Enable keep-flags, save, restore flags in a `finally`.
+8. Log any nested elements pruned during the save.
+
+Container *properties* (as opposed to fields) go through
+`$element->importIntoContainerAttribute()` — only `User` defines it, for `addresses`.
+
+---
+
+## 7. Making things importable
+
+### Elements
+
+`Element` itself is deliberately thin here — it provides `markAsImporting()`, which sets
+`public private(set) bool $importing`, read by `Entry::canChangeAuthor()`-adjacent logic to
+bypass the logged-in-user requirement.
+
+The hooks that customize how a type participates in import instead live on the `ElementImporter`
+subclass for that type (see §4):
+
+- `elementClass()` — abstract; names the target element type.
+- `getDefaultTransformer()` — `ElementTransformer` by default; `EntryImporter` →
+  `EntryTransformer`, `AssetImporter` → `AssetTransformer`. There is no `UserTransformer`, so
+  `UserImporter` uses the default.
+- `prepareNewRootElementForImport(array &$data, ?ElementInterface $element = null):
+  ElementInterface`, `prepareRootElementImportQuery()`, `setAttributesForImport()` — per-type
+  hooks. `EntryImporter` resolves the entry type (from the configured `fieldLayout`, or from the
+  row's `typeId`) and scopes the match query by type; `AssetImporter` resolves the volume from
+  `fieldLayout` and does the heavy filename/folder/temp-file work in `setAttributesForImport()`.
+
+### The `Importable` attribute
+
+`CraftCms\Cms\Support\Attributes\Importable`:
+
+```php
+__construct(
+    public string $name,
+    public string $label,
+    public bool $excludeFromUiMapping = false,
+    public bool $isContainer = false,
+    public bool $canBeMatchCriteria = true,
+    public bool $canBeCleared = true,
+)
+```
+
+Both `name` and `label` are **required** positionally. Examples: `id`/`uid` are
+`canBeCleared: false`; `Entry::$_typeId` is `#[Importable('typeId', 'Type ID', true)]`
+(excluded from UI mapping since the field-layout-provider step covers it);
+`User::$_addresses` is the only `isContainer: true` property.
+
+### Field layout elements
+
+`ImportableFieldLayoutElementInterface` — `getFieldsForMapping()`,
+`canBeMatchCriteria()`, `canBeCleared()`. The default trait returns `false` for both,
+so this is opt-in per layout element — the opposite default to the attribute.
+Implementors: `TitleField`, `CustomField`, `FullNameField`, `UsernameField`,
+`EmailField`, `AffiliatedSiteField`, `AltField`, and the Address layout elements.
+`User::$email` is deliberately not attributed — it comes in via `EmailField`.
+
+### Container fields
+
+`ImportableElementContainerFieldInterface` adds `normalizeNestedEntryForImport()`,
+`getMappingUiPrefix()`, `validateMapping()`, `canKeepMissingNestedElements()`,
+`setKeepMissingNestedElements()`. Used by `Matrix`, `Addresses`, `ContentBlock`.
+Matrix and Addresses can keep missing nested elements; ContentBlock can't (single block).
+
+`FieldInterface::normalizeValueForImport($value, $importer, $rootOwner)` — base returns
+the value unchanged. Overridden by `BaseRelationField` (returns `[]` rather than null so
+relations actually clear), `Matrix`, `Addresses`, `ContentBlock`.
+
+---
+
+## 8. Nested data formats
+
+Matrix accepts three shapes:
+
+**Flat, own-type-per-row** — order preserved:
+```json
+"myMatrix": [
+  {"type": "blockEt", "title": "block 1", "fields": {"plainText": "one"}},
+  {"type": "blockEt", "title": "block 2", "fields": {"plainText": "two"}}
+]
+```
+
+**Grouped by type** — keyed by entry type handle, rows carry no `type`:
+```php
+'myMatrix' => [
+    'secondEt' => [['title' => 'block 1', 'plainText' => 'foo']],
+    'firstEt'  => [['title' => 'block 2', 'plainText' => 'bar']],
+]
+```
+
+**Explicit `sortOrder`/`entries`**:
+```php
+'myMatrix' => [
+    'sortOrder' => ['new:1', 'new:2'],
+    'entries' => ['new:1' => [...], 'new:2' => [...]],
+]
+```
+
+Notes:
+- A block with no `type`, or a type not allowed in the field, is **silently skipped**.
+- The `fields` wrapper is optional — `normalizeNestedEntryForImport()` moves custom
+  field handles into `fields` when it's absent.
+- Blocks are matched only when the owner already has an id, using the block's own
+  `matchCriteria`, scoped by field id, owner id and site.
+- Blocks absent from the incoming data are pruned by the normal nested save, unless kept.
+
+### Keeping missing nested elements
+
+`keepMissingNestedElements` is a tree mirroring the match-criteria shape, where each
+container's own decision lives under a reserved **`__keep__`** leaf alongside its
+children:
+
+```php
+['outerMatrix' => [
+    '__keep__' => true,
+    'someEntryType' => ['fields' => ['innerMatrix' => ['__keep__' => false]]],
+]]
+```
+
+Opt-in per field, per level — an outer field can keep while an inner one prunes.
+Pruned ids are captured via an `ElementDeleted` listener and logged.
+
+---
+
+## 9. Control panel
+
+Nav: **Import** → Configs / Runs. Permissions group `import`: `viewImportConfigs`
+(→ `saveImportConfigs`, `deleteImportConfigs`) and `viewImportRuns`
+(→ `saveImportRuns`, `deleteImportRuns`, `triggerImportRuns`).
+
+Screens are Vue/Inertia under `resources/js/pages/import/`:
+
+- `import` — hub with Configs/Runs tiles.
+- `import/configs` — two tables, editable and file-based. File-based rows get a Run
+  button (synchronous) and nothing else.
+- `import/configs/new|{handle}` — name, handle, description, importer type (reactive select),
+  then the importer's own settings form: data file, site, transformer. Choosing the importer type
+  for an element import (Entries / Assets / Users) *is* choosing the element type — there's no
+  separate "Element Type" field.
+- `import/configs/{handle}/field-layout-provider` — element imports only; redirects back
+  to edit for non-element imports.
+- `import/configs/{handle}/map` — the mapping table: **Destination / Incoming data /
+  Match / Clear**. Container rows show a "Map field" button opening a nested slideout
+  instead of a select; the slideout has the "Keep existing nested elements missing from
+  the imported data" checkbox and one section per field-layout provider, and nests
+  arbitrarily deep. All four trees are held client-side and posted together.
+- `import/runs` and `import/runs/new|{handle}` — steps table with config + batch size.
+
+Read-only: derived from `allowAdminChanges`. Save/delete actions are dropped and the
+forms render in read-only mode; only the map screen shows an explicit notice.
+Triggering runs is deliberately *not* gated on it.
+
+There is **no logs/history screen** — logging goes to a daily `import` channel at
+`storage/logs/import.log` (debug, 14 days), registered only if the app hasn't already
+defined one.
+
+---
+
+## 10. CLI
+
+```
+craft:import:element {elementType} {file}
+    [--site=] [--fieldLayoutProvider=] [--transformer=] [--matchCriteria=]
+```
+Alias `import/element`. Both arguments are positional and prompted if missing;
+`--site` is only prompted on multisite. `--matchCriteria` is JSON.
+
+`{elementType}` is resolved to a concrete importer via `Import::getElementImporterTypeFor()`; the
+command fails with a clear error if no importer is registered for that type. The interactive
+prompt lists options built from `Import::getAllImporterTypes()` filtered to `ElementImporter`
+subclasses (label = the importer's `displayName()`, value = its `elementClass()`).
+
+```
+craft:import:model {className} {file} [--transformer=] [--matchCriteria=]
+```
+Alias `import/model`. `{className}` is resolved to a concrete importer via
+`Import::getModelImporterTypeFor()`; the command fails with a clear error if no importer is
+registered for that model. The interactive prompt lists options built from
+`Import::getAllImporterTypes()` filtered to `ModelImporter` subclasses (label = the importer's
+`displayName()`, value = its `modelClass()`).
+
+Neither takes a `--map`, so CLI mapping is the transformer's job.
+
+---
+
+## 11. Extension points
+
+- `RegisterDataTypes` — `$event->dataTypes['yml'] = MyType::class;` (extension-keyed).
+  Built-ins: json, csv, xml. A data type implements two **static** methods,
+  `format()` and `getHeadings()`.
+- `RegisterImporterTypes` — `$event->importers[] = MyImporter::class;`. Registering a new
+  importable element type means contributing a concrete `ElementImporter` subclass that
+  implements `elementClass()`; registering a new importable model means contributing a concrete
+  `ModelImporter` subclass that implements `modelClass()`.
+- `DataImporting` / `DataImported`, `ImportConfigSaving` / `Saved`,
+  `ImportRunSaving` / `Saved`, `ImportRunDispatching` / `Dispatched`.
+  The `*ing` variants are cancellable.
+- Transformers: extend `ElementTransformer` (or the per-type one) and override
+  `transform()`; or implement `additionalMatchCriteria()`. Transformers can also be
+  given as a class string or an `fn($element) => ...` closure string.
+  `ElementTransformer` also supports convention-based `normalize{PropName}()` methods.
diff --git a/packages/craftcms-legacy/cp/src/js/UI.js b/packages/craftcms-legacy/cp/src/js/UI.js
index 6a48b2bcc70..9cd9a41ff9c 100644
--- a/packages/craftcms-legacy/cp/src/js/UI.js
+++ b/packages/craftcms-legacy/cp/src/js/UI.js
@@ -300,6 +300,7 @@ Craft.ui = {
                 typeof option.disabled !== 'undefined'
                   ? option.disabled
                   : false,
+              data: typeof option.data !== 'undefined' ? option.data : null,
             });
           }
         } else {
@@ -323,12 +324,23 @@ Craft.ui = {
           label: option.optgroup,
         }).appendTo($select);
       } else {
-        const $option = $('<option/>', {
+        let optionProps = {
           value: option.value,
           selected: option.value == config.value,
           disabled:
             typeof option.disabled !== 'undefined' ? option.disabled : false,
-        }).appendTo($optgroup || $select);
+        };
+
+        if (typeof option.data !== 'undefined' && option.data) {
+          for (const [key, value] of Object.entries(option.data)) {
+            let dataKey = 'data-' + key;
+            optionProps[dataKey] = value;
+          }
+        }
+
+        const $option = $('<option/>', optionProps).appendTo(
+          $optgroup || $select
+        );
 
         if (option.labelHtml) {
           $option.html(option.labelHtml);
diff --git a/rector.php b/rector.php
index 2f3b6c90f77..6a2c96de408 100644
--- a/rector.php
+++ b/rector.php
@@ -60,6 +60,7 @@
             __DIR__.'/src/Console/PromptTask.php',
         ],
     ])
+    ->withSkipPath(__DIR__.'/tests/Fixtures/Import/*')
     ->withSets([
         LaravelSetList::LARAVEL_130_WITHOUT_ATTRIBUTES,
         LaravelSetList::LARAVEL_ARRAYACCESS_TO_METHOD_CALL,
diff --git a/resources/icons/light/arrow-down-to-bracket.svg b/resources/icons/light/arrow-down-to-bracket.svg
new file mode 100644
index 00000000000..cd265e83586
--- /dev/null
+++ b/resources/icons/light/arrow-down-to-bracket.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><path d="M363.3 219.3l-128 128c-6.2 6.2-16.4 6.2-22.6 0l-128-128c-6.2-6.2-6.2-16.4 0-22.6s16.4-6.2 22.6 0L208 297.4 208 16c0-8.8 7.2-16 16-16s16 7.2 16 16l0 281.4L340.7 196.7c6.2-6.2 16.4-6.2 22.6 0s6.2 16.4 0 22.6zM32 336l0 96c0 26.5 21.5 48 48 48l288 0c26.5 0 48-21.5 48-48l0-96c0-8.8 7.2-16 16-16s16 7.2 16 16l0 96c0 44.2-35.8 80-80 80L80 512c-44.2 0-80-35.8-80-80l0-96c0-8.8 7.2-16 16-16s16 7.2 16 16z"/></svg>
\ No newline at end of file
diff --git a/resources/icons/light/arrow-up-to-bracket.svg b/resources/icons/light/arrow-up-to-bracket.svg
new file mode 100644
index 00000000000..534c63b883b
--- /dev/null
+++ b/resources/icons/light/arrow-up-to-bracket.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><path d="M363.3 292.7l-128-128c-6.2-6.2-16.4-6.2-22.6 0l-128 128c-6.2 6.2-6.2 16.4 0 22.6s16.4 6.2 22.6 0L208 214.6 208 496c0 8.8 7.2 16 16 16s16-7.2 16-16l0-281.4L340.7 315.3c6.2 6.2 16.4 6.2 22.6 0s6.2-16.4 0-22.6zM32 176l0-96c0-26.5 21.5-48 48-48l288 0c26.5 0 48 21.5 48 48l0 96c0 8.8 7.2 16 16 16s16-7.2 16-16l0-96c0-44.2-35.8-80-80-80L80 0C35.8 0 0 35.8 0 80l0 96c0 8.8 7.2 16 16 16s16-7.2 16-16z"/></svg>
\ No newline at end of file
diff --git a/resources/js/modules/auth-method-setup/auth.scss b/resources/js/modules/auth-method-setup/auth.scss
index d6b388f5cf4..95d243fa415 100644
--- a/resources/js/modules/auth-method-setup/auth.scss
+++ b/resources/js/modules/auth-method-setup/auth.scss
@@ -84,7 +84,7 @@
 
 ul.auth-method-recovery-codes-list {
   font-family:
-    SFMono-Regular, Consolas, 'Liberation Mono', Menlo, Courier, monospace;
+    SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
   font-size: 0.9em !important;
   max-width: 20em;
   margin-inline: auto;
diff --git a/resources/js/modules/import/context-slideout.ts b/resources/js/modules/import/context-slideout.ts
new file mode 100644
index 00000000000..6fe36dc348a
--- /dev/null
+++ b/resources/js/modules/import/context-slideout.ts
@@ -0,0 +1,80 @@
+/**
+ * Opening a slideout panel that needs a callback-bearing context rather than plain
+ * props.
+ *
+ * Callbacks can't ride in `ScreenPageProps`, so the panel is handed a key instead and
+ * claims its context on setup. `createContextRegistry` holds the claim map; `openContextSlideout`
+ * does the claim, lazy-load and open in one step, shared by every panel in this feature
+ * that works this way (a step's settings, its mapping, and a nested mapping).
+ */
+import type {InertiaPageComponent} from '@/bootstrap/inertia-pages';
+
+export interface ContextRegistry<TContext> {
+  register(context: TContext): string;
+  take(contextId: string): TContext;
+  discard(contextId: string): void;
+}
+
+export function createContextRegistry<TContext>(
+  name: string
+): ContextRegistry<TContext> {
+  const contexts = new Map<string, TContext>();
+  let nextId = 0;
+
+  return {
+    register(context: TContext): string {
+      const contextId = `${name}-${++nextId}`;
+      contexts.set(contextId, context);
+
+      return contextId;
+    },
+
+    take(contextId: string): TContext {
+      const context = contexts.get(contextId);
+
+      if (!context) {
+        throw new Error(`Unknown ${name} context: ${contextId}`);
+      }
+
+      contexts.delete(contextId);
+
+      return context;
+    },
+
+    discard(contextId: string): void {
+      contexts.delete(contextId);
+    },
+  };
+}
+
+/**
+ * Registers `context`, opens `loadComponent`'s panel with it, and discards the context
+ * again if the panel didn't open — either the user declined to discard unsaved changes
+ * in a panel this one would have replaced, or the caller chose not to open one at all.
+ */
+export async function openContextSlideout<TContext>(
+  registry: ContextRegistry<TContext>,
+  loadComponent: () => Promise<InertiaPageComponent>,
+  context: TContext,
+  title: string,
+  opener: HTMLElement | null
+): Promise<boolean> {
+  const [{openSlideoutWith}, component] = await Promise.all([
+    import('@/common/slideouts'),
+    loadComponent(),
+  ]);
+
+  const contextId = registry.register(context);
+
+  // SAFETY: The slideout host renders this imported Vue SFC exactly like its Inertia
+  // page components; it does not require an Inertia page module.
+  const panel = openSlideoutWith(component, {contextId, title}, {opener});
+
+  if (!panel) {
+    registry.discard(contextId);
+
+    return false;
+  }
+
+  return true;
+}
diff --git a/resources/js/modules/import/mapping/MappingRow.vue b/resources/js/modules/import/mapping/MappingRow.vue
new file mode 100644
index 00000000000..53f512d80ad
--- /dev/null
+++ b/resources/js/modules/import/mapping/MappingRow.vue
@@ -0,0 +1,186 @@
+<script setup lang="ts">
+  /**
+   * One destination column: what it maps to, and how it behaves when the imported
+   * value is missing.
+   *
+   * A container column has no mapping of its own — it opens a nested panel over the
+   * same trees instead, which is why every control here writes through
+   * `prefixedHandleAsArray` rather than a form input name.
+   */
+  import '@craftcms/ui/components/badge/badge';
+  import '@craftcms/ui/components/button/button';
+  import '@craftcms/ui/components/checkbox/checkbox';
+  import '@craftcms/ui/components/info-icon/info-icon';
+  import CraftCombobox from '@craftcms/ui/vue/CraftCombobox.vue';
+  import {computed, inject, useTemplateRef} from 'vue';
+  import {ButtonVariant, t} from '@craftcms/ui';
+  import {ignoreModelValueInitialization} from '@/modules/forms/runtime';
+  import {checkedValue, getAt, isChecked, setAt} from './paths';
+  import {type MappingCol, MappingContextKey} from './types';
+
+  const props = defineProps<{
+    col: MappingCol;
+  }>();
+
+  const context = inject(MappingContextKey);
+
+  if (!context) {
+    throw new Error('MappingRow must be rendered inside a mapping screen.');
+  }
+
+  const nestedTrigger = useTemplateRef<HTMLElement>('nestedTrigger');
+  const path = computed(() => props.col.prefixedHandleAsArray);
+
+  const mapValue = computed<string>(() => {
+    const value = getAt(context.values.map, path.value);
+
+    return value === null || value === undefined ? '' : String(value);
+  });
+
+  const isBestGuess = computed(() =>
+    Boolean(getAt(context.suggestedMap, path.value))
+  );
+
+  /**
+   * A container has no value of its own to match on or clear — each of its nested
+   * columns carries its own decision, inside the panel.
+   */
+  const canMatch = computed(
+    () => !props.col.isContainer && props.col.canBeMatchCriteria
+  );
+
+  const canClear = computed(
+    () => !props.col.isContainer && props.col.canBeCleared
+  );
+
+  const isMatchOnly = computed(
+    () => !props.col.isContainer && props.col.canBeSet === false
+  );
+
+  const matchCriteriaChecked = computed(() =>
+    isChecked(getAt(context.values.matchCriteria, path.value))
+  );
+
+  const clearChecked = computed(() =>
+    isChecked(getAt(context.values.clearableItems, path.value))
+  );
+
+  function onMapChanged(event: CustomEvent): void {
+    if (event.detail?.initialize) {
+      return;
+    }
+
+    const value = (event.target as HTMLElement & {modelValue?: unknown})
+      .modelValue;
+
+    setAt(context!.values.map, path.value, value == null ? '' : String(value));
+    setAt(context!.suggestedMap, path.value, false);
+  }
+
+  // `craft-checkbox` announces its starting state too, which would write to the
+  // trees before the user has touched anything and read as an unsaved change.
+  const onMatchCriteriaChanged = ignoreModelValueInitialization((event) => {
+    setAt(context!.values.matchCriteria, path.value, checkedValue(event));
+  });
+
+  const onClearChanged = ignoreModelValueInitialization((event) => {
+    setAt(context!.values.clearableItems, path.value, checkedValue(event));
+  });
+
+  function openNested(): void {
+    context!.openNested(props.col, nestedTrigger.value);
+  }
+
+  /** Whether the container's nested mapping has anything in it yet. */
+  const hasNestedMapping = computed(() => {
+    const branch = getAt(context!.values.map, path.value);
+
+    return (
+      branch !== null &&
+      typeof branch === 'object' &&
+      Object.keys(branch as object).length > 0
+    );
+  });
+</script>
+
+<template>
+  <tr>
+    <th scope="row">
+      {{ col.label }}
+      <craft-badge v-if="isMatchOnly" fill="gray">{{
+        t('Match only')
+      }}</craft-badge>
+      <craft-info-icon v-if="isMatchOnly">{{
+        t(
+          'This value can’t be imported directly — it can only be used to match against an existing element.'
+        )
+      }}</craft-info-icon>
+      <br />
+      <code>{{ col.handle }}</code>
+    </th>
+    <td :class="{'best-guess': isBestGuess}">
+      <craft-button
+        v-if="col.isContainer"
+        ref="nestedTrigger"
+        type="button"
+        :variant="ButtonVariant.Dashed"
+        :disabled="!context.editable"
+        @click="openNested"
+      >
+        {{ hasNestedMapping ? t('Edit mapping') : t('Map field') }}
+      </craft-button>
+      <CraftCombobox
+        v-else
+        :model-value="mapValue"
+        :options="context.sourceDataCols"
+        :disabled="!context.editable"
+        :label="col.label"
+        label-sr-only
+        require-option-match
+        show-all-on-empty
+        @model-value-changed="onMapChanged"
+      />
+    </td>
+
+    <!-- The column header names these; the row is named by its `th`. An empty
+         cell means the option can never apply to this field, which is why it isn't
+         a disabled checkbox. `label-sr-only` + a slotted label is the only way to
+         name a `craft-checkbox` — Lion overwrites `aria-labelledby` on the inner
+         input with its own generated label. -->
+    <td>
+      <craft-checkbox
+        v-if="canMatch"
+        label-sr-only
+        .checked="matchCriteriaChecked"
+        :disabled="!context.editable"
+        @model-value-changed="onMatchCriteriaChanged"
+      >
+        <label slot="label">{{
+          t('Use this field’s value to match against an existing element.')
+        }}</label>
+      </craft-checkbox>
+    </td>
+
+    <td>
+      <craft-checkbox
+        v-if="canClear"
+        label-sr-only
+        .checked="clearChecked"
+        :disabled="!context.editable"
+        @model-value-changed="onClearChanged"
+      >
+        <label slot="label">{{
+          t(
+            'Clear existing value if no data provided or provided value is empty.'
+          )
+        }}</label>
+      </craft-checkbox>
+    </td>
+  </tr>
+</template>
+
+<style scoped lang="scss">
+  .best-guess {
+    background: var(--color-blue-100);
+  }
+</style>
diff --git a/resources/js/modules/import/mapping/MappingTable.vue b/resources/js/modules/import/mapping/MappingTable.vue
new file mode 100644
index 00000000000..f06e3b20661
--- /dev/null
+++ b/resources/js/modules/import/mapping/MappingTable.vue
@@ -0,0 +1,79 @@
+<script setup lang="ts">
+  /**
+   * A run of destination columns. Rendered by both the map page and the nested
+   * panel, which is why it takes the columns and reads everything else from the
+   * mapping context around it.
+   */
+  import '@craftcms/ui/components/info-icon/info-icon';
+  import {t} from '@craftcms/ui';
+  import MappingRow from './MappingRow.vue';
+  import {isCol, isColSet} from './paths';
+  import type {MappingColEntry} from './types';
+
+  defineProps<{
+    cols: MappingColEntry[];
+  }>();
+</script>
+
+<template>
+  <div class="mapping-table">
+    <!-- `cp-table--auto` matters: plain `cp-table` goes `table-layout: fixed`
+         with zero-width cells above 840px, which would split the four columns
+         evenly instead of letting the first two take the room they need. -->
+    <table class="cp-table cp-table--auto cp-table--padded">
+      <thead>
+        <tr>
+          <th class="mapping-table__destination" scope="col">
+            {{ t('Destination') }}
+          </th>
+          <th scope="col">{{ t('Incoming data') }}</th>
+          <th class="mapping-table__option" scope="col">
+            {{ t('Match') }}
+            <craft-info-icon>{{
+              t('Use this field’s value to match against an existing element.')
+            }}</craft-info-icon>
+          </th>
+          <th class="mapping-table__option" scope="col">
+            {{ t('Clear') }}
+            <craft-info-icon>{{
+              t(
+                'Clear existing value if no data provided or provided value is empty.'
+              )
+            }}</craft-info-icon>
+          </th>
+        </tr>
+      </thead>
+      <tbody v-for="(entry, index) in cols" :key="index">
+        <template v-if="isColSet(entry)">
+          <tr>
+            <th colspan="4" scope="colgroup">
+              <strong>{{ entry.heading }}</strong>
+            </th>
+          </tr>
+          <MappingRow
+            v-for="subfield in entry.subfields"
+            :key="subfield.prefixedHandle"
+            :col="subfield"
+          />
+        </template>
+        <MappingRow v-else-if="isCol(entry)" :col="entry" />
+      </tbody>
+    </table>
+  </div>
+</template>
+
+<style scoped>
+  /* The table can outgrow a slideout panel; scroll it rather than the page. */
+  .mapping-table {
+    overflow-x: auto;
+  }
+
+  .mapping-table__destination {
+    width: 20%;
+  }
+
+  .mapping-table__option {
+    width: 15%;
+    white-space: nowrap;
+  }
+</style>
diff --git a/resources/js/modules/import/mapping/NestedMapping.vue b/resources/js/modules/import/mapping/NestedMapping.vue
new file mode 100644
index 00000000000..9216b45b799
--- /dev/null
+++ b/resources/js/modules/import/mapping/NestedMapping.vue
@@ -0,0 +1,68 @@
+<script setup lang="ts">
+  /**
+   * A container column's mapping, as a slideout panel.
+   *
+   * Opened with `openSlideoutWith()` — see `nested-mapping.ts` for why. The panel
+   * edits its own copy of the screen's trees and hands them back on Apply, so
+   * cancelling leaves the screen behind untouched.
+   */
+  import '@craftcms/ui/components/checkbox/checkbox';
+  import {computed} from 'vue';
+  import {t} from '@craftcms/ui';
+  import {ignoreModelValueInitialization} from '@/modules/forms/runtime';
+  import MappingTable from './MappingTable.vue';
+  import {checkedValue, getAt, isChecked, keepFlagPath, setAt} from './paths';
+  import {takeNestedMappingContext} from './nested-mapping';
+  import {useMappingPanel} from './useMappingPanel';
+
+  const props = defineProps<{
+    contextId: string;
+    title: string;
+  }>();
+
+  const context = takeNestedMappingContext(props.contextId);
+
+  const {values} = useMappingPanel({
+    title: props.title,
+    values: context.values,
+    suggestedMap: context.suggestedMap,
+    sourceDataCols: context.sourceDataCols,
+    editable: context.editable,
+    step: context.step,
+    nestedColsUrl: context.colsUrl,
+    apply: context.apply,
+  });
+
+  const keepPath = computed(() => keepFlagPath(context.col));
+
+  const keepMissingChecked = computed(() =>
+    isChecked(getAt(values.keepMissingNestedElements, keepPath.value))
+  );
+
+  const onKeepMissingChanged = ignoreModelValueInitialization((event) => {
+    setAt(
+      values.keepMissingNestedElements,
+      keepPath.value,
+      checkedValue(event)
+    );
+  });
+</script>
+
+<template>
+  <div>
+    <craft-checkbox
+      v-if="context.col.canKeepMissingNestedElements"
+      :label="
+        t('Keep existing nested elements missing from the imported data.')
+      "
+      .checked="keepMissingChecked"
+      :disabled="!context.editable"
+      @model-value-changed="onKeepMissingChanged"
+    ></craft-checkbox>
+
+    <section v-for="(group, index) in context.groups" :key="index">
+      <h3>{{ group.providerName ?? context.fieldName }}</h3>
+      <MappingTable :cols="group.destinationCols" />
+    </section>
+  </div>
+</template>
diff --git a/resources/js/modules/import/mapping/nested-mapping.ts b/resources/js/modules/import/mapping/nested-mapping.ts
new file mode 100644
index 00000000000..3a1a25bc152
--- /dev/null
+++ b/resources/js/modules/import/mapping/nested-mapping.ts
@@ -0,0 +1,112 @@
+/**
+ * Opening a container column's mapping in a slideout panel.
+ *
+ * Opened with `openSlideoutWith()` rather than `openSlideout()`: the mapping being
+ * edited is unsaved client state the panel above already holds, with no URL to GET.
+ * The server is POSTed the draft step and asked only for the container's *structure*
+ * — which columns exist under it — and the panel edits a copy of the trees, handing
+ * them back on Apply. Nothing needs to have been saved for this to work.
+ *
+ * That copy is the whole set of trees rather than just the container's branch, so a
+ * nested column's absolute `prefixedHandleAsArray` addresses the same place in the
+ * panel as it does on the page, and nesting works to any depth without rebasing paths.
+ */
+import {actionClient} from '@craftcms/ui';
+import type {InertiaPageComponent} from '@/bootstrap/inertia-pages';
+import {
+  createContextRegistry,
+  openContextSlideout,
+} from '@/modules/import/context-slideout';
+import {applySuggestions, cloneValues, toObjectTree} from './paths';
+import type {
+  MappingCol,
+  MappingGroup,
+  MappingValues,
+  SourceDataCol,
+  StepPayload,
+  SuggestedMap,
+} from './types';
+
+export interface NestedMappingContext {
+  col: MappingCol;
+  fieldName: string;
+  groups: MappingGroup[];
+  sourceDataCols: SourceDataCol[];
+  values: MappingValues;
+  /** Which of this panel's own `values.map` leaves hold a guessed value. */
+  suggestedMap: SuggestedMap;
+  editable: boolean;
+  /** Carried through so a container inside the panel can open a panel of its own. */
+  step: StepPayload;
+  colsUrl: string;
+  apply(values: MappingValues): void;
+}
+
+export interface OpenNestedMappingOptions {
+  col: MappingCol;
+  /** The draft step being mapped. Posted so the server can build its importer. */
+  step: StepPayload;
+  /** Endpoint returning the container's destination columns. */
+  colsUrl: string;
+  values: MappingValues;
+  editable: boolean;
+  opener: HTMLElement | null;
+  apply(values: MappingValues): void;
+}
+
+const registry = createContextRegistry<NestedMappingContext>(
+  'import-nested-mapping'
+);
+
+export function takeNestedMappingContext(
+  contextId: string
+): NestedMappingContext {
+  return registry.take(contextId);
+}
+
+/**
+ * Returns false when the panel was not opened — the user declined to discard unsaved
+ * changes in a panel this one would have replaced.
+ */
+export async function openNestedMapping(
+  options: OpenNestedMappingOptions
+): Promise<boolean> {
+  const {col} = options;
+
+  const {data} = await actionClient.post(options.colsUrl, {
+    step: options.step,
+    fieldUid: col.fieldUid ?? '',
+    fieldHandle: col.prefixedHandle,
+    fieldIsProperty: col.isProperty ? 1 : 0,
+  });
+
+  const values = cloneValues(options.values);
+  const suggestedMap: SuggestedMap = {};
+  applySuggestions(
+    values.map,
+    toObjectTree(data.suggestions ?? {}),
+    suggestedMap
+  );
+
+  return openContextSlideout(
+    registry,
+    () =>
+      import('./NestedMapping.vue').then(
+        (m) => m.default as InertiaPageComponent
+      ),
+    {
+      col,
+      fieldName: data.fieldName,
+      groups: data.groups,
+      sourceDataCols: data.sourceDataCols ?? [],
+      values,
+      suggestedMap,
+      editable: options.editable,
+      step: options.step,
+      colsUrl: options.colsUrl,
+      apply: options.apply,
+    },
+    data.title,
+    options.opener
+  );
+}
diff --git a/resources/js/modules/import/mapping/paths.ts b/resources/js/modules/import/mapping/paths.ts
new file mode 100644
index 00000000000..29624412ca9
--- /dev/null
+++ b/resources/js/modules/import/mapping/paths.ts
@@ -0,0 +1,198 @@
+import type {
+  MappingCol,
+  MappingColEntry,
+  MappingColSet,
+  MappingValues,
+  StepPayload,
+} from './types';
+
+/**
+ * Reads a column's value out of one of the mapping trees.
+ *
+ * Replaces the Twig screen's `prefixedHandleAsArray|reduce(...)`: a missing branch
+ * reads as `null` rather than throwing, since the trees only hold what has been
+ * mapped so far.
+ */
+export function getAt(
+  tree: Record<string, unknown> | null | undefined,
+  path: string[]
+): unknown {
+  return path.reduce<unknown>(
+    (value, part) =>
+      value !== null && typeof value === 'object'
+        ? (value as Record<string, unknown>)[part]
+        : undefined,
+    tree
+  );
+}
+
+/** Writes a column's value into one of the mapping trees, creating branches as needed. */
+export function setAt(
+  tree: Record<string, unknown>,
+  path: string[],
+  value: unknown
+): void {
+  const leaf = path[path.length - 1]!;
+  let branch = tree;
+
+  for (const part of path.slice(0, -1)) {
+    const next = branch[part];
+
+    if (next === null || typeof next !== 'object' || Array.isArray(next)) {
+      branch[part] = {};
+    }
+
+    branch = branch[part] as Record<string, unknown>;
+  }
+
+  branch[leaf] = value;
+}
+
+/**
+ * A container's own keep-missing decision lives under a reserved `__keep__` leaf,
+ * because the container's handle also has to hold its nested containers' decisions.
+ */
+export function keepFlagPath(col: MappingCol): string[] {
+  return [...col.prefixedHandleAsArray, '__keep__'];
+}
+
+/**
+ * Match criteria and clearable items are stored loosely — `1`, `'1'`, or the mapped
+ * column's name once `normalizeMatchCriteriaFromImporterConfig()` has resolved it.
+ * The screen only cares whether they are set.
+ */
+export function isChecked(value: unknown): boolean {
+  return (
+    value !== undefined && value !== null && value !== '' && value !== false
+  );
+}
+
+/**
+ * The value a `craft-checkbox` should write into one of the trees: `1` and `''`
+ * rather than booleans, which is what the Twig checkboxes posted and what
+ * `validateMap()` and the importer already read back.
+ *
+ * Read off `currentTarget` — the `craft-checkbox` the listener is bound to, which
+ * mirrors its slotted input's state. `target` is the host for an event Lion raises
+ * itself and the input for one that bubbles up from it, so it can't be relied on.
+ */
+export function checkedValue(event: Event): string {
+  const checkbox = event.currentTarget as {checked?: boolean} | null;
+
+  return checkbox?.checked ? '1' : '';
+}
+
+/** Whether a `destinationCols` entry is a labelled run of subfields rather than one column. */
+export function isColSet(entry: MappingColEntry): entry is MappingColSet {
+  return (
+    !Array.isArray(entry) && 'multiple' in entry && entry.multiple === true
+  );
+}
+
+/** Whether a `destinationCols` entry is a column at all — `[]` means "skip me". */
+export function isCol(entry: MappingColEntry): entry is MappingCol {
+  return !Array.isArray(entry) && !isColSet(entry);
+}
+
+/**
+ * Rewrites every array in a tree as an object.
+ *
+ * PHP has one array type, so an empty tree — or any empty branch within one — reaches
+ * the client as `[]` rather than `{}`. Writing a handle key onto a JS array succeeds
+ * in memory but `JSON.stringify` drops it, so the edit would silently never reach the
+ * server. The trees are only ever handle-keyed maps, so nothing here is a real list.
+ */
+export function toObjectTree<T>(value: T): T {
+  if (Array.isArray(value)) {
+    return Object.fromEntries(
+      value.map((item, index) => [index, toObjectTree(item)])
+    ) as T;
+  }
+
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, toObjectTree(item)])
+    ) as T;
+  }
+
+  return value;
+}
+
+/**
+ * A structural copy of the trees, so a nested panel can be cancelled without a trace.
+ *
+ * Round-tripped through JSON rather than `structuredClone()`, which can't clone the
+ * reactive proxies the screens hold these in.
+ */
+export function cloneValues(values: MappingValues): MappingValues {
+  return toObjectTree(JSON.parse(JSON.stringify(values)) as MappingValues);
+}
+
+/**
+ * A structural copy of one step, so a slideout can be cancelled without a trace.
+ *
+ * Round-tripped through JSON rather than `structuredClone()`, which can't clone the
+ * reactive proxies the screens hold these in.
+ */
+export function cloneStep(step: StepPayload): StepPayload {
+  return JSON.parse(JSON.stringify(step)) as StepPayload;
+}
+
+/** A structural copy of a list of steps, as {@link cloneStep} copies one. */
+export function cloneSteps(steps: StepPayload[]): StepPayload[] {
+  return JSON.parse(JSON.stringify(steps)) as StepPayload[];
+}
+
+/**
+ * Fills in every leaf of `map` that doesn't have a value yet from `suggestions`, and
+ * records each leaf it fills in `flags`.
+ *
+ * An explicit choice — saved, or made earlier in this editing session — is neither
+ * overwritten nor flagged as a guess. The server can't work that out on its own, since
+ * it only ever sees the saved map, so the flags have to come from the pass that writes
+ * the values.
+ */
+export function applySuggestions(
+  map: Record<string, unknown>,
+  suggestions: Record<string, unknown>,
+  flags: Record<string, unknown>
+): void {
+  for (const [key, suggested] of Object.entries(suggestions)) {
+    const current = map[key];
+
+    if (
+      suggested !== null &&
+      typeof suggested === 'object' &&
+      !Array.isArray(suggested)
+    ) {
+      if (
+        current === null ||
+        typeof current !== 'object' ||
+        Array.isArray(current)
+      ) {
+        map[key] = {};
+      }
+
+      if (
+        flags[key] === null ||
+        typeof flags[key] !== 'object' ||
+        Array.isArray(flags[key])
+      ) {
+        flags[key] = {};
+      }
+
+      applySuggestions(
+        map[key] as Record<string, unknown>,
+        suggested as Record<string, unknown>,
+        flags[key] as Record<string, unknown>
+      );
+
+      continue;
+    }
+
+    if (current === undefined || current === null || current === '') {
+      map[key] = suggested;
+      flags[key] = true;
+    }
+  }
+}
diff --git a/resources/js/modules/import/mapping/types.ts b/resources/js/modules/import/mapping/types.ts
new file mode 100644
index 00000000000..dd7538963e1
--- /dev/null
+++ b/resources/js/modules/import/mapping/types.ts
@@ -0,0 +1,112 @@
+import type {InjectionKey} from 'vue';
+import type {ComboboxOptionData} from '@craftcms/ui/components/combobox/combobox';
+
+/** One `sourceDataCols` entry — a heading in the imported file. */
+export interface SourceDataCol {
+  label: string;
+  value: string;
+  /** `hint` is the incoming file's first-row value for this column, if any. */
+  data?: ComboboxOptionData | null;
+}
+
+/**
+ * A destination column, as built by `ImportHelper::getPrefixedHandlesForMapping()`
+ * and the `getFieldsForMapping()` implementations in `src/FieldLayout`.
+ *
+ * `prefixedHandleAsArray` is the column's path from the root of the mapping trees,
+ * and is how every value below is addressed. The `prefixedHandleFor*` strings are the
+ * bracket-named form inputs the Twig screen posted; they survive as stable keys but
+ * the Vue screen posts real nested objects instead.
+ */
+export interface MappingCol {
+  handle: string;
+  label: string;
+  prefixedHandle: string;
+  prefixedHandleAsArray: string[];
+  prefixedHandleForMap: string;
+  prefixedHandleForMatchCriteria: string;
+  prefixedHandleForClear: string;
+  isContainer: boolean;
+  canBeMatchCriteria: boolean;
+  canBeCleared: boolean;
+  canBeSet?: boolean;
+  canKeepMissingNestedElements?: boolean;
+  isProperty?: boolean;
+  /** Containers only — the global field UID, for fetching the nested columns. */
+  fieldUid?: string | null;
+  prefixedHandleForKeep?: string;
+  prefixedHandleForKeepFlag?: string;
+}
+
+/** A labelled run of columns rendered under one heading, e.g. lat/long. */
+export interface MappingColSet {
+  multiple: true;
+  heading?: string;
+  subfields: MappingCol[];
+}
+
+/**
+ * `getFieldsForMapping()` returns `[]` for a column it wants skipped, which arrives
+ * as an empty array rather than an object.
+ */
+export type MappingColEntry = MappingCol | MappingColSet | [];
+
+/** One field-layout provider's columns, in the nested panel. */
+export interface MappingGroup {
+  providerName: string | null;
+  destinationCols: MappingColEntry[];
+}
+
+/**
+ * One import step, as the edit screen holds it and as it's posted to the server.
+ *
+ * A step is only ever persisted as part of its import, so the mapping endpoints are
+ * handed the draft step itself rather than a UID to look up.
+ */
+export interface StepPayload {
+  uid: string;
+  type: string | null;
+  file: string | null;
+  transformer: string | null;
+  batchSize: number | null;
+  settings: Record<string, unknown>;
+}
+
+/** The four parallel trees the mapping screen edits, all keyed alike. */
+export interface MappingValues {
+  map: Record<string, unknown>;
+  matchCriteria: Record<string, unknown>;
+  clearableItems: Record<string, unknown>;
+  keepMissingNestedElements: Record<string, unknown>;
+}
+
+export type MappingValueTree = keyof MappingValues;
+
+/**
+ * A handle-keyed tree shaped like `MappingValues['map']`, holding either the guessed
+ * source column for each leaf (what the server sends) or a flag marking the leaves a
+ * guess was written into (what the screen keeps).
+ */
+export type SuggestedMap = Record<string, unknown>;
+
+/**
+ * What a row needs from the screen around it. Provided by both the page and the
+ * nested panel, so the table renders identically in either.
+ */
+export interface MappingContext {
+  values: MappingValues;
+  /**
+   * Which `values.map` leaves hold a guessed value rather than an explicit choice,
+   * keyed the same way. Kept apart from `MappingValues` so it's never posted with the
+   * form.
+   */
+  suggestedMap: SuggestedMap;
+  sourceDataCols: SourceDataCol[];
+  editable: boolean;
+  /** Opens a container column's own mapping in a nested panel. */
+  openNested(col: MappingCol, opener: HTMLElement | null): void;
+}
+
+export const MappingContextKey: InjectionKey<MappingContext> = Symbol(
+  'importMappingContext'
+);
diff --git a/resources/js/modules/import/mapping/useMappingPanel.ts b/resources/js/modules/import/mapping/useMappingPanel.ts
new file mode 100644
index 00000000000..39119b91f48
--- /dev/null
+++ b/resources/js/modules/import/mapping/useMappingPanel.ts
@@ -0,0 +1,92 @@
+/**
+ * The shell shared by every mapping slideout: `StepMapping.vue` and `NestedMapping.vue`
+ * both edit a copy of the mapping trees and provide the same {@link MappingContextKey}
+ * for `MappingTable`/`MappingRow` to read and write through, differing only in what
+ * they render around that context.
+ */
+import {provide, reactive, watch} from 'vue';
+import {t} from '@craftcms/ui';
+import {useForm} from '@inertiajs/vue3';
+import {useAppLayout} from '@/common/composables/useAppLayout';
+import {useSlideout} from '@/common/slideouts';
+import {openNestedMapping} from './nested-mapping';
+import {
+  type MappingCol,
+  MappingContextKey,
+  type MappingValues,
+  type SourceDataCol,
+  type StepPayload,
+  type SuggestedMap,
+} from './types';
+
+export interface UseMappingPanelOptions {
+  title: string;
+  values: MappingValues;
+  suggestedMap: SuggestedMap;
+  sourceDataCols: SourceDataCol[];
+  editable: boolean;
+  /** The draft step being mapped, so a nested panel opened from here can post it. */
+  step: StepPayload;
+  /** Endpoint returning a container column's own destination columns. */
+  nestedColsUrl: string;
+  apply(values: MappingValues): void;
+}
+
+export function useMappingPanel(options: UseMappingPanelOptions): {
+  values: MappingValues;
+  suggestedMap: SuggestedMap;
+} {
+  const slideout = useSlideout();
+  const values = reactive<MappingValues>(options.values);
+  const suggestedMap = reactive<SuggestedMap>(options.suggestedMap);
+
+  /**
+   * Backs the shell's Apply button and gives it an accurate dirty check for the
+   * unsaved-changes prompt. Inertia diffs against the value it was created with, so
+   * a serialization of the trees stands in for them.
+   */
+  const form = useForm({state: JSON.stringify(values)});
+
+  watch(
+    values,
+    () => {
+      form.state = JSON.stringify(values);
+    },
+    {deep: true}
+  );
+
+  useAppLayout(() => ({
+    title: options.title,
+    submitButtonLabel: t('Apply'),
+    form,
+    onSave: apply,
+  }));
+
+  provide(MappingContextKey, {
+    values,
+    suggestedMap,
+    sourceDataCols: options.sourceDataCols,
+    editable: options.editable,
+    openNested(col: MappingCol, opener: HTMLElement | null): void {
+      void openNestedMapping({
+        col,
+        step: options.step,
+        colsUrl: options.nestedColsUrl,
+        values,
+        editable: options.editable,
+        opener,
+        apply: (applied) => Object.assign(values, applied),
+      });
+    },
+  });
+
+  function apply(): void {
+    options.apply(JSON.parse(JSON.stringify(values)) as MappingValues);
+
+    // Before close(): closing drops the panel from the store, and its handler with it.
+    slideout?.saved();
+    slideout?.close({force: true});
+  }
+
+  return {values, suggestedMap};
+}
diff --git a/resources/js/modules/import/steps/StepList.test.ts b/resources/js/modules/import/steps/StepList.test.ts
new file mode 100644
index 00000000000..bdd8feed946
--- /dev/null
+++ b/resources/js/modules/import/steps/StepList.test.ts
@@ -0,0 +1,248 @@
+import {createApp, nextTick, reactive, ref} from 'vue';
+import {afterEach, beforeEach, expect, it, vi} from 'vite-plus/test';
+import {cloneStep, cloneSteps} from '@/modules/import/mapping/paths';
+import type {StepPayload} from '@/modules/import/mapping/types';
+import StepList from './StepList.vue';
+
+const state = vi.hoisted(() => ({
+  openStepSlideout: vi.fn(),
+}));
+
+vi.mock('./step-slideout', () => ({
+  openStepSlideout: state.openStepSlideout,
+}));
+
+const urls = {
+  settingsUrl: '/actions/import/step-settings',
+  validateUrl: '/actions/import/validate-step',
+  mappingUrl: '/actions/import/step-mapping',
+  nestedColsUrl: '/actions/import/nested-mapping-cols',
+};
+
+const importerTypes = [
+  {value: 'CraftCms\\Cms\\Entry\\Import\\EntryImporter', label: 'Entries'},
+  {value: 'CraftCms\\Cms\\Asset\\Import\\AssetImporter', label: 'Assets'},
+];
+
+function step(overrides: Partial<StepPayload> = {}): StepPayload {
+  return {
+    uid: 'step-1',
+    type: importerTypes[0]!.value,
+    file: 'people.csv',
+    transformer: null,
+    batchSize: null,
+    settings: {},
+    ...overrides,
+  };
+}
+
+let app: ReturnType<typeof createApp> | null;
+let container: HTMLElement;
+let steps: ReturnType<typeof ref<StepPayload[]>>;
+
+function mount(
+  initial: StepPayload[] = [step()],
+  props: {editable?: boolean; errors?: Record<string, string[]>} = {}
+) {
+  // a ref, as the edit screen holds these — reading an element back out of it hands
+  // the list a reactive proxy, which is the case that used to break cloning
+  steps = ref<StepPayload[]>(initial);
+
+  app = createApp({
+    components: {StepList},
+    template:
+      '<StepList v-model="steps" :urls="urls" :editable="editable" :importer-types="importerTypes" :errors="errors" />',
+    setup: () => ({
+      steps,
+      urls,
+      importerTypes,
+      editable: props.editable ?? true,
+      errors: props.errors ?? {},
+    }),
+  });
+  app.config.compilerOptions.isCustomElement = (tag) => tag.includes('-');
+  app.mount(container);
+}
+
+/** The rows' buttons, in DOM order: [Edit, Delete] per row. */
+function rowButtons(index = 0): HTMLElement[] {
+  const row = [...container.querySelectorAll('li')][index]!;
+
+  return [...row.querySelectorAll<HTMLElement>('craft-button')];
+}
+
+function addButton(): HTMLElement {
+  return [...container.querySelectorAll<HTMLElement>('craft-button')].at(-1)!;
+}
+
+beforeEach(() => {
+  state.openStepSlideout.mockReset();
+  state.openStepSlideout.mockResolvedValue(true);
+  vi.stubGlobal('confirm', vi.fn().mockReturnValue(true));
+  app = null;
+  container = document.createElement('div');
+  document.body.append(container);
+});
+
+afterEach(() => {
+  app?.unmount();
+  container.remove();
+  vi.unstubAllGlobals();
+});
+
+it('clones a step held in reactive state', () => {
+  // `structuredClone` throws `DataCloneError` on a Proxy, which is what a step read
+  // back out of the list's model always is.
+  const proxied = reactive(step());
+
+  expect(() => cloneStep(proxied)).not.toThrow();
+  expect(cloneStep(proxied)).toEqual(step());
+  expect(cloneSteps(reactive([step()]))).toEqual([step()]);
+});
+
+it('opens the slideout for a step read out of its reactive model', async () => {
+  mount();
+
+  rowButtons()[0]!.dispatchEvent(new Event('click'));
+  await nextTick();
+
+  expect(state.openStepSlideout).toHaveBeenCalledOnce();
+  expect(state.openStepSlideout.mock.calls[0]![0]).toMatchObject({
+    urls,
+    editable: true,
+  });
+  expect(state.openStepSlideout.mock.calls[0]![0].step.uid).toBe('step-1');
+});
+
+it('summarizes a step by its importer type and file', () => {
+  mount();
+
+  expect(container.querySelector('li')!.textContent).toContain(
+    '1. Entries — people.csv'
+  );
+});
+
+it('appends a step the add slideout hands back', async () => {
+  mount([]);
+
+  addButton().dispatchEvent(new Event('click'));
+  await nextTick();
+
+  const {step: draft, apply} = state.openStepSlideout.mock.calls[0]![0];
+  apply({...draft, type: importerTypes[1]!.value, file: 'assets.csv'});
+  await nextTick();
+
+  expect(steps.value).toHaveLength(1);
+  expect(steps.value![0]!.file).toBe('assets.csv');
+  expect(steps.value![0]!.uid).toBe(draft.uid);
+});
+
+it('replaces the edited step in place, keeping its uid', async () => {
+  mount([step(), step({uid: 'step-2', file: 'other.csv'})]);
+
+  rowButtons(1)[0]!.dispatchEvent(new Event('click'));
+  await nextTick();
+
+  state.openStepSlideout.mock.calls[0]![0].apply(
+    step({uid: 'ignored', file: 'edited.csv'})
+  );
+  await nextTick();
+
+  expect(steps.value!.map((s) => s.uid)).toEqual(['step-1', 'step-2']);
+  expect(steps.value![1]!.file).toBe('edited.csv');
+});
+
+it('removes a step once the deletion is confirmed', async () => {
+  mount([step(), step({uid: 'step-2'})]);
+
+  rowButtons(0)[1]!.dispatchEvent(new Event('click'));
+  await nextTick();
+
+  expect(steps.value!.map((s) => s.uid)).toEqual(['step-2']);
+});
+
+it('keeps a step the user declines to delete', async () => {
+  vi.stubGlobal('confirm', vi.fn().mockReturnValue(false));
+  mount([step(), step({uid: 'step-2'})]);
+
+  rowButtons(0)[1]!.dispatchEvent(new Event('click'));
+  await nextTick();
+
+  expect(steps.value!.map((s) => s.uid)).toEqual(['step-1', 'step-2']);
+});
+
+it('reorders a step when its handle asks to move', async () => {
+  mount([step(), step({uid: 'step-2'})]);
+
+  container
+    .querySelector('craft-reorder-button')!
+    .dispatchEvent(new CustomEvent('reorder', {detail: {direction: 'down'}}));
+  await nextTick();
+
+  expect(steps.value!.map((s) => s.uid)).toEqual(['step-2', 'step-1']);
+});
+
+it('ignores a reorder that would move a step off either end', async () => {
+  mount([step(), step({uid: 'step-2'})]);
+
+  container
+    .querySelector('craft-reorder-button')!
+    .dispatchEvent(new CustomEvent('reorder', {detail: {direction: 'up'}}));
+  await nextTick();
+
+  expect(steps.value!.map((s) => s.uid)).toEqual(['step-1', 'step-2']);
+});
+
+it('shows a server error on the step it belongs to', () => {
+  mount([step(), step({uid: 'step-2'})], {
+    errors: {'steps.step-2.file': ['File does not exist.']},
+  });
+
+  const rows = [...container.querySelectorAll('li')];
+
+  expect(rows[0]!.querySelector('.error')).toBeNull();
+  expect(rows[1]!.querySelector('.error')!.textContent).toContain(
+    'The step “Entries — people.csv” is invalid. Edit it to fix the problem.'
+  );
+});
+
+it('shows an error about the list itself when there are no steps', () => {
+  // `steps` with nothing after it is the list's own error, not a row's
+  mount([], {errors: {steps: ['An import needs at least one step.']}});
+
+  expect(container.querySelector('.error-list')!.textContent).toContain(
+    'An import needs at least one step.'
+  );
+});
+
+it('keeps a list error and a row error apart', () => {
+  mount([step()], {
+    errors: {
+      steps: ['An import needs at least one step.'],
+      'steps.step-1.file': ['File does not exist.'],
+    },
+  });
+
+  expect(container.querySelector('.error-list')!.textContent).toContain(
+    'An import needs at least one step.'
+  );
+  expect(container.querySelector('.error-list')!.textContent).not.toContain(
+    'File does not exist.'
+  );
+  expect(container.querySelector('li .error')!.textContent).toContain(
+    'The step “Entries — people.csv” is invalid. Edit it to fix the problem.'
+  );
+});
+
+it('reports a slideout that fails to open instead of doing nothing', async () => {
+  state.openStepSlideout.mockRejectedValue(new Error('Request failed.'));
+  mount([]);
+
+  addButton().dispatchEvent(new Event('click'));
+  await nextTick();
+  await nextTick();
+
+  expect(container.querySelector('.error-list')!.textContent).toContain(
+    'Request failed.'
+  );
+});
diff --git a/resources/js/modules/import/steps/StepList.vue b/resources/js/modules/import/steps/StepList.vue
new file mode 100644
index 00000000000..878788bb7db
--- /dev/null
+++ b/resources/js/modules/import/steps/StepList.vue
@@ -0,0 +1,249 @@
+<script setup lang="ts">
+  /**
+   * An import's ordered list of steps.
+   *
+   * The list owns the steps outright: adding, editing, reordering and deleting all
+   * happen against this component's state, and the steps only reach the server when
+   * the import's own form is submitted.
+   */
+  import '@craftcms/ui/components/button/button';
+  import '@craftcms/ui/components/empty/empty';
+  import '@craftcms/ui/components/reorder-button/reorder-button';
+  import {computed, ref} from 'vue';
+  import {t} from '@craftcms/ui';
+  import {useReorderableItems} from '@/common/composables/useReorderableItems';
+  import type {StepPayload} from '@/modules/import/mapping/types';
+  import {openStepSlideout, type StepUrls} from './step-slideout';
+
+  const props = defineProps<{
+    urls: StepUrls;
+    editable: boolean;
+    /** Every importer type a step can be, for labelling the summary rows. */
+    importerTypes: Array<{value: string; label: string}>;
+    /** Server-side errors, keyed `steps.<step uid>.<attribute>`. */
+    errors?: Record<string, string[]>;
+  }>();
+
+  const steps = defineModel<StepPayload[]>({required: true});
+
+  const addButton = ref<HTMLElement | null>(null);
+  const itemButtons = ref<Record<string, HTMLElement | null>>({});
+
+  /** A slideout that couldn't be opened, as opposed to a server validation error. */
+  const requestError = ref<string | null>(null);
+
+  const {setItemRef, setHandleRef, getDropState, getRowPosition} =
+    useReorderableItems({
+      getItemIds: () => steps.value.map((step) => step.uid),
+      enabled: () => props.editable && steps.value.length > 1,
+      onReorder: (from, to) => reorder(from, to),
+    });
+
+  const errorsByStep = computed(() => {
+    const byStep: Record<string, string[]> = {};
+
+    for (const [path, messages] of Object.entries(props.errors ?? {})) {
+      const uid = /^steps\.([^.]+)\./.exec(path)?.[1];
+
+      if (uid === undefined) {
+        continue;
+      }
+
+      byStep[uid] = [...(byStep[uid] ?? []), ...messages];
+    }
+
+    return byStep;
+  });
+
+  /** Errors about the list as a whole — having no steps at all, or a slideout that failed to open. */
+  const listErrors = computed(() => [
+    ...(props.errors?.steps ?? []),
+    ...(requestError.value ? [requestError.value] : []),
+  ]);
+
+  function newStep(): StepPayload {
+    return {
+      // a plain UUID: the server caps a step's uid at 36 characters
+      uid: crypto.randomUUID(),
+      type: null,
+      file: null,
+      transformer: null,
+      batchSize: null,
+      settings: {},
+    };
+  }
+
+  const typeLabels = computed(() =>
+    Object.fromEntries(
+      props.importerTypes.map((type) => [type.value, type.label])
+    )
+  );
+
+  function summary(step: StepPayload): string {
+    const label = step.type
+      ? (typeLabels.value[step.type] ?? step.type)
+      : t('Choose an importer');
+
+    return [label, step.file].filter(Boolean).join(' — ');
+  }
+
+  function reorder(from: number, to: number): void {
+    if (to < 0 || to >= steps.value.length) {
+      return;
+    }
+
+    const next = [...steps.value];
+    const [moved] = next.splice(from, 1);
+
+    if (!moved) {
+      return;
+    }
+
+    next.splice(to, 0, moved);
+    steps.value = next;
+  }
+
+  function replace(uid: string, step: StepPayload): void {
+    steps.value = steps.value.map((existing) =>
+      existing.uid === uid ? {...step, uid} : existing
+    );
+  }
+
+  function remove(step: StepPayload): void {
+    if (
+      !window.confirm(t('Are you sure you want to delete this import step?'))
+    ) {
+      return;
+    }
+
+    steps.value = steps.value.filter((existing) => existing.uid !== step.uid);
+  }
+
+  /**
+   * Opening a step's slideout asks the server to build its form, so it can fail. Report it
+   * rather than letting the rejection go unhandled, which reads as the button doing nothing.
+   */
+  async function openStep(
+    options: Parameters<typeof openStepSlideout>[0],
+    title: string
+  ): Promise<void> {
+    requestError.value = null;
+
+    try {
+      await openStepSlideout(options, title);
+    } catch (error) {
+      requestError.value =
+        error instanceof Error && error.message
+          ? error.message
+          : t('Couldn’t open this step.');
+    }
+  }
+
+  async function add(): Promise<void> {
+    const step = newStep();
+
+    await openStep(
+      {
+        step,
+        urls: props.urls,
+        editable: props.editable,
+        opener: addButton.value,
+        apply: (applied) => {
+          steps.value = [...steps.value, {...applied, uid: step.uid}];
+        },
+      },
+      t('Add an import step')
+    );
+  }
+
+  async function edit(step: StepPayload): Promise<void> {
+    await openStep(
+      {
+        step,
+        urls: props.urls,
+        editable: props.editable,
+        opener: itemButtons.value[step.uid] ?? null,
+        apply: (applied) => replace(step.uid, applied),
+      },
+      t('Edit import step')
+    );
+  }
+</script>
+
+<template>
+  <craft-pane appearance="raised">
+    <h2>{{ t('Steps') }}</h2>
+    <p>
+      {{
+        t(
+          'Each step imports one kind of data. Steps run in the order listed here.'
+        )
+      }}
+    </p>
+
+    <craft-empty v-if="!steps.length" :label="t('No steps yet.')"></craft-empty>
+
+    <ol v-else class="m-0 p-0 list-none space-y-2">
+      <li
+        v-for="(step, index) in steps"
+        :key="step.uid"
+        :ref="(el) => setItemRef(el, step.uid)"
+        class="flex flex-wrap items-center gap-3 rounded p-2"
+        :class="{'bg-gray-100': getDropState(step.uid).type === 'is-over'}"
+      >
+        <craft-reorder-button
+          :ref="
+            (el: Parameters<typeof setHandleRef>[0]) =>
+              setHandleRef(el, step.uid)
+          "
+          .disabled="!editable || steps.length < 2"
+          :position="getRowPosition(index)"
+          @reorder="
+            reorder(index, index + ($event.detail.direction === 'up' ? -1 : 1))
+          "
+        ></craft-reorder-button>
+
+        <span class="flex-1">
+          <span class="font-bold">{{ index + 1 }}. {{ summary(step) }}</span>
+          <span v-if="errorsByStep[step.uid]" class="error block">
+            {{
+              t('The step “{step}” is invalid. Edit it to fix the problem.', {
+                step: summary(step),
+              })
+            }}
+          </span>
+        </span>
+
+        <craft-button
+          :ref="(el: HTMLElement | null) => (itemButtons[step.uid] = el)"
+          type="button"
+          @click="edit(step)"
+        >
+          {{ editable ? t('Edit') : t('View') }}
+        </craft-button>
+
+        <craft-button
+          type="button"
+          icon="trash"
+          :aria-label="t('Delete')"
+          .disabled="!editable"
+          @click="remove(step)"
+        ></craft-button>
+      </li>
+    </ol>
+
+    <ul v-if="listErrors.length" class="error-list" role="alert">
+      <li v-for="error in listErrors" :key="error">{{ error }}</li>
+    </ul>
+
+    <craft-button
+      v-if="editable"
+      ref="addButton"
+      type="button"
+      icon="plus"
+      @click="add"
+    >
+      {{ t('Add a step') }}
+    </craft-button>
+  </craft-pane>
+</template>
diff --git a/resources/js/modules/import/steps/StepMapping.test.ts b/resources/js/modules/import/steps/StepMapping.test.ts
new file mode 100644
index 00000000000..44a43cf5594
--- /dev/null
+++ b/resources/js/modules/import/steps/StepMapping.test.ts
@@ -0,0 +1,317 @@
+import {createApp, nextTick} from 'vue';
+import {afterEach, beforeEach, expect, it, vi} from 'vite-plus/test';
+import {applySuggestions, cloneValues} from '@/modules/import/mapping/paths';
+import type {
+  MappingCol,
+  MappingColEntry,
+  MappingValues,
+  StepPayload,
+  SuggestedMap,
+} from '@/modules/import/mapping/types';
+import StepMapping from './StepMapping.vue';
+
+const state = vi.hoisted(() => ({
+  layout: vi.fn(),
+  openNested: vi.fn(),
+  context: null as any,
+}));
+
+vi.mock('@/common/composables/useAppLayout', () => ({
+  useAppLayout: (options: unknown) => {
+    state.layout(options instanceof Function ? options() : options);
+  },
+}));
+
+vi.mock('@/common/slideouts', () => ({
+  useSlideout: () => null,
+}));
+
+vi.mock('@/modules/import/mapping/nested-mapping', () => ({
+  openNestedMapping: state.openNested,
+}));
+
+vi.mock('./step-mapping', () => ({
+  takeStepMappingContext: () => state.context,
+}));
+
+function col(
+  overrides: Partial<MappingCol> & {prefixedHandle: string}
+): MappingCol {
+  return {
+    handle: overrides.prefixedHandle,
+    label: overrides.prefixedHandle,
+    prefixedHandleAsArray: [overrides.prefixedHandle],
+    prefixedHandleForMap: `map[${overrides.prefixedHandle}]`,
+    prefixedHandleForMatchCriteria: `matchCriteria[${overrides.prefixedHandle}]`,
+    prefixedHandleForClear: `clearableItems[${overrides.prefixedHandle}]`,
+    isContainer: false,
+    canBeMatchCriteria: false,
+    canBeCleared: false,
+    ...overrides,
+  };
+}
+
+const title = col({prefixedHandle: 'title', canBeMatchCriteria: true});
+const body = col({
+  prefixedHandle: 'body',
+  canBeMatchCriteria: true,
+  canBeCleared: true,
+});
+const relation = col({prefixedHandle: 'author'});
+// The server reports both flags as true for a container — `CustomField` tests `$this`
+// where it means `$field` — so the fixture mirrors that rather than the ideal.
+const outerMatrix = col({
+  prefixedHandle: 'outerMatrix',
+  isContainer: true,
+  fieldUid: 'field-uid',
+  canKeepMissingNestedElements: true,
+  canBeMatchCriteria: true,
+  canBeCleared: true,
+});
+
+const step: StepPayload = {
+  uid: 'step-uid',
+  type: 'CraftCms\\Cms\\Entry\\Import\\EntryImporter',
+  file: 'people.csv',
+  transformer: null,
+  batchSize: null,
+  settings: {},
+};
+
+const urls = {
+  settingsUrl: '/actions/import/step-settings',
+  validateUrl: '/actions/import/validate-step',
+  mappingUrl: '/actions/import/step-mapping',
+  nestedColsUrl: '/actions/import/nested-mapping-cols',
+};
+
+function emptyValues(): MappingValues {
+  return {
+    map: {},
+    matchCriteria: {},
+    clearableItems: {},
+    keepMissingNestedElements: {},
+  };
+}
+
+let applied: MappingValues | null;
+
+function mount(
+  destinationCols: MappingColEntry[],
+  values: MappingValues = emptyValues(),
+  suggestedMap: SuggestedMap = {}
+) {
+  state.context = {
+    destinationCols,
+    sourceDataCols: [
+      {label: 'Please select', value: ''},
+      {label: 'Name', value: 'name'},
+      {label: 'Email', value: 'email'},
+    ],
+    values,
+    suggestedMap,
+    editable: true,
+    step,
+    urls,
+    apply: (next: MappingValues) => (applied = next),
+  };
+
+  app = createApp(StepMapping, {contextId: 'ctx', title: 'Edit mapping'});
+  app.config.compilerOptions.isCustomElement = (tag) => tag.includes('-');
+  app.mount(container);
+}
+
+/** What the panel would hand back to the step right now. */
+function apply(): MappingValues {
+  state.layout.mock.calls.at(-1)![0].onSave();
+
+  return applied!;
+}
+
+/** The `td`s of the first body row, in column order. */
+function cells(): HTMLTableCellElement[] {
+  return [...container.querySelectorAll<HTMLTableCellElement>('tbody td')];
+}
+
+/**
+ * Toggles the checkbox in the named column of the first row, the way
+ * `craft-checkbox` reports one: the host carries the state, and
+ * `model-value-changed` announces it.
+ */
+function toggleCheckbox(column: 'match' | 'clear', checked = true): void {
+  // Destination is a `th`, so the `td`s are Incoming data, Match, Clear.
+  const cell = cells()[column === 'match' ? 1 : 2]!;
+  const checkbox = cell.querySelector<HTMLElement & {checked: boolean}>(
+    'craft-checkbox'
+  )!;
+  checkbox.checked = checked;
+
+  checkbox.dispatchEvent(
+    new CustomEvent('model-value-changed', {bubbles: true, detail: {}})
+  );
+}
+
+/**
+ * `craft-combobox` rejects a value that doesn't match one of its options, and it only
+ * renders those an animation frame or so after mounting, so the tests below have to
+ * let it settle before reading or writing its value.
+ */
+function settle(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 50));
+}
+
+/** The combobox in the first row's Incoming data cell. */
+function combobox(): HTMLElement & {modelValue?: string} {
+  return cells()[0]!.querySelector(
+    'craft-combobox'
+  ) as unknown as HTMLElement & {modelValue?: string};
+}
+
+/** Picks a source column the way `craft-combobox` reports one. */
+function chooseSource(value: string): void {
+  const host = combobox();
+  host.modelValue = value;
+
+  host.dispatchEvent(
+    new CustomEvent('model-value-changed', {bubbles: true, detail: {}})
+  );
+}
+
+let app: ReturnType<typeof createApp>;
+let container: HTMLElement;
+
+beforeEach(() => {
+  state.layout.mockClear();
+  state.openNested.mockReset();
+  applied = null;
+  container = document.createElement('div');
+  document.body.append(container);
+});
+
+afterEach(() => {
+  app.unmount();
+  container.remove();
+});
+
+it('writes a chosen source column to the destination column’s path', async () => {
+  mount([title]);
+  await settle();
+
+  chooseSource('name');
+  await nextTick();
+
+  expect(apply().map).toEqual({title: 'name'});
+});
+
+it('keeps the Match and Clear columns on their own trees', () => {
+  mount([body]);
+
+  toggleCheckbox('match');
+  toggleCheckbox('clear');
+
+  expect(apply().matchCriteria).toEqual({body: '1'});
+  expect(apply().clearableItems).toEqual({body: '1'});
+});
+
+it('offers no Match or Clear on a container row', () => {
+  // The container's nested columns each carry their own decision, in the panel.
+  mount([outerMatrix]);
+
+  const [incoming, match, clear] = cells();
+
+  expect(incoming!.querySelector('craft-button')).not.toBeNull();
+  expect(match!.querySelector('craft-checkbox')).toBeNull();
+  expect(clear!.querySelector('craft-checkbox')).toBeNull();
+});
+
+it('leaves the option cells empty when neither applies', () => {
+  mount([relation]);
+
+  const [, match, clear] = cells();
+
+  expect(match!.querySelector('craft-checkbox')).toBeNull();
+  expect(clear!.querySelector('craft-checkbox')).toBeNull();
+  expect(match!.textContent!.trim()).toBe('');
+  expect(clear!.textContent!.trim()).toBe('');
+});
+
+it('hands the step’s mapping trees back on apply', () => {
+  mount([title], {...emptyValues(), map: {title: 'name'}});
+
+  expect(apply()).toEqual({
+    map: {title: 'name'},
+    matchCriteria: {},
+    clearableItems: {},
+    keepMissingNestedElements: {},
+  });
+});
+
+it('opens a container column’s nested mapping against the draft step', () => {
+  mount([outerMatrix]);
+
+  expect(container.querySelector('craft-combobox')).toBeNull();
+
+  container.querySelector('craft-button')!.dispatchEvent(new Event('click'));
+
+  expect(state.openNested).toHaveBeenCalledOnce();
+  expect(state.openNested.mock.calls[0]![0]).toMatchObject({
+    col: outerMatrix,
+    step,
+    colsUrl: urls.nestedColsUrl,
+    editable: true,
+  });
+});
+
+it('shows a suggested source column and flags it as a best guess', async () => {
+  mount([title], {...emptyValues(), map: {title: 'name'}}, {title: true});
+  await settle();
+
+  expect(combobox().modelValue).toBe('name');
+  expect(cells()[0]!.classList).toContain('best-guess');
+});
+
+it('clears the best-guess flag once the user chooses a column themselves', async () => {
+  mount([title], {...emptyValues(), map: {title: 'name'}}, {title: true});
+  await settle();
+
+  chooseSource('email');
+  await nextTick();
+
+  expect(cells()[0]!.classList).not.toContain('best-guess');
+});
+
+it('keeps a freshly guessed column flagged once the combobox settles', async () => {
+  // The context the way `step-mapping.ts` builds it: an empty map from the server,
+  // filled by the real `applySuggestions`. The other best-guess tests hand the flags
+  // in ready-made, which skips this — and it's where the flag was being lost.
+  const values = cloneValues(emptyValues());
+  const suggestedMap: SuggestedMap = {};
+  applySuggestions(values.map, {title: 'name'}, suggestedMap);
+
+  mount([title], values, suggestedMap);
+  await settle();
+
+  expect(combobox().modelValue).toBe('name');
+  expect(cells()[0]!.classList).toContain('best-guess');
+  expect(apply().map).toEqual({title: 'name'});
+});
+
+it('merges a nested panel’s result back into the trees', async () => {
+  mount([outerMatrix]);
+
+  container.querySelector('craft-button')!.dispatchEvent(new Event('click'));
+
+  const next: MappingValues = {
+    ...emptyValues(),
+    map: {outerMatrix: {outerEt: {title: 'name'}}},
+    // A container's own keep decision lives under a reserved `__keep__` leaf.
+    keepMissingNestedElements: {outerMatrix: {__keep__: '1'}},
+  };
+  state.openNested.mock.calls[0]![0].apply(next);
+  await nextTick();
+
+  expect(apply().map).toEqual(next.map);
+  expect(apply().keepMissingNestedElements).toEqual(
+    next.keepMissingNestedElements
+  );
+});
diff --git a/resources/js/modules/import/steps/StepMapping.vue b/resources/js/modules/import/steps/StepMapping.vue
new file mode 100644
index 00000000000..0e276702f67
--- /dev/null
+++ b/resources/js/modules/import/steps/StepMapping.vue
@@ -0,0 +1,45 @@
+<script setup lang="ts">
+  /**
+   * One import step's field mapping, as a slideout panel.
+   *
+   * Opened from the step's own panel — see `step-mapping.ts`. The panel edits its own
+   * copy of the step's four mapping trees and hands them back on Apply, so cancelling
+   * leaves the step behind untouched.
+   */
+  import {t} from '@craftcms/ui';
+  import MappingTable from '@/modules/import/mapping/MappingTable.vue';
+  import {useMappingPanel} from '@/modules/import/mapping/useMappingPanel';
+  import {takeStepMappingContext} from './step-mapping';
+
+  const props = defineProps<{
+    contextId: string;
+    title: string;
+  }>();
+
+  const context = takeStepMappingContext(props.contextId);
+
+  useMappingPanel({
+    title: props.title,
+    values: context.values,
+    suggestedMap: context.suggestedMap,
+    sourceDataCols: context.sourceDataCols,
+    editable: context.editable,
+    step: context.step,
+    nestedColsUrl: context.urls.nestedColsUrl,
+    apply: context.apply,
+  });
+</script>
+
+<template>
+  <div>
+    <p>
+      {{
+        t(
+          'If you see any selections marked in blue, they were auto-selected as closest matches from the incoming data. Change them if they’re not right.'
+        )
+      }}
+    </p>
+
+    <MappingTable :cols="context.destinationCols" />
+  </div>
+</template>
diff --git a/resources/js/modules/import/steps/StepSlideout.test.ts b/resources/js/modules/import/steps/StepSlideout.test.ts
new file mode 100644
index 00000000000..f89287d5f8a
--- /dev/null
+++ b/resources/js/modules/import/steps/StepSlideout.test.ts
@@ -0,0 +1,183 @@
+import {createApp, h, nextTick} from 'vue';
+import {afterEach, beforeEach, expect, it, vi} from 'vite-plus/test';
+import type {FormPayload} from '@/modules/forms/types';
+import type {StepPayload} from '@/modules/import/mapping/types';
+import StepSlideout from './StepSlideout.vue';
+
+const state = vi.hoisted(() => ({
+  layout: vi.fn(),
+  fetchStepForm: vi.fn(),
+  validateStep: vi.fn(),
+  openStepMapping: vi.fn(),
+  context: null as any,
+  refresh: null as ((values: unknown) => Promise<FormPayload>) | null,
+  errors: null as FormPayload['errors'] | null,
+}));
+
+vi.mock('@/common/composables/useAppLayout', () => ({
+  useAppLayout: (options: unknown) => {
+    state.layout(options instanceof Function ? options() : options);
+  },
+}));
+
+vi.mock('@/common/slideouts', () => ({
+  useSlideout: () => null,
+}));
+
+vi.mock('./step-mapping', () => ({
+  openStepMapping: state.openStepMapping,
+}));
+
+vi.mock('./step-slideout', () => ({
+  takeStepSlideoutContext: () => state.context,
+  fetchStepForm: state.fetchStepForm,
+  validateStep: state.validateStep,
+}));
+
+// Stubbed so the test can invoke the refresh callback the panel hands it, which is what
+// carries an updated `canMap` back from the server.
+vi.mock('@/modules/forms/FormRenderer.vue', () => ({
+  default: {
+    name: 'FormRenderer',
+    props: ['payload', 'refresh', 'errors'],
+    setup(props: any, {expose}: any) {
+      state.refresh = props.refresh;
+      expose({currentValues: () => ({settings: {}})});
+
+      return () => {
+        state.errors = props.errors;
+
+        return h('div', {class: 'form-renderer'});
+      };
+    },
+  },
+}));
+
+function payload(): FormPayload {
+  return {
+    scope: [],
+    refreshable: true,
+    nodes: [],
+    values: {},
+    errors: [],
+    globalErrors: [],
+  } as unknown as FormPayload;
+}
+
+const step: StepPayload = {
+  uid: 'step-1',
+  type: 'CraftCms\\Cms\\Entry\\Import\\EntryImporter',
+  file: 'people.csv',
+  transformer: null,
+  batchSize: null,
+  settings: {},
+};
+
+const urls = {
+  settingsUrl: '/actions/import/step-settings',
+  validateUrl: '/actions/import/validate-step',
+  mappingUrl: '/actions/import/step-mapping',
+  nestedColsUrl: '/actions/import/nested-mapping-cols',
+};
+
+let app: ReturnType<typeof createApp>;
+let container: HTMLElement;
+
+function mount(canMap: boolean) {
+  state.context = {
+    step: structuredClone(step),
+    payload: payload(),
+    canMap,
+    urls,
+    editable: true,
+    apply: vi.fn(),
+  };
+
+  app = createApp(StepSlideout, {contextId: 'ctx', title: 'Edit step'});
+  app.config.compilerOptions.isCustomElement = (tag) => tag.includes('-');
+  app.mount(container);
+}
+
+/** The Mapping section only exists while the step can be mapped. */
+function mappingSection(): HTMLElement | null {
+  return container.querySelector('section');
+}
+
+beforeEach(() => {
+  state.layout.mockClear();
+  state.fetchStepForm.mockReset();
+  state.validateStep.mockReset();
+  state.openStepMapping.mockReset();
+  state.refresh = null;
+  state.errors = null;
+  container = document.createElement('div');
+  document.body.append(container);
+});
+
+afterEach(() => {
+  app.unmount();
+  container.remove();
+});
+
+it('hides the mapping section while the step can’t be mapped', () => {
+  mount(false);
+
+  expect(mappingSection()).toBeNull();
+});
+
+it('shows the mapping section once the step can be mapped', () => {
+  mount(true);
+
+  expect(mappingSection()).not.toBeNull();
+  expect(mappingSection()!.textContent).toContain('Mapping');
+});
+
+it('reveals the mapping section when a refresh reports the step as mappable', async () => {
+  // An element importer only resolves its field layout once an entry type is chosen, which
+  // reaches the panel as a refresh — the section has to appear without reopening.
+  mount(false);
+  state.fetchStepForm.mockResolvedValue({form: payload(), canMap: true});
+
+  await state.refresh!({settings: {}});
+  await nextTick();
+
+  expect(mappingSection()).not.toBeNull();
+});
+
+it('hides the mapping section again when a refresh reports it unmappable', async () => {
+  mount(true);
+  state.fetchStepForm.mockResolvedValue({form: payload(), canMap: false});
+
+  await state.refresh!({settings: {}});
+  await nextTick();
+
+  expect(mappingSection()).toBeNull();
+});
+
+it('keeps the slideout open and shows the errors when the draft step is invalid', async () => {
+  mount(true);
+  state.validateStep.mockRejectedValue({
+    response: {data: {errors: {file: ['File must be provided.']}}},
+  });
+
+  const onSave = state.layout.mock.calls.at(-1)![0].onSave;
+  await onSave();
+  await nextTick();
+
+  expect(state.context.apply).not.toHaveBeenCalled();
+  expect(state.errors).toEqual([
+    {path: ['file'], messages: ['File must be provided.']},
+  ]);
+});
+
+it('applies the step and lets the slideout close once it validates', async () => {
+  mount(true);
+  state.validateStep.mockResolvedValue(undefined);
+
+  const onSave = state.layout.mock.calls.at(-1)![0].onSave;
+  await onSave();
+
+  expect(state.context.apply).toHaveBeenCalledWith(
+    expect.objectContaining({uid: 'step-1'})
+  );
+});
diff --git a/resources/js/modules/import/steps/StepSlideout.vue b/resources/js/modules/import/steps/StepSlideout.vue
new file mode 100644
index 00000000000..0abf8dd1856
--- /dev/null
+++ b/resources/js/modules/import/steps/StepSlideout.vue
@@ -0,0 +1,233 @@
+<script setup lang="ts">
+  /**
+   * One import step's settings, as a slideout panel.
+   *
+   * Opened with `openSlideoutWith()` — see `step-slideout.ts` for why. The panel edits
+   * a copy of the step and hands it back on Apply; the step only reaches the database
+   * when the import itself is saved.
+   */
+  import '@craftcms/ui/components/button/button';
+  import {computed, ref, shallowRef} from 'vue';
+  import {useForm} from '@inertiajs/vue3';
+  import {t} from '@craftcms/ui';
+  import {useAppLayout} from '@/common/composables/useAppLayout';
+  import {useSlideout} from '@/common/slideouts';
+  import FormRenderer from '@/modules/forms/FormRenderer.vue';
+  import type {FormPayload} from '@/modules/forms/types';
+  import type {
+    MappingValues,
+    StepPayload,
+  } from '@/modules/import/mapping/types';
+  import {
+    fetchStepForm,
+    takeStepSlideoutContext,
+    validateStep,
+  } from './step-slideout';
+  import {openStepMapping} from './step-mapping';
+
+  const props = defineProps<{
+    contextId: string;
+    title: string;
+  }>();
+
+  const context = takeStepSlideoutContext(props.contextId);
+  const slideout = useSlideout();
+  const payload = shallowRef<FormPayload>(context.payload);
+  const errors = shallowRef<FormPayload['errors']>([]);
+  const renderer = ref<{
+    currentValues(): FormPayload['values'];
+  } | null>(null);
+
+  /** The step as it currently stands, including mapping the form doesn't render. */
+  const step = ref<StepPayload>(context.step);
+  const mappingButton = ref<HTMLElement | null>(null);
+  const mappingMessage = ref<string | null>(null);
+
+  /**
+   * Backs the shell's Apply button and gives it an accurate dirty check for the
+   * unsaved-changes prompt.
+   */
+  const form = useForm({state: JSON.stringify(context.step)});
+
+  useAppLayout(() => ({
+    title: props.title,
+    submitButtonLabel: t('Apply'),
+    form,
+    onSave: done,
+  }));
+
+  /**
+   * Whether the step can be mapped, as the server last reported it. An element importer
+   * has no destination columns until its field layout resolves from what it imports into,
+   * so this tracks every refresh rather than being derived from the step here.
+   */
+  const canMap = ref(context.canMap);
+
+  const mappedCount = computed(() => countLeaves(mappingValues().map));
+
+  function mappingValues(): MappingValues {
+    const settings = step.value.settings ?? {};
+
+    return {
+      map: (settings.map ?? {}) as Record<string, unknown>,
+      matchCriteria: (settings.matchCriteria ?? {}) as Record<string, unknown>,
+      clearableItems: (settings.clearableItems ?? {}) as Record<
+        string,
+        unknown
+      >,
+      keepMissingNestedElements: (settings.keepMissingNestedElements ??
+        {}) as Record<string, unknown>,
+    };
+  }
+
+  function countLeaves(tree: unknown): number {
+    if (tree === null || tree === undefined || tree === '') {
+      return 0;
+    }
+
+    if (typeof tree !== 'object') {
+      return 1;
+    }
+
+    return Object.values(tree as Record<string, unknown>).reduce<number>(
+      (total, value) => total + countLeaves(value),
+      0
+    );
+  }
+
+  /** Folds the form's current values back into the step. */
+  function syncFromForm(): void {
+    const values = renderer.value?.currentValues() ?? {};
+    const settings = (values.settings ?? {}) as Record<string, unknown>;
+    const batchSize = values.batchSize;
+
+    step.value = {
+      ...step.value,
+      type: (values.type as string) || null,
+      file: (values.file as string) || null,
+      transformer: (values.transformer as string) || null,
+      batchSize:
+        batchSize === null || batchSize === undefined || batchSize === ''
+          ? null
+          : Number(batchSize),
+      // the mapping trees live on the step, not in the form, so they're carried over
+      settings: {...settings, ...mappingValues()},
+    };
+
+    form.state = JSON.stringify(step.value);
+  }
+
+  function onChange(): void {
+    syncFromForm();
+  }
+
+  async function editMapping(): Promise<void> {
+    syncFromForm();
+    mappingMessage.value = null;
+
+    const opened = await openStepMapping(
+      {
+        step: step.value,
+        urls: context.urls,
+        editable: context.editable,
+        opener: mappingButton.value,
+        apply: (applied) => {
+          step.value = {
+            ...step.value,
+            settings: {...step.value.settings, ...applied},
+          };
+          form.state = JSON.stringify(step.value);
+        },
+      },
+      t('Edit mapping')
+    );
+
+    if (!opened) {
+      mappingMessage.value = t(
+        'Choose what this step imports into, and a data file, before mapping.'
+      );
+    }
+  }
+
+  async function refresh(values: FormPayload['values']): Promise<FormPayload> {
+    syncFromForm();
+
+    const response = await fetchStepForm(context.urls.settingsUrl, {
+      ...step.value,
+      settings: {
+        ...((values.settings ?? {}) as Record<string, unknown>),
+        ...mappingValues(),
+      },
+    });
+
+    canMap.value = response.canMap;
+
+    return response.form;
+  }
+
+  function setErrors(next: Record<string, string | string[]>): void {
+    errors.value = Object.entries(next).map(([path, messages]) => ({
+      path: path.split('.'),
+      messages: Array.isArray(messages) ? messages : [messages],
+    }));
+  }
+
+  async function done(): Promise<void> {
+    syncFromForm();
+    errors.value = [];
+
+    if (context.urls.validateUrl) {
+      try {
+        await validateStep(context.urls.validateUrl, step.value);
+      } catch (error: any) {
+        const responseErrors = error?.response?.data?.errors;
+
+        if (responseErrors) {
+          setErrors(responseErrors);
+        }
+
+        return;
+      }
+    }
+
+    context.apply(JSON.parse(JSON.stringify(step.value)) as StepPayload);
+
+    // Before close(): closing drops the panel from the store, and its handler with it.
+    slideout?.saved();
+    slideout?.close({force: true});
+  }
+</script>
+
+<template>
+  <div class="grid gap-6">
+    <FormRenderer
+      ref="renderer"
+      :payload="payload"
+      :errors="errors"
+      :refresh="payload.refreshable ? refresh : undefined"
+      @change="onChange"
+    />
+
+    <section v-if="canMap">
+      <h3>{{ t('Mapping') }}</h3>
+
+      <p>
+        {{
+          mappedCount === 0
+            ? t('Nothing mapped yet.')
+            : t('{count} columns mapped.', {count: mappedCount})
+        }}
+      </p>
+
+      <craft-button
+        ref="mappingButton"
+        .disabled="!context.editable"
+        @click="editMapping"
+      >
+        {{ t('Edit mapping') }}
+      </craft-button>
+
+      <p v-if="mappingMessage">{{ mappingMessage }}</p>
+    </section>
+  </div>
+</template>
diff --git a/resources/js/modules/import/steps/step-mapping.test.ts b/resources/js/modules/import/steps/step-mapping.test.ts
new file mode 100644
index 00000000000..67dfca21783
--- /dev/null
+++ b/resources/js/modules/import/steps/step-mapping.test.ts
@@ -0,0 +1,106 @@
+import {expect, it, vi} from 'vite-plus/test';
+import {actionClient} from '@craftcms/ui';
+import type {StepPayload} from '@/modules/import/mapping/types';
+import {openStepMapping, takeStepMappingContext} from './step-mapping';
+
+const state = vi.hoisted(() => ({
+  openSlideoutWith: vi.fn(),
+}));
+
+vi.mock('@/common/slideouts', () => ({
+  openSlideoutWith: state.openSlideoutWith,
+}));
+
+const step: StepPayload = {
+  uid: 'step-1',
+  type: 'CraftCms\\Cms\\Entry\\Import\\EntryImporter',
+  file: 'people.csv',
+  transformer: null,
+  batchSize: null,
+  settings: {},
+};
+
+const urls = {
+  settingsUrl: '/actions/import/step-settings',
+  validateUrl: '/actions/import/validate-step',
+  mappingUrl: '/actions/import/step-mapping',
+  nestedColsUrl: '/actions/import/nested-mapping-cols',
+};
+
+/** The context the panel would be handed, for a given server response. */
+async function contextFor(data: Record<string, unknown>) {
+  let contextId: string | undefined;
+  state.openSlideoutWith.mockReset();
+  state.openSlideoutWith.mockImplementation((_component, props) => {
+    contextId = props.contextId;
+
+    return {};
+  });
+  vi.spyOn(actionClient, 'post').mockResolvedValue({data} as never);
+
+  await openStepMapping(
+    {step, urls, editable: true, opener: null, apply: () => {}},
+    'Edit mapping'
+  );
+
+  return takeStepMappingContext(contextId!);
+}
+
+it('flags the leaves it filled from the server’s suggestions', async () => {
+  // PHP has one array type, so an untouched map and an empty tree both arrive as `[]`.
+  const context = await contextFor({
+    available: true,
+    destinationCols: [],
+    sourceDataCols: [{label: 'Name', value: 'name'}],
+    values: {
+      map: [],
+      matchCriteria: [],
+      clearableItems: [],
+      keepMissingNestedElements: [],
+    },
+    suggestions: {title: 'name'},
+  });
+
+  expect(context.values.map).toEqual({title: 'name'});
+  expect(context.suggestedMap).toEqual({title: true});
+});
+
+it('flags nested leaves inside a container’s branch', async () => {
+  const context = await contextFor({
+    available: true,
+    destinationCols: [],
+    sourceDataCols: [{label: 'Name', value: 'name'}],
+    values: {
+      map: [],
+      matchCriteria: [],
+      clearableItems: [],
+      keepMissingNestedElements: [],
+    },
+    suggestions: {outerMatrix: {outerEt: {title: 'name'}}},
+  });
+
+  expect(context.values.map).toEqual({
+    outerMatrix: {outerEt: {title: 'name'}},
+  });
+  expect(context.suggestedMap).toEqual({
+    outerMatrix: {outerEt: {title: true}},
+  });
+});
+
+it('leaves an already-mapped leaf unflagged', async () => {
+  const context = await contextFor({
+    available: true,
+    destinationCols: [],
+    sourceDataCols: [{label: 'Name', value: 'name'}],
+    values: {
+      map: {title: 'email'},
+      matchCriteria: [],
+      clearableItems: [],
+      keepMissingNestedElements: [],
+    },
+    suggestions: {title: 'name'},
+  });
+
+  expect(context.values.map).toEqual({title: 'email'});
+  expect(context.suggestedMap).toEqual({});
+});
diff --git a/resources/js/modules/import/steps/step-mapping.ts b/resources/js/modules/import/steps/step-mapping.ts
new file mode 100644
index 00000000000..a9e6847a5cf
--- /dev/null
+++ b/resources/js/modules/import/steps/step-mapping.ts
@@ -0,0 +1,125 @@
+/**
+ * Opening one step's field mapping in a slideout panel, from inside that step's own
+ * panel.
+ *
+ * Same shape as `nested-mapping.ts`: the server is POSTed the draft step and returns
+ * only the structure — which destination columns exist and what the source file's
+ * headings are — while the panel edits a copy of the step's mapping trees and hands
+ * them back on Apply.
+ */
+import {actionClient} from '@craftcms/ui';
+import type {InertiaPageComponent} from '@/bootstrap/inertia-pages';
+import {
+  createContextRegistry,
+  openContextSlideout,
+} from '@/modules/import/context-slideout';
+import {
+  applySuggestions,
+  cloneValues,
+  toObjectTree,
+} from '@/modules/import/mapping/paths';
+import type {
+  MappingColEntry,
+  MappingValues,
+  SourceDataCol,
+  StepPayload,
+  SuggestedMap,
+} from '@/modules/import/mapping/types';
+import type {StepUrls} from './step-slideout';
+
+export interface StepMappingContext {
+  destinationCols: MappingColEntry[];
+  sourceDataCols: SourceDataCol[];
+  values: MappingValues;
+  suggestedMap: SuggestedMap;
+  editable: boolean;
+  step: StepPayload;
+  urls: StepUrls;
+  apply(values: MappingValues): void;
+}
+
+export interface OpenStepMappingOptions {
+  step: StepPayload;
+  urls: StepUrls;
+  editable: boolean;
+  opener: HTMLElement | null;
+  apply(values: MappingValues): void;
+}
+
+const registry = createContextRegistry<StepMappingContext>(
+  'import-step-mapping'
+);
+
+export function takeStepMappingContext(contextId: string): StepMappingContext {
+  return registry.take(contextId);
+}
+
+export interface StepMappingStructure {
+  available: boolean;
+  message?: string;
+  destinationCols?: MappingColEntry[];
+  sourceDataCols?: SourceDataCol[];
+  values?: MappingValues;
+  suggestions?: SuggestedMap;
+}
+
+/** Asks the server for a draft step's mapping structure. */
+export async function fetchStepMapping(
+  mappingUrl: string,
+  step: StepPayload
+): Promise<StepMappingStructure> {
+  const {data} = await actionClient.post(mappingUrl, {step});
+
+  return data as StepMappingStructure;
+}
+
+/**
+ * Returns false when the panel was not opened — either the step isn't ready to be
+ * mapped yet, or the user declined to discard unsaved changes in a panel this one
+ * would have replaced.
+ */
+export async function openStepMapping(
+  options: OpenStepMappingOptions,
+  title: string
+): Promise<boolean> {
+  const data = await fetchStepMapping(options.urls.mappingUrl, options.step);
+
+  if (!data.available) {
+    return false;
+  }
+
+  const values = cloneValues(
+    data.values ?? {
+      map: {},
+      matchCriteria: {},
+      clearableItems: {},
+      keepMissingNestedElements: {},
+    }
+  );
+  const suggestedMap: SuggestedMap = {};
+  applySuggestions(
+    values.map,
+    toObjectTree(data.suggestions ?? {}),
+    suggestedMap
+  );
+
+  return openContextSlideout(
+    registry,
+    () =>
+      import('./StepMapping.vue').then(
+        (m) => m.default as InertiaPageComponent
+      ),
+    {
+      destinationCols: data.destinationCols ?? [],
+      sourceDataCols: data.sourceDataCols ?? [],
+      values,
+      suggestedMap,
+      editable: options.editable,
+      step: options.step,
+      urls: options.urls,
+      apply: options.apply,
+    },
+    title,
+    options.opener
+  );
+}
diff --git a/resources/js/modules/import/steps/step-slideout.ts b/resources/js/modules/import/steps/step-slideout.ts
new file mode 100644
index 00000000000..ea2a54f8f44
--- /dev/null
+++ b/resources/js/modules/import/steps/step-slideout.ts
@@ -0,0 +1,114 @@
+/**
+ * Opening one import step's settings in a slideout panel.
+ *
+ * Opened with `openSlideoutWith()` rather than `openSlideout()`: a step is unsaved
+ * client state the edit screen holds, with no URL to fetch. The server is POSTed the
+ * draft step and returns only a Form payload for it; the panel edits a copy and hands
+ * it back on Done, so cancelling leaves the screen untouched and nothing reaches the
+ * database until the import itself is saved.
+ */
+import {actionClient} from '@craftcms/ui';
+import type {InertiaPageComponent} from '@/bootstrap/inertia-pages';
+import {
+  createContextRegistry,
+  openContextSlideout,
+} from '@/modules/import/context-slideout';
+import {cloneStep} from '@/modules/import/mapping/paths';
+import type {FormPayload} from '@/modules/forms/types';
+import type {StepPayload} from '@/modules/import/mapping/types';
+
+export interface StepUrls {
+  settingsUrl: string;
+  validateUrl: string | null;
+  mappingUrl: string;
+  nestedColsUrl: string;
+}
+
+export interface StepFormResponse {
+  form: FormPayload;
+  /**
+   * Whether the step has settled enough to be mapped. An element importer has no
+   * destination columns until its field layout resolves, which only the server can tell.
+   */
+  canMap: boolean;
+}
+
+export interface StepSlideoutContext {
+  step: StepPayload;
+  payload: FormPayload;
+  canMap: boolean;
+  urls: StepUrls;
+  editable: boolean;
+  apply(step: StepPayload): void;
+}
+
+export interface OpenStepSlideoutOptions {
+  step: StepPayload;
+  urls: StepUrls;
+  editable: boolean;
+  opener: HTMLElement | null;
+  apply(step: StepPayload): void;
+}
+
+const registry = createContextRegistry<StepSlideoutContext>('import-step');
+
+export function takeStepSlideoutContext(
+  contextId: string
+): StepSlideoutContext {
+  return registry.take(contextId);
+}
+
+/** Fetches the form for a draft step, and whether that step can be mapped yet. */
+export async function fetchStepForm(
+  settingsUrl: string,
+  step: StepPayload
+): Promise<StepFormResponse> {
+  const {data} = await actionClient.post(settingsUrl, {step});
+
+  if (!data.form) {
+    throw new Error('The import step did not return a Form payload.');
+  }
+
+  return {form: data.form as FormPayload, canMap: Boolean(data.canMap)};
+}
+
+/**
+ * Validates a draft step against its importer type's rules. Rejects with the axios error
+ * (carrying `response.data.errors`) when the step is invalid.
+ */
+export async function validateStep(
+  validateUrl: string,
+  step: StepPayload
+): Promise<void> {
+  await actionClient.post(validateUrl, {step});
+}
+
+/**
+ * Returns false when the panel was not opened — the user declined to discard unsaved
+ * changes in a panel this one would have replaced.
+ */
+export async function openStepSlideout(
+  options: OpenStepSlideoutOptions,
+  title: string
+): Promise<boolean> {
+  const step = cloneStep(options.step);
+  const {form, canMap} = await fetchStepForm(options.urls.settingsUrl, step);
+
+  return openContextSlideout(
+    registry,
+    () =>
+      import('./StepSlideout.vue').then(
+        (m) => m.default as InertiaPageComponent
+      ),
+    {
+      step,
+      payload: form,
+      canMap,
+      urls: options.urls,
+      editable: options.editable,
+      apply: options.apply,
+    },
+    title,
+    options.opener
+  );
+}
diff --git a/resources/js/pages/Form.vue b/resources/js/pages/Form.vue
index 6bf9bf4b87b..fd8ff6d5ccf 100644
--- a/resources/js/pages/Form.vue
+++ b/resources/js/pages/Form.vue
@@ -2,7 +2,7 @@
   import {actionClient} from '@craftcms/ui';
   import type {UrlMethodPair} from '@inertiajs/core';
   import {useForm} from '@inertiajs/vue3';
-  import {shallowRef, toRaw} from 'vue';
+  import {shallowRef, toRaw, watch} from 'vue';
   import {
     useAppLayout,
     type UseAppLayoutOptions,
@@ -25,6 +25,13 @@
     elevatedFields?: string[] | '*';
     refreshUrl?: string;
     defaultFormActions?: UseAppLayoutOptions['defaultFormActions'];
+    /**
+     * State the page owns outside the rendered form — a repeatable list edited in a
+     * slideout, say — posted alongside the form's own values and counted towards the
+     * unsaved-changes prompt. `transform` replaces the posted data wholesale, so the
+     * serialization below that backs the dirty check never reaches the server.
+     */
+    additionalData?: Record<string, unknown>;
   }>();
   const emit = defineEmits<{
     (event: 'change', change: FormChange, values: FormPayload['values']): void;
@@ -36,8 +43,24 @@
   const elevatedFields = props.elevatedFields;
   const {advanceBaseline, errors, onMutation, renderer} =
     useInertiaFormRenderer(inertiaForm, () => props.form);
+  if (props.additionalData !== undefined) {
+    watch(
+      () => props.additionalData,
+      (additionalData) => {
+        Object.assign(inertiaForm, {
+          __additionalData: JSON.stringify(additionalData),
+        });
+      },
+      {deep: true, immediate: true}
+    );
+    inertiaForm.defaults();
+  }
+
   const {save} = useSettingsSave(inertiaForm, () => props.submit, {
-    transform: () => renderer.value?.currentValues() ?? props.form.values,
+    transform: () => ({
+      ...(renderer.value?.currentValues() ?? props.form.values),
+      ...props.additionalData,
+    }),
     onSuccess: () => {
       elevatedBaseline.value = structuredClone(
         toRaw(renderer.value?.currentValues() ?? props.form.values)
diff --git a/resources/js/pages/import/Edit.vue b/resources/js/pages/import/Edit.vue
new file mode 100644
index 00000000000..4bd5d336ea5
--- /dev/null
+++ b/resources/js/pages/import/Edit.vue
@@ -0,0 +1,70 @@
+<script setup lang="ts">
+  /**
+   * An import: its name and handle, and the ordered list of steps that make it up.
+   *
+   * The steps are held here, edited in slideouts, and posted alongside the form when
+   * the screen is saved — nothing about a step reaches the database before that.
+   */
+  import type {UrlMethodPair} from '@inertiajs/core';
+  import {usePage} from '@inertiajs/vue3';
+  import {computed, ref} from 'vue';
+  import FormPage from '@/pages/Form.vue';
+  import type {FormPayload} from '@/modules/forms/types';
+  import type {StepPayload} from '@/modules/import/mapping/types';
+  import {cloneSteps} from '@/modules/import/mapping/paths';
+  import StepList from '@/modules/import/steps/StepList.vue';
+
+  const props = defineProps<{
+    form: FormPayload;
+    submit: UrlMethodPair;
+    steps: StepPayload[];
+    importerTypes: Array<{value: string; label: string}>;
+    stepSettingsUrl: string | null;
+    validateStepUrl: string | null;
+    stepMappingUrl: string;
+    nestedColsUrl: string;
+    readOnly: boolean;
+    canSave: boolean;
+  }>();
+
+  const page = usePage<{errors?: Record<string, string | string[]>}>();
+
+  const editable = !props.readOnly && props.canSave;
+  const steps = ref<StepPayload[]>(cloneSteps(props.steps));
+
+  const urls = {
+    settingsUrl: props.stepSettingsUrl ?? props.stepMappingUrl,
+    validateUrl: props.validateStepUrl,
+    mappingUrl: props.stepMappingUrl,
+    nestedColsUrl: props.nestedColsUrl,
+  };
+
+  const additionalData = computed(() => ({steps: steps.value}));
+
+  // `steps` on its own is the list's error (no steps at all); `steps.<uid>.*` belongs to
+  // one row. Both go to the list, which decides where each one renders.
+  const stepErrors = computed(() =>
+    Object.fromEntries(
+      Object.entries(page.props.errors ?? {})
+        .filter(([path]) => path === 'steps' || path.startsWith('steps.'))
+        .map(([path, messages]) => [
+          path,
+          Array.isArray(messages) ? messages : [messages],
+        ])
+    )
+  );
+</script>
+
+<template>
+  <div class="grid gap-6">
+    <FormPage :form="form" :submit="submit" :additional-data="additionalData" />
+
+    <StepList
+      v-model="steps"
+      :urls="urls"
+      :editable="editable"
+      :importer-types="importerTypes"
+      :errors="stepErrors"
+    />
+  </div>
+</template>
diff --git a/resources/js/pages/import/Index.vue b/resources/js/pages/import/Index.vue
new file mode 100644
index 00000000000..e221730a477
--- /dev/null
+++ b/resources/js/pages/import/Index.vue
@@ -0,0 +1,207 @@
+<script setup lang="ts">
+  import {t} from '@craftcms/ui';
+  import AdminTable from '@/modules/admin-table/components/AdminTable.vue';
+  import {getCoreRowModel, useVueTable} from '@tanstack/vue-table';
+  import {h, ref} from 'vue';
+  import Empty from '@/common/components/Empty.vue';
+  import CpLink from '@/common/components/CpLink.vue';
+  import {createCraftColumnHelper} from '@/modules/admin-table/helpers/createCraftColumnHelper';
+  import {router} from '@inertiajs/vue3';
+  import LayoutSlot from '@/common/components/LayoutSlot.vue';
+  import ActionMenu from '@/common/components/ActionMenu.vue';
+  import type {ActionItems} from '@/common/types';
+  import {
+    create,
+    destroy,
+    duplicate,
+    run,
+  } from '@actions/Import/ImportController';
+  import CpContainer from '@/common/components/CpContainer.vue';
+
+  interface ImportRow {
+    uid: string | null;
+    name: string;
+    handle: string;
+    description: string | null;
+    stepCount: number;
+    stepLabels: string[];
+    editUrl: string | null;
+  }
+
+  const props = defineProps<{
+    readOnly: boolean;
+    canSave: boolean;
+    canDelete: boolean;
+    canTrigger: boolean;
+    editableImports: Array<ImportRow>;
+    nonEditableImports: Array<ImportRow>;
+  }>();
+
+  function stepsCell(row: ImportRow) {
+    if (row.stepCount === 0) {
+      return t('No steps');
+    }
+
+    return h(
+      'div',
+      row.stepLabels.map((label, i) => h('div', `${i + 1}. ${label}`))
+    );
+  }
+
+  function runAction(body: Record<string, string | null>): ActionItems[number] {
+    return {
+      type: 'button',
+      label: t('Run'),
+      onClick: () => router.post(run().url, body),
+    };
+  }
+
+  const columnHelper = createCraftColumnHelper<ImportRow>();
+  const editableColumns = ref([
+    columnHelper.link('name', {
+      header: t('Name'),
+      props: ({row}) => ({
+        href: row.original.editUrl ?? '',
+        inertia: false,
+      }),
+    }),
+    columnHelper.handle('handle'),
+    columnHelper.accessor('stepCount', {
+      header: t('Steps'),
+      cell: ({row}) => stepsCell(row.original),
+    }),
+    columnHelper.actions(({row}) => {
+      const actions: ActionItems = [
+        {
+          type: 'link',
+          label: t('Edit'),
+          href: row.original.editUrl ?? '',
+        },
+      ];
+
+      if (props.canTrigger) {
+        actions.push(runAction({uid: row.original.uid}));
+      }
+
+      if (props.canSave) {
+        actions.push({
+          type: 'button',
+          label: t('Duplicate'),
+          onClick: () => router.post(duplicate().url, {uid: row.original.uid}),
+        });
+      }
+
+      if (props.canDelete) {
+        actions.push({
+          type: 'button',
+          label: t('Delete'),
+          variant: 'danger',
+          onClick: () => {
+            if (
+              !window.confirm(
+                t('Are you sure you want to delete “{name}”?', {
+                  name: row.original.name,
+                })
+              )
+            ) {
+              return;
+            }
+            router.delete(destroy().url, {
+              data: {uid: row.original.uid},
+            });
+          },
+        });
+      }
+
+      return [h(ActionMenu, {actions})];
+    }),
+  ]);
+
+  const editableTable = useVueTable<ImportRow>({
+    get data() {
+      return props.editableImports;
+    },
+    get columns() {
+      return editableColumns.value;
+    },
+    enableSorting: false,
+    getCoreRowModel: getCoreRowModel<ImportRow>(),
+  });
+
+  const nonEditableColumns = ref([
+    columnHelper.accessor('name', {
+      header: t('Name'),
+      cell: ({row, getValue}) =>
+        h('div', [h('div', {class: 'font-bold'}, getValue())]),
+    }),
+    columnHelper.handle('handle'),
+    columnHelper.accessor('stepCount', {
+      header: t('Steps'),
+      cell: ({row}) => stepsCell(row.original),
+    }),
+    columnHelper.actions(({row}) => {
+      if (!props.canTrigger) {
+        return [];
+      }
+
+      return [
+        h(ActionMenu, {
+          actions: [runAction({handle: row.original.handle})],
+        }),
+      ];
+    }),
+  ]);
+
+  const nonEditableTable = useVueTable<ImportRow>({
+    get data() {
+      return props.nonEditableImports;
+    },
+    get columns() {
+      return nonEditableColumns.value;
+    },
+    enableSorting: false,
+    getCoreRowModel: getCoreRowModel<ImportRow>(),
+  });
+</script>
+
+<template>
+  <LayoutSlot v-if="canSave" name="content-actions">
+    <CpLink
+      variant="accent"
+      appearance="button"
+      :href="create().url"
+      :inertia="false"
+    >
+      {{ t('New import') }}
+    </CpLink>
+  </LayoutSlot>
+
+  <CpContainer class="@container">
+    <div class="grid gap-6">
+      <craft-pane>
+        <div>
+          <h3>{{ t('Editable Imports') }}</h3>
+          <p>
+            {{ t('Those imports can be edited in the Control Panel') }}
+          </p>
+        </div>
+
+        <AdminTable :table="editableTable" :reorderable="false">
+          <template #empty-row>
+            <Empty :label="t('No imports yet.')" icon="light/upload" />
+          </template>
+        </AdminTable>
+      </craft-pane>
+
+      <craft-pane v-if="nonEditableImports.length">
+        <div>
+          <h3>{{ t('Non-Editable Imports') }}</h3>
+          <p>
+            {{ t('Those imports can be edited in the config file.') }}
+          </p>
+        </div>
+        <AdminTable :table="nonEditableTable" :reorderable="false"></AdminTable>
+      </craft-pane>
+    </div>
+  </CpContainer>
+</template>
diff --git a/routes/actions.php b/routes/actions.php
index e66204e5973..63fb63527a7 100644
--- a/routes/actions.php
+++ b/routes/actions.php
@@ -63,6 +63,7 @@
 use CraftCms\Cms\Http\Controllers\FieldsController;
 use CraftCms\Cms\Http\Controllers\Gql\ApiController as GqlApiController;
 use CraftCms\Cms\Http\Controllers\IconController;
+use CraftCms\Cms\Http\Controllers\Import\ImportController;
 use CraftCms\Cms\Http\Controllers\MatrixController;
 use CraftCms\Cms\Http\Controllers\MigrateController;
 use CraftCms\Cms\Http\Controllers\NestedElementsController;
@@ -326,6 +327,18 @@
             Route::post('fields/render-card-preview', [FieldsController::class, 'renderCardPreview']);
         });
 
+        // Import
+        Route::middleware('can:saveImports')->group(function () {
+            Route::post('import/save', [ImportController::class, 'store']);
+            Route::post('import/duplicate', [ImportController::class, 'duplicate']);
+            Route::post('import/step-settings', [ImportController::class, 'stepSettings']);
+            Route::post('import/validate-step', [ImportController::class, 'validateStep']);
+            Route::post('import/step-mapping', [ImportController::class, 'stepMapping']);
+            Route::post('import/nested-mapping-cols', [ImportController::class, 'nestedMappingCols']);
+        });
+        Route::middleware('can:deleteImports')->delete('import/delete', [ImportController::class, 'destroy']);
+        Route::middleware('can:triggerImports')->post('import/run', [ImportController::class, 'run']);
+
         // Matrix
         Route::post('matrix/default-table-column-options', [MatrixController::class, 'defaultTableColumnOptions']);
         Route::post('matrix/create-entry', [MatrixController::class, 'createEntry']);
diff --git a/routes/cp.php b/routes/cp.php
index 585c6350bbc..1748aaaebc0 100644
--- a/routes/cp.php
+++ b/routes/cp.php
@@ -28,6 +28,7 @@
 use CraftCms\Cms\Http\Controllers\Gql\IndexController as GqlIndexController;
 use CraftCms\Cms\Http\Controllers\Gql\SchemasController;
 use CraftCms\Cms\Http\Controllers\Gql\TokensController;
+use CraftCms\Cms\Http\Controllers\Import\ImportController;
 use CraftCms\Cms\Http\Controllers\InstallController;
 use CraftCms\Cms\Http\Controllers\NotificationsController;
 use CraftCms\Cms\Http\Controllers\PluginsController;
@@ -215,6 +216,14 @@
         ->name('content.index')
         ->where('page', '[^\/]+');
 
+    /**
+     * Import
+     */
+    Route::middleware('can:viewImports')->group(function () {
+        Route::get('import', [ImportController::class, 'index']);
+        Route::middleware('can:saveImports')->get('import/new', [ImportController::class, 'create']);
+        Route::get('import/{handle}', [ImportController::class, 'edit']);
+    });
     /**
      * Users
      */
diff --git a/scripts/copyicons.php b/scripts/copyicons.php
index 505a7ec8efd..0ace990661a 100644
--- a/scripts/copyicons.php
+++ b/scripts/copyicons.php
@@ -15,6 +15,7 @@
     'envelope',
     'files',
     'folder-open',
+    'gear',
     'globe',
     'image',
     'map-location',
@@ -25,6 +26,7 @@
     'sitemap',
     'sliders',
     'tags',
+    'upload',
     'user-group',
 ];
 
diff --git a/src/Asset/AssetsHelper.php b/src/Asset/AssetsHelper.php
index 5c3a22fe777..252ab95c3dc 100644
--- a/src/Asset/AssetsHelper.php
+++ b/src/Asset/AssetsHelper.php
@@ -22,11 +22,16 @@
 use CraftCms\Cms\Support\PHP;
 use CraftCms\Cms\Support\Str;
 use CraftCms\Cms\Support\Url;
+use CraftCms\UrlValidator\UrlValidationException;
+use CraftCms\UrlValidator\UrlValidator;
 use DateTimeInterface;
 use Exception;
+use GuzzleHttp\RequestOptions;
+use GuzzleHttp\TransferStats;
 use Illuminate\Contracts\Filesystem\Filesystem as LaravelFilesystem;
 use Illuminate\Filesystem\FilesystemAdapter;
 use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Http;
 use InvalidArgumentException;
 use Throwable;
 use Twig\Error\RuntimeError;
@@ -571,4 +576,45 @@ public static function resolveSubpath(Volume $volume, ?string $subpath, ?Element
 
         return [$subpath, $folder];
     }
+
+    /**
+     * Downloads a remote file to a temp path, pinning the connection to a set of
+     * pre-validated IP addresses so cURL can’t re-resolve the hostname to a
+     * different (potentially internal) address between validation and download.
+     *
+     * @throws InvalidArgumentException if the connection still resolves to a disallowed IP
+     */
+    public static function downloadUrl(string $url, string $tempPath): void
+    {
+        $urlValidator = new UrlValidator;
+
+        // Validate the URL and resolve it to a known-good set of IPs *before*
+        // opening any connection (guards against SSRF + DNS rebinding).
+        try {
+            $ips = $urlValidator->validate($url);
+        } catch (UrlValidationException $e) {
+            throw new InvalidArgumentException("$url is invalid.", previous: $e);
+        }
+
+        $host = parse_url($url, PHP_URL_HOST);
+        $port = parse_url($url, PHP_URL_PORT)
+            ?? (strtolower((string) parse_url($url, PHP_URL_SCHEME)) === 'https' ? 443 : 80);
+
+        Http::create()->withOptions([
+            RequestOptions::ALLOW_REDIRECTS => false,
+            RequestOptions::SINK => $tempPath,
+            // Pin the connection to the IPs we already validated, so cURL doesn’t
+            // re-resolve the hostname to a different address (DNS rebinding).
+            'curl' => [
+                CURLOPT_RESOLVE => ["$host:$port:".implode(',', $ips)],
+            ],
+            RequestOptions::ON_STATS => function (TransferStats $stats) use ($url, $urlValidator) {
+                // Validate the IP, in case the cURL handler isn’t in use (so CURLOPT_RESOLVE was ignored)
+                $ip = $stats->getHandlerStat('primary_ip');
+                if ($ip && ! $urlValidator->validateIp($ip)) {
+                    throw new InvalidArgumentException("$url is invalid.");
+                }
+            },
+        ])->get($url)->throw();
+    }
 }
diff --git a/src/Asset/Commands/ImportAsset.php b/src/Asset/Commands/ImportAsset.php
new file mode 100644
index 00000000000..860b4688e8a
--- /dev/null
+++ b/src/Asset/Commands/ImportAsset.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Asset\Commands;
+
+use CraftCms\Cms\Asset\Data\Volume;
+use CraftCms\Cms\Asset\Import\AssetImporter;
+use CraftCms\Cms\Import\Commands\Import;
+use CraftCms\Cms\Support\Facades\Volumes;
+use Override;
+use Symfony\Component\Console\Input\InputOption;
+
+use function Laravel\Prompts\select;
+
+class ImportAsset extends Import
+{
+    #[Override]
+    protected $name = 'craft:import:asset';
+
+    #[Override]
+    protected $description = 'Imports Craft CMS Assets';
+
+    #[Override]
+    protected $aliases = ['import/asset'];
+
+    #[Override]
+    protected function configure(): void
+    {
+        parent::configure();
+
+        $this->addOption('volume', null, InputOption::VALUE_OPTIONAL, 'The volume to import into.');
+    }
+
+    #[Override]
+    public static function importerClass(): string
+    {
+        return AssetImporter::class;
+    }
+
+    #[Override]
+    protected function getAdditionalOptions(): array
+    {
+        return array_merge(parent::getAdditionalOptions(), [
+            'volume' => [
+                'prompt' => fn () => select(
+                    label: 'Which volume do you want to import into?',
+                    options: Volumes::getAllVolumes()->mapWithKeys(fn (Volume $volume) => [$volume->uid => $volume->name])->all(),
+                ),
+            ],
+        ]);
+    }
+}
diff --git a/src/Asset/Elements/Asset.php b/src/Asset/Elements/Asset.php
index bf7b3819124..becdca26197 100644
--- a/src/Asset/Elements/Asset.php
+++ b/src/Asset/Elements/Asset.php
@@ -75,6 +75,7 @@
 use CraftCms\Cms\Search\SearchQueryTermGroup;
 use CraftCms\Cms\Shared\Exceptions\NotSupportedException;
 use CraftCms\Cms\Support\Arr;
+use CraftCms\Cms\Support\Attributes\Importable;
 use CraftCms\Cms\Support\Facades\Assets as AssetsService;
 use CraftCms\Cms\Support\Facades\Deprecator;
 use CraftCms\Cms\Support\Facades\ElementSources;
@@ -195,6 +196,7 @@ class Asset extends Element
      * @var int|null Folder ID
      */
     #[AllowedInSandbox]
+    #[Importable('folderId', 'Folder ID')]
     public ?int $folderId = null;
 
     /**
@@ -219,6 +221,7 @@ class Asset extends Element
      * @var string|null Alternative text
      */
     #[AllowedInSandbox]
+    // importing is handled via native field
     public ?string $alt = null;
 
     /**
@@ -266,6 +269,7 @@ class Asset extends Element
     /**
      * @var string|null The temp file path
      */
+    #[Importable('tempFilePath', 'File Path', canBeMatchCriteria: false, canBeCleared: false)]
     public ?string $tempFilePath = null;
 
     /** The staged upload, before it has been promoted into its volume. */
@@ -317,6 +321,7 @@ class Asset extends Element
     /**
      * @var string Filename
      */
+    #[Importable('filename', 'Filename')]
     private string $_filename;
 
     private ?string $_mimeType = null;
@@ -3376,48 +3381,20 @@ private function _validateTempFilePath(): bool
         $tempFilePath = File::normalizePath($tempFilePath);
 
         // Make sure it's within a known temp path, the project root, or storage/ folder
-        $allowedRoots = [
+        $allowedRoots = self::getAllowedTempFileRoots();
+
+        return Path::isPathWithinRoots($tempFilePath, $allowedRoots);
+    }
+
+    public static function getAllowedTempFileRoots(): array
+    {
+        return [
             [Path::temp(), true],
             [Path::tempAssetUploads(), true],
             [sys_get_temp_dir(), true],
             [Aliases::get('@root', false), false],
             [Aliases::get('@storage', false), false],
         ];
-
-        $inAllowedRoot = false;
-        foreach ($allowedRoots as [$root, $isTempDir]) {
-            $root = $this->_normalizeTempPath($root);
-            if ($root !== false && str_starts_with($tempFilePath, $root)) {
-                // If this is a known temp dir, we’re good here
-                if ($isTempDir) {
-                    return true;
-                }
-                $inAllowedRoot = true;
-                break;
-            }
-        }
-        if (! $inAllowedRoot) {
-            return false;
-        }
-
-        // Make sure it's *not* within a system directory though
-        $systemDirs = Path::system();
-        $systemDirs = array_map($this->_normalizeTempPath(...), $systemDirs);
-        $systemDirs = array_filter($systemDirs, fn ($value) => $value !== false);
-
-        return array_all($systemDirs, fn ($dir) => ! str_starts_with($tempFilePath, (string) $dir));
-    }
-
-    /**
-     * Returns a normalized temp path or false, if realpath fails.
-     */
-    private function _normalizeTempPath(string|false $path): string|false
-    {
-        if (! $path || ! ($path = realpath($path))) {
-            return false;
-        }
-
-        return File::normalizePath($path).DIRECTORY_SEPARATOR;
     }
 
     private function deleteTransformData(): void
diff --git a/src/Asset/Import/AssetImporter.php b/src/Asset/Import/AssetImporter.php
new file mode 100644
index 00000000000..720a2e93a60
--- /dev/null
+++ b/src/Asset/Import/AssetImporter.php
@@ -0,0 +1,307 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Asset\Import;
+
+use Closure;
+use CraftCms\Cms\Asset\AssetsHelper;
+use CraftCms\Cms\Asset\Data\Volume;
+use CraftCms\Cms\Asset\Elements\Asset;
+use CraftCms\Cms\Asset\Exceptions\AssetDisallowedExtensionException;
+use CraftCms\Cms\Asset\Exceptions\AssetException;
+use CraftCms\Cms\Asset\Exceptions\FileException;
+use CraftCms\Cms\Cms;
+use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\Element\Import\ElementImporter;
+use CraftCms\Cms\Element\Queries\AssetQuery;
+use CraftCms\Cms\Element\Queries\Contracts\ElementQueryInterface;
+use CraftCms\Cms\Form\Controls\Choice;
+use CraftCms\Cms\Form\FormContext;
+use CraftCms\Cms\Form\Nodes\Field as FormField;
+use CraftCms\Cms\Support\Facades\Assets as AssetsService;
+use CraftCms\Cms\Support\Facades\Folders;
+use CraftCms\Cms\Support\Facades\ImportLog;
+use CraftCms\Cms\Support\Facades\Path;
+use CraftCms\Cms\Support\Facades\Volumes;
+use CraftCms\Cms\Support\File;
+use CraftCms\Cms\Support\Url;
+use Exception;
+use Illuminate\Validation\Validator;
+use Override;
+
+use function CraftCms\Cms\t;
+
+/**
+ * Imports data into Asset elements.
+ */
+class AssetImporter extends ElementImporter
+{
+    public protected(set) ?string $volume = null;
+
+    #[Override]
+    public static function targetClass(): string
+    {
+        return Asset::class;
+    }
+
+    /**
+     * Convenience factory returning a new instance.
+     */
+    public static function create(): self
+    {
+        return new self;
+    }
+
+    #[Override]
+    public static function displayName(): string
+    {
+        return t('Assets');
+    }
+
+    public static function getDefaultTransformer(): ?string
+    {
+        return AssetTransformer::class;
+    }
+
+    #[Override]
+    public function settingsForm(FormContext $context): array
+    {
+        $parent = parent::settingsForm($context);
+
+        return [
+            'context' => $parent['context'] ?? $context,
+            'nodes' => [
+                ...$parent['nodes'] ?? [],
+                FormField::make(t('Volume'), Choice::make(['volume'])
+                    ->value($this->volume)
+                    ->placeholder(t('Please select'))
+                    ->options($this->availableVolumes())
+                    ->reactive())
+                    ->instructions(t('The volume to import into.')),
+            ],
+        ];
+    }
+
+    #[Override]
+    public function refreshSettingsForm(array $settings): void
+    {
+        parent::refreshSettingsForm($settings);
+
+        if (array_key_exists('volume', $settings)) {
+            $this->volume($settings['volume']);
+            $this->fieldLayout($settings['fieldLayout']);
+        }
+    }
+
+    #[Override]
+    public function storeSettings(array $settings): void
+    {
+        parent::storeSettings($settings);
+
+        $this->volume($settings['volume'] ?? null);
+    }
+
+    #[Override]
+    public function getSettings(): array
+    {
+        $settings = parent::getSettings();
+
+        $settings['volume'] = $this->volume;
+
+        return $settings;
+    }
+
+    /**
+     * Sets the target volume by uid.
+     */
+    public function volume(string|int|Volume|null $value): self
+    {
+        $result = self::normalizeVolume($value);
+        if (! $result) {
+            $this->volume = null;
+            $this->fieldLayout(null);
+        } else {
+            $this->volume = $result->uid;
+            $this->fieldLayout($result->getFieldLayout());
+        }
+
+        return $this;
+    }
+
+    #[Override]
+    public static function getSettingsRules(): array
+    {
+        return array_merge(parent::getSettingsRules(), [
+            'settings.volume' => [
+                'required',
+                'string',
+                'max:255',
+                fn ($attribute, $value, Closure $fail, Validator $validator) => static::validateVolume($value, $attribute, $fail, $validator),
+            ],
+        ]);
+    }
+
+    #[Override]
+    public function toArrayData(): array
+    {
+        $data = parent::toArrayData();
+        $data['settings']['volume'] = $this->volume ?? null;
+
+        return $data;
+    }
+
+    public static function validateVolume(string $value, string $attribute, Closure $fail, Validator $validator): bool
+    {
+        // can't be empty
+        if (empty($value)) {
+            $fail($attribute, t('Volume must be provided.'));
+
+            return false;
+        }
+
+        if (static::normalizeVolume($value) === null) {
+            $fail($attribute, t('No Volume found for “{volume}”.', [
+                'volume' => $value,
+            ]));
+
+            return false;
+        }
+
+        return true;
+    }
+
+    private static function normalizeVolume(string|int|Volume|null $value): ?Volume
+    {
+        return match (true) {
+            $value instanceof Volume => $value,
+            $value === null => null,
+            is_numeric($value) => Volumes::getVolumeById((int) $value),
+            default => Volumes::getVolumeByUid($value) ?? Volumes::getVolumeByHandle($value),
+        };
+    }
+
+    #[Override]
+    public function prepareNewRootElementForImport(array &$data, ?ElementInterface $element = null): ElementInterface
+    {
+        $element = parent::prepareNewRootElementForImport($data, $element);
+
+        // if it's UI-driven element import where the fieldLayout was chosen in the editable config,
+        // we need to ensure the volumeId is set
+        if ($this->fieldLayout) {
+            $allVolumes = Volumes::getAllVolumes();
+            $allFieldLayouts = $allVolumes->mapWithKeys(function ($volume) {
+                $fieldLayout = $volume->getFieldLayout();
+
+                return [$fieldLayout->id => $fieldLayout];
+            });
+            $volume = $allFieldLayouts->firstWhere('uid', $this->fieldLayout)?->provider;
+            if ($volume) {
+                $element->setVolumeId($volume->id);
+                if (isset($data['matchCriteria']['volumeId'])) {
+                    unset($data['matchCriteria']['volumeId']);
+                }
+            }
+        }
+
+        return $element;
+    }
+
+    #[Override]
+    public function prepareRootElementImportQuery(ElementInterface $element, ElementQueryInterface $query): ElementQueryInterface
+    {
+        /** @var $element Asset */
+        /** @var $query AssetQuery */
+        return $query->volumeId($element->getVolumeId());
+    }
+
+    #[Override]
+    public function setAttributesForImport(ElementInterface $element, array $attributes): void
+    {
+        // ensure we're not changing volume ID compared to what we chose in the field layout provider step
+        unset($attributes['volumeId']);
+
+        // if this is a new asset and we don't have tempFilePath - throw an error and don't bother going further
+        if ($element->id === null && ! isset($attributes['tempFilePath'])) {
+            // throw new Exception('Cannot import an asset without a tempFilePath');
+            throw new AssetException(t('Cannot create a new asset without a file. Please check your mapping and incoming data.'));
+        }
+
+        // if folderId was not provided, ensure we have one:
+        if (empty($attributes['folderId'])) {
+            $folder = Folders::getRootFolderByVolumeId($element->getVolumeId());
+            $attributes['folderId'] = $folder->id;
+        }
+
+        // deduce filename - was one provided or should we get it from the provided file path
+        if (empty($attributes['filename']) && ! empty($attributes['tempFilePath'])) {
+            $attributes['filename'] = AssetsHelper::prepareAssetName(pathinfo(Url::stripQueryString($attributes['tempFilePath']), PATHINFO_BASENAME));
+        } elseif (isset($attributes['filename'])) {
+            $attributes['filename'] = AssetsHelper::prepareAssetName($attributes['filename']);
+        }
+
+        // avoid filename conflicts
+        if (isset($attributes['filename'])) {
+            $suggestedFilename = AssetsService::getNameReplacementInFolder($attributes['filename'], $attributes['folderId']);
+            if ($suggestedFilename !== $attributes['filename'] && (! $element->id || $attributes['filename'] !== $element->getFilename())) {
+                $attributes['filename'] = $suggestedFilename;
+            }
+
+            // deduce extension and check if it's allowed
+            $allowedExtensions = Cms::config()->allowedFileExtensions;
+            $extension = strtolower(pathinfo($attributes['filename'], PATHINFO_EXTENSION));
+            if (! in_array($extension, $allowedExtensions, true)) {
+                throw new AssetDisallowedExtensionException(t('“{extension}” is not an allowed file extension.', [
+                    'extension' => $extension,
+                ]));
+            }
+        }
+
+        // process the file path (tempFilePath); if it's in a temp location - use it;
+        // if it's an absolute URL - download to a temp location and use it
+        if (! empty($attributes['tempFilePath'])) {
+            // if it's not an absolute URL
+            if (! Url::isAbsoluteUrl($attributes['tempFilePath'])) {
+                // check if the file is already located in the temp location - if so, we should be able to just use it
+                $value = realpath($attributes['tempFilePath']);
+
+                if ($value === false || ! is_file($value)) {
+                    // if we don't have the file path, we shouldn't proceed
+                    throw new FileException(t('Cannot establish absolute pathname for “{filePath}” (e.g. file doesn’t exist) or it’s not a file.', [
+                        'filePath' => $attributes['tempFilePath'],
+                    ]));
+                }
+                $value = File::normalizePath($value);
+                // Make sure it's within a known temp path, the project root, or storage/ folder
+                $allowedRoots = Asset::getAllowedTempFileRoots();
+                if (! Path::isPathWithinRoots($value, $allowedRoots)) {
+                    throw new FileException(t('File “{filePath}” is in a disallowed location. Only temp path, project root and storage folders are allowed.', [
+                        'filePath' => $attributes['tempFilePath'],
+                    ]));
+                }
+                $attributes['tempFilePath'] = $value;
+            } else {
+                // if it's an absolute URL, we need to download the file to a temp location
+                $tempPath = AssetsHelper::tempFilePath($extension);
+                try {
+                    AssetsHelper::downloadUrl($attributes['tempFilePath'], $tempPath);
+                    $attributes['tempFilePath'] = $tempPath;
+                } catch (Exception $e) {
+                    // log error
+                    ImportLog::warning("Couldn't download a file while importing an asset: ".$e->getMessage());
+                }
+                // todo (iwona): what about base64 - feed me supports it, but do we want it for the native import?
+            }
+        }
+
+        parent::setAttributesForImport($element, $attributes);
+    }
+
+    protected function availableVolumes(): array
+    {
+        return Volumes::getAllVolumes()->map(fn ($volume) => [
+            'label' => $volume->name,
+            'value' => $volume->uid,
+        ])->all();
+    }
+}
diff --git a/src/Asset/Import/AssetTransformer.php b/src/Asset/Import/AssetTransformer.php
new file mode 100644
index 00000000000..d21571ce4a0
--- /dev/null
+++ b/src/Asset/Import/AssetTransformer.php
@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Asset\Import;
+
+use CraftCms\Cms\Asset\Elements\Asset;
+use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\Element\Import\ElementTransformer;
+use CraftCms\Cms\Support\Facades\Folders;
+
+class AssetTransformer extends ElementTransformer
+{
+    /**
+     * Normalize folder ID to an existing folder ID or null.
+     */
+    protected function normalizeFolderId(mixed $value, ElementInterface $element): ?int
+    {
+        // if folder ID wasn't provided in the incoming data (which should be very common)
+        // we need to get the root folder for given volume
+        if ($value === null) {
+            return null;
+        }
+
+        $folder = null;
+        /** @var Asset $element */
+        $volume = $element->getVolume();
+
+        if (is_int($value) || is_numeric($value)) {
+            $folder = Folders::getFolderById((int) $value);
+        }
+
+        if (is_string($value)) {
+            $folder = Folders::findFolder(['name' => $value]);
+        }
+
+        // check that it belongs to the volume that was selected
+        if ($folder && $folder->volumeId === $volume->id) {
+            return $folder->id;
+        }
+
+        $folder = Folders::getRootFolderByVolumeId($volume->id);
+
+        return $folder?->id;
+    }
+}
diff --git a/src/Cp/Navigation.php b/src/Cp/Navigation.php
index 20ecaf9359d..e2df93ac294 100644
--- a/src/Cp/Navigation.php
+++ b/src/Cp/Navigation.php
@@ -238,6 +238,13 @@ private function buildTree(): array
                 ->subnav($this->sourceSubnav(User::class, 'users')));
         }
 
+        if (Gate::check('viewImports')) {
+            $navItems->add(new NavItem()
+                ->label(t('Import'))
+                ->url('import')
+                ->icon('arrow-up-to-bracket'));
+        }
+
         // Add any Plugin nav items
         foreach ($this->plugins->getAllPlugins() as $plugin) {
             if (! $plugin->hasCpSection) {
diff --git a/src/Database/Migrations/0000_00_00_000009_create_import_tables.php b/src/Database/Migrations/0000_00_00_000009_create_import_tables.php
new file mode 100644
index 00000000000..f36545c75d6
--- /dev/null
+++ b/src/Database/Migrations/0000_00_00_000009_create_import_tables.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Database\Migration;
+use CraftCms\Cms\Database\Table;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        if (! Schema::hasTable(Table::IMPORTS)) {
+            Schema::create(Table::IMPORTS, function (Blueprint $table) {
+                $table->integer('id', true);
+                $table->string('name');
+                $table->string('handle');
+                $table->text('description')->nullable();
+                $table->mediumText('steps');
+                $table->dateTime('dateCreated');
+                $table->dateTime('dateUpdated');
+                $table->dateTime('dateDeleted')->nullable()->default(null);
+                $table->char('uid', 36)->default('0');
+            });
+        }
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists(Table::IMPORTS);
+    }
+};
diff --git a/src/Database/Migrations/Install.php b/src/Database/Migrations/Install.php
index 6c48273195e..a2d333436e6 100644
--- a/src/Database/Migrations/Install.php
+++ b/src/Database/Migrations/Install.php
@@ -665,6 +665,18 @@ public function createTables(?Logger $logger = null): void
             $table->char('uid', 36)->default('0');
         });
 
+        Schema::create(Table::IMPORTS, function (Blueprint $table) {
+            $table->integer('id', true);
+            $table->string('name');
+            $table->string('handle');
+            $table->text('description')->nullable();
+            $table->mediumText('steps');
+            $table->dateTime('dateCreated');
+            $table->dateTime('dateUpdated');
+            $table->dateTime('dateDeleted')->nullable()->default(null);
+            $table->char('uid', 36)->default('0');
+        });
+
         /** @todo Change when Larastan is updated */
         $logger?->subLabel('info');
         Schema::create(Table::INFO, function (Blueprint $table) {
diff --git a/src/Database/Table.php b/src/Database/Table.php
index c777a35e6cf..c58d298d233 100644
--- a/src/Database/Table.php
+++ b/src/Database/Table.php
@@ -67,6 +67,8 @@
 
     public const string IMAGETRANSFORMS = 'imagetransforms';
 
+    public const string IMPORTS = 'imports';
+
     public const string INFO = 'info';
 
     public const string MIGRATIONS = 'migrations';
diff --git a/src/Element/Concerns/HasStatuses.php b/src/Element/Concerns/HasStatuses.php
index beaae00593f..16d862b6117 100644
--- a/src/Element/Concerns/HasStatuses.php
+++ b/src/Element/Concerns/HasStatuses.php
@@ -4,6 +4,7 @@
 
 namespace CraftCms\Cms\Element\Concerns;
 
+use CraftCms\Cms\Support\Attributes\Importable;
 use CraftCms\Cms\Twig\Attributes\AllowedInSandbox;
 
 use function CraftCms\Cms\t;
@@ -33,6 +34,7 @@ trait HasStatuses
      * @var bool Whether the element is enabled
      */
     #[AllowedInSandbox]
+    #[Importable('enabled', 'Enabled', canBeMatchCriteria: false, canBeCleared: false)]
     public bool $enabled = true;
 
     /**
diff --git a/src/Element/Concerns/Structurable.php b/src/Element/Concerns/Structurable.php
index 26c53745222..72b2e07bb3e 100644
--- a/src/Element/Concerns/Structurable.php
+++ b/src/Element/Concerns/Structurable.php
@@ -12,6 +12,7 @@
 use CraftCms\Cms\Element\Events\ElementMovingInStructure;
 use CraftCms\Cms\Element\Queries\Contracts\ElementQueryInterface;
 use CraftCms\Cms\Element\Queries\ElementQuery;
+use CraftCms\Cms\Support\Attributes\Importable;
 use CraftCms\Cms\Support\Facades\ElementCaches;
 use CraftCms\Cms\Support\Typecast;
 
@@ -52,6 +53,7 @@ trait Structurable
 
     private ElementInterface|false|null $_prevElement = null;
 
+    #[Importable('parentId', 'Parent ID')]
     private int|false|null $_parentId = null;
 
     private ElementInterface|false|null $_parent = null;
diff --git a/src/Element/Element.php b/src/Element/Element.php
index 02891610180..fc8f978d203 100644
--- a/src/Element/Element.php
+++ b/src/Element/Element.php
@@ -16,6 +16,7 @@
 use CraftCms\Cms\Element\Validation\ElementRules;
 use CraftCms\Cms\Field\Fields;
 use CraftCms\Cms\FieldLayout\LayoutElements\BaseField;
+use CraftCms\Cms\Support\Attributes\Importable as ImportableAttribute;
 use CraftCms\Cms\Support\Facades\Sites;
 use CraftCms\Cms\Support\Str;
 use CraftCms\Cms\Support\Utils;
@@ -84,6 +85,7 @@ abstract class Element extends Component implements AllowableInSandbox, ElementI
      * @var int|null The element's ID
      */
     #[AllowedInSandbox]
+    #[ImportableAttribute('id', 'ID', canBeCleared: false, canBeSet: false)]
     public ?int $id = null;
 
     /**
@@ -95,6 +97,7 @@ abstract class Element extends Component implements AllowableInSandbox, ElementI
      * @var string|null The element’s UID
      */
     #[AllowedInSandbox]
+    #[ImportableAttribute('uid', 'UID', canBeCleared: false, canBeSet: false)]
     public ?string $uid = null;
 
     /**
@@ -108,12 +111,14 @@ abstract class Element extends Component implements AllowableInSandbox, ElementI
      * @var string|null The element’s title
      */
     #[AllowedInSandbox]
+    // importing is handled via native field
     public ?string $title = null;
 
     /**
      * @var string|null The element’s slug
      */
     #[AllowedInSandbox]
+    #[ImportableAttribute('slug', 'Slug')]
     public ?string $slug = null;
 
     /**
@@ -183,6 +188,11 @@ abstract class Element extends Component implements AllowableInSandbox, ElementI
      */
     public bool $hardDelete = false;
 
+    /**
+     * @var bool Whether the element is currently being imported.
+     */
+    public private(set) bool $importing = false;
+
     #[Override]
     public static function displayName(): string
     {
@@ -746,6 +756,14 @@ public function setAttributesFromRequest(array $values): void
         $this->setAttributes($values);
     }
 
+    /**
+     * Marks the element as currently being imported.
+     */
+    public function markAsImporting(): void
+    {
+        $this->importing = true;
+    }
+
     /** @return string[] */
     public function safeAttributes(): array
     {
diff --git a/src/Element/Import/ElementImporter.php b/src/Element/Import/ElementImporter.php
new file mode 100644
index 00000000000..725ca381123
--- /dev/null
+++ b/src/Element/Import/ElementImporter.php
@@ -0,0 +1,810 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Element\Import;
+
+use Closure;
+use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\Element\Events\ElementDeleted;
+use CraftCms\Cms\Element\Queries\Contracts\ElementQueryInterface;
+use CraftCms\Cms\Element\Validation\ElementRules;
+use CraftCms\Cms\Field\Contracts\FieldInterface;
+use CraftCms\Cms\Field\Contracts\ImportableElementContainerFieldInterface;
+use CraftCms\Cms\FieldLayout\FieldLayout;
+use CraftCms\Cms\Form\Controls\Choice;
+use CraftCms\Cms\Form\FormContext;
+use CraftCms\Cms\Form\Nodes\Field as FormField;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use CraftCms\Cms\Site\Data\Site;
+use CraftCms\Cms\Support\Arr;
+use CraftCms\Cms\Support\Facades\Elements;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Import;
+use CraftCms\Cms\Support\Facades\ImportLog;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Support\Html;
+use CraftCms\Cms\Support\ImportHelper;
+use CraftCms\Cms\Support\Typecast;
+use Illuminate\Support\Facades\Event;
+use Illuminate\Validation\Validator;
+use InvalidArgumentException;
+use Override;
+use Throwable;
+
+use function CraftCms\Cms\t;
+
+abstract class ElementImporter extends BaseImporter
+{
+    public protected(set) ?Site $site = null;
+
+    public protected(set) ?string $fieldLayout = null;
+
+    /**
+     * @var array|null
+     *
+     * array => a tree keyed by field handle, mirroring $matchCriteria's shape (including a
+     *  `fields` segment and provider/entry-type handle for each level of nesting). Since a
+     *  container field (Matrix, Addresses) is the only kind of node in this tree that both
+     *  has its own decision *and* may contain further nested container fields, each
+     *  container field's own decision lives under a reserved `__keep__` leaf sitting
+     *  alongside its children, e.g. `['outerMatrix' => ['__keep__' => true, 'someEntryType' =>
+     *  ['fields' => ['innerMatrix' => ['__keep__' => false]]]]]`; a `true` leaf keeps that
+     *  field's nested items missing from the incoming data instead of pruning them; a field
+     *  with no `__keep__` entry is pruned (the default), matching how Craft already saves
+     *  that field type outside of import;
+     *
+     *  null => nothing is kept; missing nested items are pruned for every field that supports it
+     */
+    public protected(set) ?array $keepMissingNestedElements = null;
+
+    /**
+     * Whether an `Elements::saveElement()` call is currently in progress, so the `ElementDeleted`
+     * listener registered in the constructor knows to collect deletions caused by it.
+     */
+    private bool $trackingNestedElementDeletions = false;
+
+    /**
+     * Element IDs deleted (via nested-item pruning) during the current `Elements::saveElement()` call.
+     */
+    private array $deletedNestedElementIds = [];
+
+    /**
+     * Calls the parent constructor then sets default match criteria to `['id' => 'id']`.
+     *
+     * @param  array|null  $config  Optional config array, potentially containing a `uid` key.
+     */
+    public function __construct(?array $config = null)
+    {
+        parent::__construct($config);
+        // $this->matchCriteria = ['id' => 'id'];
+
+        Event::listen(function (ElementDeleted $event) {
+            if ($this->trackingNestedElementDeletions) {
+                $this->deletedNestedElementIds[] = $event->element->id;
+            }
+        });
+    }
+
+    #[Override]
+    public static function getDefaultTransformer(): ?string
+    {
+        return ElementTransformer::class;
+    }
+
+    #[Override]
+    public function settingsForm(FormContext $context): array
+    {
+        $availableSites = Sites::getEditableSites()
+            ->map(fn ($item) => ['label' => $item->name, 'value' => $item->handle])
+            ->all();
+
+        return [
+            'context' => $context,
+            'nodes' => [
+                FormField::make(t('Site'), Choice::make('site')
+                    ->value($this->site?->handle ?? Sites::getPrimarySite()->handle)
+                    ->options($availableSites))
+                    ->instructions(t('The site you want to import the data into'))
+                    ->required(),
+            ],
+        ];
+    }
+
+    #[Override]
+    public function refreshSettingsForm(array $settings): void
+    {
+        if (array_key_exists('site', $settings)) {
+            $this->site($settings['site']);
+        }
+        if (array_key_exists('fieldLayout', $settings)) {
+            $this->fieldLayout($settings['fieldLayout']);
+        }
+    }
+
+    #[Override]
+    public function storeSettings(array $settings): void
+    {
+        $this->site($settings['site']);
+        // $this->fieldLayout($settings['fieldLayout']);
+    }
+
+    #[Override]
+    public function getSettings(): array
+    {
+        $settings['keepMissingNestedElements'] = $this->keepMissingNestedElements;
+        $settings['site'] = $this->site->uid;
+        $settings['fieldLayout'] = $this->fieldLayout;
+
+        return $settings;
+    }
+
+    /**
+     * Resolves and sets the target site from a Site instance, id, handle, or uid.
+     * Defaults to the primary site if null.
+     *
+     * @param  string|int|Site|null  $site  The site instance, ID, handle, uid, or null.
+     */
+    public function site(string|int|Site|null $site): self
+    {
+        $resolved = static::normalizeSite($site);
+
+        if ($resolved === null) {
+            throw new InvalidArgumentException(is_numeric($site)
+                ? "No site found with ID: $site"
+                : "No site found with handle or UID: \"$site\".");
+        }
+
+        $this->site = $resolved;
+
+        return $this;
+    }
+
+    /**
+     * Resolves and sets the fieldLayout property from a FieldLayout instance, id, or uid/type string into UID/type string.
+     *
+     * @param  string|int|FieldLayout|null  $value  The field layout instance, ID, uid, type, or null.
+     */
+    public function fieldLayout(string|int|FieldLayout|null $value): self
+    {
+        if ($value === null) {
+            $this->fieldLayout = null;
+
+            return $this;
+        }
+
+        $fieldLayout = static::normalizeFieldLayout($value, create: true);
+
+        if ($fieldLayout === null) {
+            throw new InvalidArgumentException(is_numeric($value)
+                ? "No field layout found with ID: $value"
+                : "No field layout found with UID or Type of: \"$value\".");
+        }
+
+        // if the field layout is saved in the database, then it has an ID and therefore persistent UID;
+        // otherwise, it's the default layout and we need to use the type
+        $this->fieldLayout = $fieldLayout->id ? $fieldLayout->uid : $fieldLayout->type;
+
+        return $this;
+    }
+
+    /**
+     * Gives an importer whose field layout isn't chosen by the user a chance to resolve one.
+     *
+     * Called once the importer has been built from a step's settings. Most element types
+     * resolve their layout from a setting (an entry type, a volume), so the default does
+     * nothing; override it where the layout is fixed for the element type instead.
+     */
+    public function resolveDefaultFieldLayout(): void {}
+
+    /**
+     * Sets the container field handles that should keep nested elements missing from the
+     * incoming data instead of pruning them, and returns the current instance.
+     *
+     * @param  array|null  $keepMissingNestedElements  The field handles to keep, either as the nested
+     *                                                 `__keep__`-leaf tree (matching $matchCriteria's
+     *                                                 shape) or a flat list of dot-notation handles to keep.
+     */
+    public function keepMissingNestedElements(?array $keepMissingNestedElements = null): self
+    {
+        if ($keepMissingNestedElements !== null) {
+            $keepMissingNestedElements = ImportHelper::decodeRecursive($keepMissingNestedElements);
+
+            if (array_is_list($keepMissingNestedElements)) {
+                $keepMissingNestedElements = Arr::undot(array_fill_keys(
+                    array_map(fn ($handle) => $handle.'.__keep__', $keepMissingNestedElements),
+                    true
+                ));
+            }
+
+            $this->keepMissingNestedElements = $keepMissingNestedElements;
+        }
+
+        return $this;
+    }
+
+    #[Override]
+    public static function getSettingsRules(): array
+    {
+        return array_merge(parent::getSettingsRules(), [
+            'settings.fieldLayout' => fn ($attribute, $value, Closure $fail, Validator $validator) => static::validateFieldLayout($value, $attribute, $fail, $validator),
+            'settings.site' => [
+                'required',
+                'string',
+                'max:255',
+                fn ($attribute, $value, Closure $fail, Validator $validator) => static::validateSite($value, $attribute, $fail, $validator),
+            ],
+            'settings.keepMissingNestedElements' => ['array'],
+        ]);
+    }
+
+    #[Override]
+    public function toArrayData(): array
+    {
+        $data = parent::toArrayData();
+        $data['settings']['site'] = $this->site?->handle;
+        $data['settings']['fieldLayout'] = $this->fieldLayout ?? null;
+
+        return $data;
+    }
+
+    /**
+     * Validates that the given handle matches a known site.
+     *
+     * @param  mixed  $value  The value of the site handle being validated.
+     * @param  string  $attribute  The name of the attribute being validated.
+     * @param  Closure  $fail  The callback function to invoke when validation fails.
+     * @param  Validator  $validator  The validator instance performing the validation.
+     */
+    public static function validateSite(mixed $value, string $attribute, Closure $fail, Validator $validator): bool
+    {
+        if (empty($value)) {
+            $fail($attribute, t('Site must be provided.'));
+
+            return false;
+        }
+
+        if (static::normalizeSite($value) === null) {
+            $fail($attribute, t('“{site}” is not a valid site handle.', [
+                'site' => $value,
+            ]));
+
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Validates that the given field layout is a valid FieldLayout instance, numeric ID, UID, or element-type string.
+     */
+    public static function validateFieldLayout(mixed $value, string $attribute, Closure $fail, Validator $validator): bool
+    {
+        // if we don't have a UID, then the config is coming from the CLI or file-based and won't have a fieldLayout
+        if (! isset($validator->getData()['uid'])) {
+            return true;
+        }
+
+        // can't be empty
+        if (empty($value)) {
+            $fail($attribute, t('Field layout must be provided.'));
+
+            return false;
+        }
+
+        // has to exist (never create a layout as a side effect of validation)
+        $fieldLayout = static::normalizeFieldLayout($value, true);
+        if ($fieldLayout === null) {
+            $fail($attribute, t('No field layout found for “{fieldLayout}”.', [
+                'fieldLayout' => $value,
+            ]));
+
+            return false;
+        }
+
+        //        // has to belong to the element type if we know it
+        //        $className = Arr::get($validator->getData(), 'settings.className');
+        //        if (is_string($className) && $className !== '' && $fieldLayout->type !== $className) {
+        //            $fail($attribute, t('Field layout does not belong to element type “{elementType}”.', [
+        //                'elementType' => $className,
+        //            ]));
+        //
+        //            return false;
+        //        }
+
+        return true;
+    }
+
+    #[Override]
+    public static function validateMap(mixed $value, string $attribute, Closure $fail, Validator $validator, array $params = []): bool
+    {
+        // in case of an element importer, the $params might contain the field this map partial is for
+        // if $params is empty, then we're validating the whole map
+        if (! empty($params['field'])) {
+            $field = $params['field'];
+
+            if ($field instanceof ImportableElementContainerFieldInterface) {
+                $field->validateMapping($value, $attribute, $fail, $validator, $params);
+            }
+        }
+
+        return true;
+    }
+
+    #[Override]
+    public function getDestinationCols(): array
+    {
+        $propertyCols = [];
+
+        // attribute mapping - get all properties marked as importable
+        $props = ImportHelper::getImportableProperties($this);
+
+        // exclude all those that are not supposed to be available for UI mapping
+        $props = array_filter($props, fn ($prop) => ! isset($prop['excludeFromUiMapping']) || $prop['excludeFromUiMapping'] === false);
+
+        if (! empty($props)) {
+            $propertyCols = array_map(fn ($prop) => [
+                'handle' => $prop['name'],
+                'label' => $prop['label'],
+                'prefixedHandleForMap' => Html::namespaceInputName($prop['name'], 'map'),
+                'prefixedHandleForMatchCriteria' => Html::namespaceInputName($prop['name'], 'matchCriteria'),
+                'prefixedHandleForClear' => Html::namespaceInputName($prop['name'], 'clearableItems'),
+                'prefixedHandle' => $prop['name'],
+                'prefixedHandleAsArray' => Arr::bracketsToArray($prop['name']),
+                'isContainer' => $prop['isContainer'] ?? false,
+                'canBeMatchCriteria' => $prop['canBeMatchCriteria'] ?? true,
+                'canBeCleared' => $prop['canBeCleared'] ?? true,
+                'canBeSet' => $prop['canBeSet'] ?? true,
+                'isProperty' => true,
+            ], $props);
+        }
+
+        if ($this->fieldLayout === null) {
+            return $propertyCols;
+        }
+
+        $fieldLayout = self::normalizeFieldLayout($this->fieldLayout, create: true);
+
+        $fieldLayoutCols = ImportHelper::getDestinationColsForFieldLayout($fieldLayout);
+
+        return array_merge($propertyCols, $fieldLayoutCols);
+    }
+
+    #[Override]
+    public function getSourceDataCols(): array
+    {
+        $filePath = BaseImporter::resolvedFilePath($this->file);
+
+        // a config can be saved before its file is chosen, and the map screen still renders
+        if ($filePath === null) {
+            return [];
+        }
+
+        return Import::getDataHeadings($filePath);
+    }
+
+    #[Override]
+    public function importItem(array $data): void
+    {
+        // figure out if we're adding or updating
+        $element = $this->getRootElement($data);
+        $element->markAsImporting();
+
+        $item = Import::processData($this, $data, $element);
+
+        $isNew = $element->id === null;
+
+        // normalization and validation of attributes happens in the transformer and in the setAttributesForImport() method
+        $attributeHandles = $element->attributes();
+        // $fieldHandles has custom and native fields - basically all field layout elements
+        $fieldHandles = array_diff(array_keys($item), $attributeHandles);
+
+        // get a list of container properties
+        $containerProps = ImportHelper::getImportableContainerProperties($this);
+        // and deduce attributes from those
+        $containerAttributes = collect($containerProps)->map(fn ($prop) => $prop['name'])->all();
+
+        // exclude container attributes from field handles
+        $fieldHandles = empty($containerAttributes) ? $fieldHandles : array_diff($fieldHandles, $containerAttributes);
+
+        $attributes = array_filter($item, fn ($key) => in_array($key, $attributeHandles), ARRAY_FILTER_USE_KEY);
+        $fields = array_filter($item, fn ($key) => in_array($key, $fieldHandles), ARRAY_FILTER_USE_KEY);
+
+        // If any container property has data present in $item, treat the element as changed
+        // (there's no cheap/reliable way to diff this,
+        // plus the container handling may depend on the parent being re-saved, like it does for User addresses)
+        $hasContainerData = collect($containerProps)->contains(fn ($prop) => isset($item[$prop['name']]));
+
+        // no need to snapshot old values when the element will be saved unconditionally anyway
+        $skipChangeDetection = $isNew || $hasContainerData;
+        $oldAttributeValues = $skipChangeDetection ? [] : $this->snapshotAttributeValues($element, array_keys($attributes));
+        $oldFieldValues = $skipChangeDetection ? [] : $this->snapshotFieldValues($element, array_keys($fields));
+
+        if (! empty($attributes)) {
+            $this->setAttributesForImport($element, $attributes);
+        }
+
+        if (! empty($fields)) {
+            $fields = $this->normalizeFields($element, $fields);
+            $element->setFieldValues($fields);
+        }
+
+        // attributes that are containers need special processing
+        foreach ($containerProps as $prop) {
+            if (isset($item[$prop['name']]) && method_exists($element, 'importIntoContainerAttribute')) {
+                $element->importIntoContainerAttribute($prop, $item, $this);
+            }
+        }
+
+        // A container field whose nested element doesn't exist yet can serialize identically before
+        // and after the incoming value is set (ContentBlock::serializeValue() returns null while the
+        // block has no id), so the diff below can't see the new content. Treat incoming data for a
+        // container field that's currently empty as a change.
+        $hasNewContainerFieldData = ! $skipChangeDetection
+            && $this->hasNewContainerFieldData($element, $fields, $oldFieldValues);
+
+        $hasChanges = $skipChangeDetection
+            || $hasNewContainerFieldData
+            || $this->attributeValuesChanged($element, $oldAttributeValues)
+            || $this->fieldValuesChanged($element, $oldFieldValues);
+
+        if (! $hasChanges) {
+            return;
+        }
+
+        if ($element->enabled && $element->getEnabledForSite()) {
+            $element->ruleset->useScenario(ElementRules::SCENARIO_LIVE);
+        } else {
+            $element->ruleset->useScenario(ElementRules::SCENARIO_ESSENTIALS);
+        }
+
+        $restoreKeepFlagFields = $this->enableKeepMissingNestedElements($element);
+
+        $this->trackingNestedElementDeletions = true;
+        $this->deletedNestedElementIds = [];
+
+        try {
+            if (! Elements::saveElement($element)) {
+                ImportLog::warning(
+                    'Unable to save element being imported (elementId: '.($element->id ?? 'new').'): '.
+                    print_r($element->errors()->all(), true),
+                    ['data' => $item]
+                );
+            }
+        } finally {
+            $this->trackingNestedElementDeletions = false;
+
+            foreach ($restoreKeepFlagFields as $field) {
+                $field->setKeepMissingNestedElements(false);
+            }
+        }
+
+        if (! empty($this->deletedNestedElementIds)) {
+            ImportLog::info(
+                'Pruned nested elements missing from imported data (elementId: '.($element->id ?? 'new').')',
+                ['elementId' => $element->id, 'prunedElementIds' => $this->deletedNestedElementIds]
+            );
+        }
+    }
+
+    /**
+     * Resolves a Site instance, numeric ID, handle, or UID to a Site, or null if not found.
+     * A null value resolves to the primary site.
+     */
+    private static function normalizeSite(string|int|Site|null $value): ?Site
+    {
+        return match (true) {
+            $value instanceof Site => $value,
+            $value === null => Sites::getPrimarySite(),
+            is_numeric($value) => Sites::getSiteById((int) $value),
+            default => static::siteByUidOrNull($value) ?? Sites::getSiteByHandle($value),
+        };
+    }
+
+    /**
+     * Resolves a FieldLayout instance, numeric ID, UID, or element-type string to a FieldLayout, or null if not found.
+     * A null value resolves to null.
+     */
+    private static function normalizeFieldLayout(string|int|FieldLayout|null $value, bool $create = false): ?FieldLayout
+    {
+        return match (true) {
+            $value instanceof FieldLayout => $value,
+            $value === null => null,
+            is_numeric($value) => Fields::getLayoutById((int) $value),
+            default => Fields::getLayoutByUid($value) ?? Fields::getLayoutByType($value, create: $create),
+        };
+    }
+
+    /**
+     * Prepares a new element instance for import.
+     */
+    public function prepareNewRootElementForImport(array &$data, ?ElementInterface $element = null): ElementInterface
+    {
+        $element ??= new ($this::targetClass());
+
+        // ensure site is set
+        $element->siteId = $this->site->id;
+
+        return $element;
+    }
+
+    /**
+     * Prepare the element query that searches for the root element we're importing into
+     */
+    public function prepareRootElementImportQuery(ElementInterface $element, ElementQueryInterface $query): ElementQueryInterface
+    {
+        // by default, we don't need to adjust the element query
+        return $query;
+    }
+
+    /**
+     * Sets element's importable attributes.
+     */
+    public function setAttributesForImport(ElementInterface $element, array $attributes): void
+    {
+        // the ID and UID can only be used to match on, we cannot have them be set via the import
+        unset($attributes['id'], $attributes['uid']);
+
+        // by default, simply set the attributes
+        $element->setAttributesFromRequest($attributes);
+    }
+
+    #[Override]
+    public static function isElementImporter(): bool
+    {
+        return true;
+    }
+
+    /**
+     * `Sites::getSiteByUid()` throws an error when the UID isn't found,
+     * so we need this method to catch it and return null in that case.
+     */
+    private static function siteByUidOrNull(string $uid): ?Site
+    {
+        try {
+            return Sites::getSiteByUid($uid);
+        } catch (Throwable) {
+            return null;
+        }
+    }
+
+    /**
+     * Enables keeping missing nested elements for any container field opted in via
+     * `keepMissingNestedElements`, returning the fields that should be restored after the save.
+     *
+     * @return ImportableElementContainerFieldInterface[]
+     */
+    private function enableKeepMissingNestedElements(ElementInterface $element): array
+    {
+        return $this->collectAndEnableKeepFields($element->getFieldLayout(), null, null, null);
+    }
+
+    /**
+     * Recursively walks a field layout's container fields (and, for each one, the field layouts of
+     * every provider it offers, e.g. a Matrix field's entry types) looking for fields opted in to
+     * keeping missing nested elements via `keepMissingNestedElements`, enabling each one it finds.
+     *
+     * Fields are resolved strictly through the given `FieldLayout` object (never via a direct
+     * lookup like `Fields::getFieldById()`), so the instance mutated here is the exact same one
+     * the real, recursive `Elements::saveElement()` cascade will encounter later.
+     *
+     * @param  FieldInterface|null  $ownerField  The container field $fieldLayout belongs to, if any.
+     * @param  mixed  $provider  The field layout provider $fieldLayout came from, if any.
+     * @param  string|null  $prefix  $ownerField's own prefixed handle, as the mapping screen names it.
+     * @return ImportableElementContainerFieldInterface[]
+     */
+    private function collectAndEnableKeepFields(
+        ?FieldLayout $fieldLayout,
+        ?FieldInterface $ownerField,
+        mixed $provider,
+        ?string $prefix,
+    ): array {
+        if (! $fieldLayout) {
+            return [];
+        }
+
+        $restoreKeepFlagFields = [];
+
+        foreach ($fieldLayout->getCustomFields() as $field) {
+            if (! $field instanceof ImportableElementContainerFieldInterface) {
+                continue;
+            }
+
+            // The keep tree is keyed by the names the mapping screen generates, so ask the same
+            // helper the UI does rather than assuming a [handle][providerHandle][fields] shape -
+            // a content block is its own layout provider, which that assumption would spell twice.
+            [, , , $prefixedHandle, $prefixedHandleAsArray] = ImportHelper::getPrefixedHandlesForMapping(
+                $field->handle,
+                $ownerField,
+                $field,
+                $fieldLayout,
+                $provider,
+                $prefix,
+            );
+
+            if ($field->canKeepMissingNestedElements()) {
+                // loose cast: a real checkbox submission survives as int 1/0 (or even the
+                // string "1"/"0") after json_decode(), not strictly bool true/false
+                $shouldKeep = (bool) Arr::get($this->keepMissingNestedElements, implode('.', [...$prefixedHandleAsArray, '__keep__']));
+
+                if ($shouldKeep) {
+                    $field->setKeepMissingNestedElements(true);
+                    $restoreKeepFlagFields[] = $field;
+                }
+            }
+
+            foreach ($field->getFieldLayoutProviders() as $nestedProvider) {
+                $restoreKeepFlagFields = [
+                    ...$restoreKeepFlagFields,
+                    ...$this->collectAndEnableKeepFields($nestedProvider->getFieldLayout(), $field, $nestedProvider, $prefixedHandle),
+                ];
+            }
+        }
+
+        return $restoreKeepFlagFields;
+    }
+
+    /**
+     * Snapshots the element's current values for the given attribute handles.
+     */
+    private function snapshotAttributeValues(ElementInterface $element, array $handles): array
+    {
+        $values = [];
+
+        foreach ($handles as $handle) {
+            $values[$handle] = $element->$handle;
+        }
+
+        return $values;
+    }
+
+    /**
+     * Snapshots the element's current serialized values for the given field handles.
+     */
+    private function snapshotFieldValues(ElementInterface $element, array $handles): array
+    {
+        $fieldLayout = $element->getFieldLayout();
+        $values = [];
+
+        foreach ($handles as $handle) {
+            $field = $fieldLayout?->getFieldByHandle($handle);
+            $values[$handle] = $field
+                ? $field->serializeValue($element->getFieldValue($handle), $element)
+                : $element->getFieldValue($handle);
+        }
+
+        return $values;
+    }
+
+    /**
+     * Compares the given old attribute values against the element's current values.
+     */
+    private function attributeValuesChanged(ElementInterface $element, array $oldValues): bool
+    {
+        return array_any($oldValues, fn ($oldValue, $handle) => $oldValue != $element->$handle);
+    }
+
+    /**
+     * Compares the given old serialized field values against the element's current values.
+     */
+    /**
+     * Returns whether the incoming data fills a container field that the element has no nested
+     * elements for yet - a case comparing serialized values can't detect.
+     *
+     * @param  array<string, mixed>  $fields
+     * @param  array<string, mixed>  $oldValues
+     */
+    private function hasNewContainerFieldData(ElementInterface $element, array $fields, array $oldValues): bool
+    {
+        $fieldLayout = $element->getFieldLayout();
+
+        if (! $fieldLayout) {
+            return false;
+        }
+
+        foreach ($fields as $handle => $value) {
+            if (empty($value) || ! empty($oldValues[$handle])) {
+                continue;
+            }
+
+            if ($fieldLayout->getFieldByHandle((string) $handle) instanceof ImportableElementContainerFieldInterface) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function fieldValuesChanged(ElementInterface $element, array $oldValues): bool
+    {
+        $fieldLayout = $element->getFieldLayout();
+
+        foreach ($oldValues as $handle => $oldValue) {
+            $field = $fieldLayout?->getFieldByHandle($handle);
+            $newValue = $field
+                ? $field->serializeValue($element->getFieldValue($handle), $element)
+                : $element->getFieldValue($handle);
+
+            // using !== cause the order of the keys is important here
+            if ($oldValue !== $newValue) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Prepares a new element or looks up an existing one via a match criteria query, applying site ID.
+     */
+    private function getRootElement(array &$data): ElementInterface
+    {
+        // figure out if we're adding or editing
+        $element = $this->prepareNewRootElementForImport($data);
+
+        // if we don't have matchCriteria, then return a new Element
+        if (empty($data['matchCriteria'])) {
+            return $element;
+        }
+
+        if (is_array($data['matchCriteria'])) {
+            $query = $element::find()
+                ->drafts(null)
+                ->status(null);
+
+            // give element a chance to adjust the query
+            $this->prepareRootElementImportQuery($element, $query);
+
+            // by now the match criteria from various sources (ui, config, transformer) should have been merged,
+            // and the values from incoming data should have been applied to it
+            $criteria = $data['matchCriteria'];
+
+            // if we still don't have criteria, return a new Element
+            if (empty($criteria)) {
+                $element->siteId = $this->site?->id;
+
+                return $element;
+            }
+
+            Typecast::configure($query, $criteria);
+
+            // ensure we use the config's siteId, not one from the matchCriteria
+            // that's why we haven't set it earlier on
+            $query->siteId = $this->site?->id;
+
+            // return found or new element
+            return $query->one() ?? $element;
+        }
+
+        // return new element
+        return $element;
+    }
+
+    /**
+     * Runs each field's `normalizeValueForImport()` (if defined) over the incoming field data.
+     */
+    private function normalizeFields(ElementInterface $rootElement, array $data): array
+    {
+        $fieldLayout = $rootElement->getFieldLayout();
+
+        if (! $fieldLayout) {
+            return $data;
+        }
+
+        foreach ($data as $handle => $value) {
+            $field = $fieldLayout->getFieldByHandle($handle);
+            // if we don't have a field, or it doesn't have a normalizeValueForImport() method,
+            // we don't have to worry about extra normalization, so carry on
+            if (! $field) {
+                continue;
+            }
+            if (! method_exists($field, 'normalizeValueForImport')) {
+                continue;
+            }
+
+            $data[$handle] = $field->normalizeValueForImport($value, $this, $rootElement);
+        }
+
+        return $data;
+    }
+}
diff --git a/src/Element/Import/ElementTransformer.php b/src/Element/Import/ElementTransformer.php
new file mode 100644
index 00000000000..f5c1eeee0fd
--- /dev/null
+++ b/src/Element/Import/ElementTransformer.php
@@ -0,0 +1,125 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Element\Import;
+
+use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\Import\Transformers\BaseTransformer;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\ImportHelper;
+
+class ElementTransformer extends BaseTransformer
+{
+    public ?array $props = null;
+
+    /**
+     * This method is called automatically by Fractal when transforming an item.
+     * It's responsible for converting the incoming data (e.g. from the json file)
+     * into an array that's understood and can be imported into an Element.
+     *
+     * This is where you can manipulate the data before it's imported.
+     * For example, you can choose to uppercase the text, concatenate it or do whatever you want.
+     *
+     * If you use field handles as keys in the incoming data, the mapping will happen automatically.
+     * But if you don't, this is where you can also set that up.
+     * For example, if you have a 'myPlainTextField' custom field that you know is available on the element you're importing into,
+     * and the incoming data has a 'myContent' key, you can map it to that field.
+     *
+     * Note: with automatic handle matching, if the handle is overwritten in the field layout, that's what's used;
+     * it *doesn't* fall back to the original handle.
+     *
+     * Returns the transformed data array, ready to be imported into an Element.
+     *
+     * @param  mixed  $item  The raw item data to transform.
+     *
+     * @throws \ReflectionException
+     */
+    public function transform(mixed $item): array
+    {
+        $element = $this->getCurrentScope()->getResource()->getMeta()['element'] ?? null;
+
+        // automatically include all Importable properties (e.g. sectionId, typeId for Entry);
+        if ($this->props === null) {
+            $config = $this->getCurrentScope()->getResource()->getMeta()['config'];
+            $this->props = ImportHelper::getImportableProperties($config);
+        }
+
+        $array = [];
+
+        // at this stage the $item contains the keys that have been run through the remapData() helper,
+        // so all the UI-based mapping is taken into consideration;
+        // we now want to compose an array of key-value pairs where the keys are the properties that are available on the element
+        // and the values are the raw values from the incoming data;
+        $incomingKeys = array_combine(array_keys($item), array_keys($item));
+        $incomingKeys = array_map(fn ($key) => ImportHelper::prepKeyForAutoMatching((string) $key), $incomingKeys);
+
+        foreach ($this->props as $prop) {
+            // if it exists, then it was either mapped like this or the "correct" key already existed in the incoming data
+            // use it and remove it from a list of keys we can mess with in the next step
+            if (array_key_exists((string) $prop['name'], $item)) {
+                $array[$prop['name']] = $this->normalizePropertyValue($item, $prop, $element);
+                unset($incomingKeys[$prop['name']]);
+                // otherwise attempt to match auto-magically
+            } elseif ($key = array_search(ImportHelper::prepKeyForAutoMatching((string) $prop['name']), $incomingKeys)) {
+                $array[$prop['name']] = $this->normalizePropertyValue($item[$key], $prop, $element);
+            }
+        }
+
+        // include all custom fields
+        $fieldLayout = $element->getFieldLayout();
+        // if we don't have a field layout here, it means we're creating a new element and the field layout isn't set yet
+        if (! $fieldLayout) {
+            // if we have a typeId, try to get the field layout from the entry type - this is the case for Entry element
+            if (isset($array['typeId'])) {
+                $entryType = EntryTypes::getEntryTypeById((int) $array['typeId']);
+                if ($entryType) {
+                    $fieldLayout = $entryType->getFieldLayout();
+                }
+            }
+        }
+
+        // now, we should have a layout, so we can get all the field handles
+        if ($fieldLayout) {
+            $fieldHandles = array_filter(
+                array_map(
+                    fn ($fieldLayoutElement) => $fieldLayoutElement->attribute(),
+                    $fieldLayout->getAllElements()
+                )
+            );
+
+            // and this is where auto-magical mapping happens between what's in the incoming data and in the field layout element handles
+            foreach ($fieldHandles as $fieldHandle) {
+                // if it exists, then it was either mapped like this or the "correct" key already existed in the incoming data
+                // use it and remove it from a list of keys we can mess with in the next step
+                if (array_key_exists((string) $fieldHandle, $item)) {
+                    $array[$fieldHandle] = $item[$fieldHandle];
+                    unset($incomingKeys[$fieldHandle]);
+                    // otherwise attempt to match auto-magically
+                } elseif ($key = array_search(ImportHelper::prepKeyForAutoMatching((string) $fieldHandle), $incomingKeys)) {
+                    $array[$fieldHandle] = $item[$key];
+                }
+            }
+        }
+
+        return $array;
+    }
+
+    /**
+     * Looks up a raw property value from the item and calls a `normalize{PropName}()` method if defined on the transformer, else returns the raw or default value.
+     */
+    private function normalizePropertyValue(mixed $item, array $prop, ElementInterface $element): mixed
+    {
+        $rawValue = $item[$prop['name']] ?? null;
+
+        if ($rawValue !== null) {
+            if (method_exists($this, 'normalize'.ucfirst((string) $prop['name']))) {
+                return $this::{'normalize'.ucfirst((string) $prop['name'])}($rawValue, $element);
+            }
+
+            return $rawValue;
+        }
+
+        return $prop['defaultValue'] ?? null;
+    }
+}
diff --git a/src/Element/NestedElementManager.php b/src/Element/NestedElementManager.php
index 800b303d49e..faec8dd02a9 100644
--- a/src/Element/NestedElementManager.php
+++ b/src/Element/NestedElementManager.php
@@ -101,6 +101,8 @@ public function __construct(
 
     public ?string $propagationKeyFormat = null;
 
+    public bool $keepOtherNestedElements = false;
+
     public function getIsTranslatable(?ElementInterface $owner = null): bool
     {
         if ($this->propagationMethod === PropagationMethod::Custom && $this->propagationKeyFormat !== null) {
@@ -1002,7 +1004,9 @@ private function saveNestedElements(ElementInterface $owner): void
                 $elementIds[] = $element->id;
             }
 
-            $this->deleteOtherNestedElements($owner, $elementIds);
+            if (! $this->keepOtherNestedElements) {
+                $this->deleteOtherNestedElements($owner, $elementIds);
+            }
 
             if (
                 $this->propagationMethod !== PropagationMethod::All &&
diff --git a/src/Entry/Commands/ImportEntry.php b/src/Entry/Commands/ImportEntry.php
new file mode 100644
index 00000000000..98900feb736
--- /dev/null
+++ b/src/Entry/Commands/ImportEntry.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Entry\Commands;
+
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Import\Commands\Import;
+use CraftCms\Cms\Section\Data\Section;
+use CraftCms\Cms\Support\Facades\Sections;
+use Override;
+use Symfony\Component\Console\Input\InputOption;
+
+use function Laravel\Prompts\select;
+
+class ImportEntry extends Import
+{
+    #[Override]
+    protected $name = 'craft:import:entry';
+
+    #[Override]
+    protected $description = 'Imports Craft CMS Entries';
+
+    #[Override]
+    protected $aliases = ['import/entry'];
+
+    #[Override]
+    protected function configure(): void
+    {
+        parent::configure();
+
+        $this->addOption('section', null, InputOption::VALUE_OPTIONAL, 'The section to import into.')
+            ->addOption('entryType', null, InputOption::VALUE_OPTIONAL, 'The entry type to import into.');
+    }
+
+    #[Override]
+    public static function importerClass(): string
+    {
+        return EntryImporter::class;
+    }
+
+    #[Override]
+    protected function getAdditionalOptions(): array
+    {
+        return array_merge(parent::getAdditionalOptions(), [
+            'section' => [
+                'prompt' => fn () => select(
+                    label: 'Which section do you want to import into?',
+                    options: Sections::getAllSections()->mapWithKeys(fn (Section $section) => [$section->uid => $section->name])->all(),
+                ),
+            ],
+            'entryType' => [
+                'prompt' => fn ($responses) => select(
+                    label: 'Which entry type do you want to import into?',
+                    options: $this->entryTypeOptions($responses['section']),
+                ),
+            ],
+        ]);
+    }
+
+    private function entryTypeOptions(?string $section): array
+    {
+        if ($section === null) {
+            return [];
+        }
+
+        $section = Sections::getSectionByUid($section);
+
+        return collect($section?->getEntryTypes())
+            ->mapWithKeys(fn ($entryType) => [$entryType->uid => $entryType->name])
+            ->all();
+    }
+}
diff --git a/src/Entry/Elements/Entry.php b/src/Entry/Elements/Entry.php
index 100ae2d5d02..18faf133ba5 100644
--- a/src/Entry/Elements/Entry.php
+++ b/src/Entry/Elements/Entry.php
@@ -75,6 +75,7 @@
 use CraftCms\Cms\Site\Data\Site;
 use CraftCms\Cms\Structure\Enums\Mode;
 use CraftCms\Cms\Support\Arr;
+use CraftCms\Cms\Support\Attributes\Importable;
 use CraftCms\Cms\Support\Facades\DeltaRegistry;
 use CraftCms\Cms\Support\Facades\ElementActions;
 use CraftCms\Cms\Support\Facades\Elements;
@@ -147,6 +148,7 @@ class Entry extends Element implements Colorable, ExpirableElementInterface, Ico
      *               ```
      */
     #[AllowedInSandbox]
+    #[Importable('sectionId', 'Section ID', excludeFromUiMapping: true, canBeCleared: false)]
     public ?int $sectionId = null;
 
     /**
@@ -165,6 +167,7 @@ class Entry extends Element implements Colorable, ExpirableElementInterface, Ico
      *                             ```
      */
     #[AllowedInSandbox]
+    #[Importable('postDate', 'Post Date')]
     public ?DateTimeInterface $postDate = null;
 
     /**
@@ -182,6 +185,7 @@ class Entry extends Element implements Colorable, ExpirableElementInterface, Ico
      *                             ```
      */
     #[AllowedInSandbox]
+    #[Importable('expiryDate', 'Expiry Date')]
     public ?DateTimeInterface $expiryDate = null;
 
     /**
@@ -223,6 +227,7 @@ class Entry extends Element implements Colorable, ExpirableElementInterface, Ico
      * @see getAuthorIds()
      * @see setAuthorIds()
      */
+    #[Importable('authorIds', 'Author IDs')]
     private array $_authorIds;
 
     /**
@@ -246,6 +251,7 @@ class Entry extends Element implements Colorable, ExpirableElementInterface, Ico
      *
      * @see getType()
      */
+    #[Importable('typeId', 'Type ID', true)]
     private ?int $_typeId = null;
 
     private ?int $_oldTypeId = null;
@@ -1028,7 +1034,7 @@ public function setAttributesFromRequest(array $values): void
             $oldAuthorIds = $this->getAuthorIds();
             if (
                 $authorIds !== $oldAuthorIds &&
-                $this->canChangeAuthor()
+                ($this->canChangeAuthor() || $this->importing)
             ) {
                 $this->_oldAuthorIds = $oldAuthorIds;
                 $this->setAuthorIds($authorIds);
diff --git a/src/Entry/Import/EntryImporter.php b/src/Entry/Import/EntryImporter.php
new file mode 100644
index 00000000000..6db2554b93f
--- /dev/null
+++ b/src/Entry/Import/EntryImporter.php
@@ -0,0 +1,314 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Entry\Import;
+
+use Closure;
+use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\Element\Import\ElementImporter;
+use CraftCms\Cms\Entry\Data\EntryType;
+use CraftCms\Cms\Entry\Elements\Entry;
+use CraftCms\Cms\Form\Controls\Choice;
+use CraftCms\Cms\Form\FormContext;
+use CraftCms\Cms\Form\Nodes\Field as FormField;
+use CraftCms\Cms\Form\Nodes\Group;
+use CraftCms\Cms\Section\Data\Section;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\Facades\Sections;
+use Illuminate\Validation\Validator;
+use Override;
+
+use function CraftCms\Cms\t;
+
+/**
+ * Imports data into Entry elements.
+ */
+class EntryImporter extends ElementImporter
+{
+    public protected(set) ?string $section = null;
+
+    public protected(set) ?string $entryType = null;
+
+    #[Override]
+    public static function targetClass(): string
+    {
+        return Entry::class;
+    }
+
+    /**
+     * Convenience factory returning a new instance.
+     */
+    public static function create(): self
+    {
+        return new self;
+    }
+
+    #[Override]
+    public static function displayName(): string
+    {
+        return t('Entries');
+    }
+
+    public static function getDefaultTransformer(): ?string
+    {
+        return EntryTransformer::class;
+    }
+
+    #[Override]
+    public function settingsForm(FormContext $context): array
+    {
+        $parent = parent::settingsForm($context);
+
+        return [
+            'context' => $parent['context'] ?? $context,
+            'nodes' => [
+                ...$parent['nodes'] ?? [],
+                FormField::make(t('Section'), Choice::make(['section'])
+                    ->value($this->section)
+                    ->placeholder(t('Please select'))
+                    ->options($this->availableSections())
+                    ->reactive())
+                    ->instructions(t('The section to import into.')),
+                Group::make('entry-type-group', [
+                    // reactive: choosing an entry type is what resolves the field layout,
+                    // which the step's mapping is gated on
+                    FormField::make(t('Entry Type'), Choice::make('entryType')
+                        ->value($this->entryType)
+                        ->placeholder(t('Please select'))
+                        ->options($this->availableEntryTypes())
+                        ->reactive())
+                        ->instructions(t('The entry type to import into.')),
+                ])
+                    ->dependsOn('settings.section')
+                    ->visible($this->section !== null),
+            ],
+        ];
+    }
+
+    #[Override]
+    public function refreshSettingsForm(array $settings): void
+    {
+        parent::refreshSettingsForm($settings);
+
+        if (array_key_exists('section', $settings)) {
+            $this->section($settings['section']);
+        }
+        if (array_key_exists('entryType', $settings)) {
+            $this->entryType($settings['entryType']);
+        }
+    }
+
+    #[Override]
+    public function storeSettings(array $settings): void
+    {
+        parent::storeSettings($settings);
+
+        $this->section($settings['section'] ?? null);
+        $this->entryType($settings['entryType'] ?? null);
+    }
+
+    #[Override]
+    public function getSettings(): array
+    {
+        $settings = parent::getSettings();
+
+        $settings['section'] = $this->section;
+        $settings['entryType'] = $this->entryType;
+
+        return $settings;
+    }
+
+    /**
+     * Sets the target section by uid.
+     */
+    public function section(string|int|Section|null $value): self
+    {
+        $result = self::normalizeSection($value);
+        $this->section = $result?->uid;
+
+        return $this;
+    }
+
+    /**
+     * Sets the target entry type by uid.
+     */
+    public function entryType(string|int|EntryType|null $value): self
+    {
+        $result = self::normalizeEntryType($value);
+        if (! $result) {
+            $this->entryType = null;
+            $this->fieldLayout(null);
+        } else {
+            $this->entryType = $result->uid;
+            $this->fieldLayout($result->getFieldLayout());
+        }
+
+        return $this;
+    }
+
+    #[Override]
+    public static function getSettingsRules(): array
+    {
+        return array_merge(parent::getSettingsRules(), [
+            'settings.section' => [
+                'required',
+                'string',
+                'max:255',
+                fn ($attribute, $value, Closure $fail, Validator $validator) => static::validateSection($value, $attribute, $fail, $validator),
+            ],
+            'settings.entryType' => [
+                'required',
+                'string',
+                'max:255',
+                fn ($attribute, $value, Closure $fail, Validator $validator) => static::validateEntryType($value, $attribute, $fail, $validator),
+            ],
+        ]);
+    }
+
+    #[Override]
+    public function toArrayData(): array
+    {
+        $data = parent::toArrayData();
+        $data['settings']['section'] = $this->section ?? null;
+        $data['settings']['entryType'] = $this->entryType ?? null;
+
+        return $data;
+    }
+
+    public static function validateSection(string $value, string $attribute, Closure $fail, Validator $validator): bool
+    {
+        // can't be empty
+        if (empty($value)) {
+            $fail($attribute, t('Section must be provided.'));
+
+            return false;
+        }
+
+        if (static::normalizeSection($value) === null) {
+            $fail($attribute, t('No Section found for “{section}”.', [
+                'section' => $value,
+            ]));
+
+            return false;
+        }
+
+        return true;
+    }
+
+    public static function validateEntryType(string $value, string $attribute, Closure $fail, Validator $validator): bool
+    {
+        // can't be empty
+        if (empty($value)) {
+            $fail($attribute, t('Entry Type must be provided.'));
+
+            return false;
+        }
+
+        if (static::normalizeEntryType($value) === null) {
+            $fail($attribute, t('No Entry Type found for “{entryType}”.', [
+                'entryType' => $value,
+            ]));
+
+            return false;
+        }
+
+        return true;
+    }
+
+    private static function normalizeSection(string|int|Section|null $value): ?Section
+    {
+        return match (true) {
+            $value instanceof Section => $value,
+            $value === null => null,
+            is_numeric($value) => Sections::getSectionById((int) $value),
+            default => Sections::getSectionByUid($value) ?? Sections::getSectionByHandle($value),
+        };
+    }
+
+    private static function normalizeEntryType(string|int|EntryType|null $value): ?EntryType
+    {
+        return match (true) {
+            $value instanceof EntryType => $value,
+            $value === null => null,
+            is_numeric($value) => EntryTypes::getEntryTypeById((int) $value),
+            default => EntryTypes::getEntryTypeByUid($value) ?? EntryTypes::getEntryTypeByHandle($value),
+        };
+    }
+
+    #[Override]
+    public function prepareNewRootElementForImport(array &$data, ?ElementInterface $element = null): ElementInterface
+    {
+        /** @var Entry $element */
+        if ($element === null) {
+            $section = null;
+            $entryType = null;
+
+            // if it's UI-driven element import where the fieldLayout was chosen in the editable config,
+            // we need to ensure the sectionId and typeId are both set
+            if ($this->section) {
+                $section = Sections::getSectionByUid($this->section);
+                $data['sectionId'] = $section->id;
+            } elseif (isset($data['sectionId'])) {
+                $section = self::normalizeSection($data['sectionId']);
+            }
+            if ($this->entryType) {
+                $entryType = EntryTypes::getEntryTypeByUid($this->entryType);
+                $data['typeId'] = $entryType->id;
+            } elseif (isset($data['typeId'])) {
+                $entryType = self::normalizeEntryType($data['typeId']);
+            }
+
+            $element = new ($this::targetClass());
+            $element->sectionId = $section?->id;
+
+            if ($entryType) {
+                $element->setTypeId($entryType->id);
+                $element->fieldLayoutId = $entryType->getFieldLayoutId();
+                if (isset($data['matchCriteria']['typeId'])) {
+                    unset($data['matchCriteria']['typeId']);
+                }
+            }
+        }
+
+        parent::prepareNewRootElementForImport($data, $element);
+
+        return $element;
+    }
+
+    #[Override]
+    public function setAttributesForImport(ElementInterface $element, array $attributes): void
+    {
+        // for UI-based import, ensure we're not changing type ID compared to what we chose in the field layout provider step
+        if (isset($this->section)) {
+            unset($attributes['sectionId']);
+        }
+        if (isset($this->entryType) || isset($this->fieldLayout)) {
+            unset($attributes['typeId']);
+        }
+
+        parent::setAttributesForImport($element, $attributes);
+    }
+
+    protected function availableSections(): array
+    {
+        return Sections::getAllSections()->map(fn ($section) => [
+            'label' => $section->name,
+            'value' => $section->uid,
+        ])->all();
+    }
+
+    protected function availableEntryTypes(): array
+    {
+        if ($this->section === null) {
+            return [];
+        }
+
+        $section = Sections::getSectionByUid($this->section);
+
+        return collect($section?->getEntryTypes())->map(fn ($entryType) => [
+            'label' => $entryType->name,
+            'value' => $entryType->uid,
+        ])->all();
+    }
+}
diff --git a/src/Entry/Import/EntryTransformer.php b/src/Entry/Import/EntryTransformer.php
new file mode 100644
index 00000000000..16ca4b960ef
--- /dev/null
+++ b/src/Entry/Import/EntryTransformer.php
@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Entry\Import;
+
+use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\Element\Import\ElementTransformer;
+use CraftCms\Cms\Entry\Elements\Entry;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\Facades\Sections;
+
+class EntryTransformer extends ElementTransformer
+{
+    /**
+     * Normalizes an incoming section value (numeric id or handle string) to a section ID.
+     */
+    protected function normalizeSectionId(mixed $value, ElementInterface $element): ?int
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        if (is_int($value) || is_numeric($value)) {
+            // $section = Sections::getSectionById($value);
+            return (int) $value;
+        }
+
+        if (is_string($value)) {
+            $section = Sections::getSectionByHandle($value) ?? Sections::getSectionByUid($value);
+            if ($section) {
+                return $section->id;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Normalizes an incoming entry-type value (numeric id or handle string) to a type ID, falling back to the element's current type ID.
+     */
+    protected function normalizeTypeId(mixed $value, ElementInterface $element): ?int
+    {
+        if ($value === null) {
+            /** @var $element Entry */
+            return $element->getTypeId();
+        }
+
+        if (is_int($value) || is_numeric($value)) {
+            $type = EntryTypes::getEntryTypeById((int) $value);
+
+            return $type?->id;
+        }
+
+        if (is_string($value)) {
+            $type = EntryTypes::getEntryTypeByHandle($value);
+
+            return $type?->id;
+        }
+
+        /** @var $element Entry */
+        return $element->getTypeId();
+    }
+}
diff --git a/src/Field/Addresses.php b/src/Field/Addresses.php
index 77935278986..6c53bdc2d40 100644
--- a/src/Field/Addresses.php
+++ b/src/Field/Addresses.php
@@ -17,10 +17,12 @@
 use CraftCms\Cms\Element\Queries\AddressQuery;
 use CraftCms\Cms\Element\Queries\Contracts\ElementQueryInterface;
 use CraftCms\Cms\Element\Validation\ElementRules;
+use CraftCms\Cms\Field\Concerns\ImportableElementContainerField;
 use CraftCms\Cms\Field\Conditions\EmptyFieldConditionRule;
 use CraftCms\Cms\Field\Contracts\EagerLoadingFieldInterface;
 use CraftCms\Cms\Field\Contracts\ElementContainerFieldInterface;
 use CraftCms\Cms\Field\Contracts\FieldInterface;
+use CraftCms\Cms\Field\Contracts\ImportableElementContainerFieldInterface;
 use CraftCms\Cms\Field\Contracts\MergeableFieldInterface;
 use CraftCms\Cms\Field\Enums\TranslationMethod;
 use CraftCms\Cms\Field\Exceptions\InvalidFieldException;
@@ -39,10 +41,14 @@
 use CraftCms\Cms\Gql\Interfaces\Elements\Address as AddressGqlInterface;
 use CraftCms\Cms\Gql\Resolvers\Elements\Address as AddressResolver;
 use CraftCms\Cms\Gql\Types\Input\Addresses as AddressesInput;
+use CraftCms\Cms\Import\Importers\BaseImporter;
 use CraftCms\Cms\Shared\Enums\Color;
+use CraftCms\Cms\Support\Arr;
 use CraftCms\Cms\Support\Facades\Sites;
 use CraftCms\Cms\Support\Html;
+use CraftCms\Cms\Support\ImportHelper;
 use CraftCms\Cms\Support\Str;
+use CraftCms\Cms\Support\Typecast;
 use CraftCms\Cms\User\Elements\User;
 use GraphQL\Type\Definition\Type;
 use Illuminate\Database\Query\Builder;
@@ -69,8 +75,10 @@
  *     createElement:callable,
  * }
  */
-class Addresses extends Field implements EagerLoadingFieldInterface, ElementContainerFieldInterface, MergeableFieldInterface
+class Addresses extends Field implements EagerLoadingFieldInterface, ElementContainerFieldInterface, ImportableElementContainerFieldInterface, MergeableFieldInterface
 {
+    use ImportableElementContainerField;
+
     public const string VIEW_MODE_CARDS = 'cards';
 
     public const string VIEW_MODE_INDEX = 'index';
@@ -422,7 +430,7 @@ private function normalizeValueInternal(mixed $value, ?ElementInterface $element
      * @param  array<array-key, array<string, mixed>>  $value
      * @return list<Address>
      */
-    private function createAddressesFromSerializedData(array $value, ElementInterface $element, bool $fromRequest): array
+    public function createAddressesFromSerializedData(array $value, ElementInterface $element, bool $fromRequest): array
     {
         // Was the value posted in the new (delta) format, and by UUID or ID?
         ['delta' => $delta, 'uids' => $uids, 'entries' => $newAddressData, 'sortOrder' => $newSortOrder] =
@@ -565,6 +573,12 @@ private function createAddressesFromSerializedData(array $value, ElementInterfac
                 $addressData += $addressData['address'];
             }
 
+            // Import data may nest latitude & longitude under a `latLong` key (the name of the
+            // layout element); the Lat/Long control itself posts them as flat inputs
+            if (isset($addressData['latLong']) && is_array($addressData['latLong'])) {
+                $addressData += $addressData['latLong'];
+            }
+
             foreach ($nativeFields as $field) {
                 if (array_key_exists($field, $addressData)) {
                     $address->$field = $addressData[$field];
@@ -991,6 +1005,22 @@ public function afterElementPropagate(ElementInterface $element, bool $isNew): v
         parent::afterElementPropagate($element, $isNew);
     }
 
+    /**
+     * @see ImportableElementContainerFieldInterface::canKeepMissingNestedElements()
+     */
+    public function canKeepMissingNestedElements(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @see ImportableElementContainerFieldInterface::setKeepMissingNestedElements()
+     */
+    public function setKeepMissingNestedElements(bool $keep): void
+    {
+        $this->addressManager()->keepOtherNestedElements = $keep;
+    }
+
     #[Override]
     public function beforeElementDelete(ElementInterface $element): bool
     {
@@ -1012,4 +1042,70 @@ public function afterElementRestore(ElementInterface $element): void
 
         parent::afterElementRestore($element);
     }
+
+    /**
+     * Normalizes value so that it can be imported into an Addresses-type field.
+     * The custom field values must be nested under a "fields" key.
+     *
+     * The value has to be an array; each item in the array represents an address.
+     */
+    #[Override]
+    public function normalizeValueForImport(mixed $value, BaseImporter $importer, ?ElementInterface $rootOwner = null): array
+    {
+        if (! is_array($value)) {
+            return [];
+        }
+
+        $normalizedValue = [];
+        $fieldLayout = app(\CraftCms\Cms\Address\Addresses::class)->getFieldLayout();
+        $i = 0;
+
+        foreach ($value as $address) {
+            if (! is_array($address)) {
+                continue;
+            }
+
+            // skip this row if everything other than the reserved matchCriteria key is empty
+            if (ImportHelper::isEmptyImportEntryData(Arr::except($address, ['matchCriteria']))) {
+                continue;
+            }
+
+            $addressElement = null;
+            $newKey = null;
+
+            // try to match existing address entries,
+            // but only if owner already has an ID; no point trying to match nested entry for a brand new owner element
+            if (($rootOwner?->id)) {
+                $criteria = [];
+
+                if (! empty($address['matchCriteria'])) {
+                    $criteria = $address['matchCriteria'];
+                }
+
+                if (! empty($criteria)) {
+                    $query = Address::find()
+                        ->fieldId($this->id)
+                        ->ownerId($rootOwner->id);
+
+                    Typecast::configure($query, $criteria);
+                    $addressElement = $query->one();
+                }
+
+                if ($addressElement) {
+                    $newKey = $addressElement->id;
+                } else {
+                    $newKey = 'new:'.++$i;
+                }
+            }
+
+            // if we still don't have a key, generate a new one
+            $newKey ??= 'new:'.++$i;
+
+            Arr::forget($address, ['matchCriteria']);
+
+            $normalizedValue[$newKey] = $this->normalizeNestedEntryForImport($address, $importer, $fieldLayout, $addressElement);
+        }
+
+        return $normalizedValue;
+    }
 }
diff --git a/src/Field/BaseRelationField.php b/src/Field/BaseRelationField.php
index 052a90c5001..ebf4a15e3fa 100644
--- a/src/Field/BaseRelationField.php
+++ b/src/Field/BaseRelationField.php
@@ -49,6 +49,7 @@
 use CraftCms\Cms\Form\Nodes\Field as FormField;
 use CraftCms\Cms\Form\Nodes\Group;
 use CraftCms\Cms\Image\Enums\ImageTransformMode;
+use CraftCms\Cms\Import\Importers\BaseImporter;
 use CraftCms\Cms\Site\Exceptions\SiteNotFoundException;
 use CraftCms\Cms\Support\Arr;
 use CraftCms\Cms\Support\Facades\Conditions;
@@ -1160,6 +1161,15 @@ protected function fetchRelationsFromDbTable(?ElementInterface $element): bool
         return true;
     }
 
+    #[Override]
+    public function normalizeValueForImport(mixed $value, BaseImporter $importer, ?ElementInterface $rootOwner = null): mixed
+    {
+        // A cleared relation field arrives as null, which normalizeValue() reads as “never set” and
+        // resolves back to the stored relations; an empty list is what actually clears them - the
+        // same translation normalizeValueFromRequest() does for the control panel.
+        return $value ?? [];
+    }
+
     #[Override]
     public function serializeValue(mixed $value, ?ElementInterface $element): mixed
     {
diff --git a/src/Field/Concerns/ImportableElementContainerField.php b/src/Field/Concerns/ImportableElementContainerField.php
new file mode 100644
index 00000000000..8bc81de2d7c
--- /dev/null
+++ b/src/Field/Concerns/ImportableElementContainerField.php
@@ -0,0 +1,108 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Field\Concerns;
+
+use Closure;
+use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\Field\Contracts\ImportableElementContainerFieldInterface;
+use CraftCms\Cms\FieldLayout\FieldLayout;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use Illuminate\Validation\Validator;
+
+/**
+ * ImportableElementContainerFieldTrait provides a base implementation for {@see ImportableElementContainerFieldInterface}.
+ */
+trait ImportableElementContainerField
+{
+    /**
+     * @see ImportableElementContainerFieldInterface::normalizeNestedEntryForImport()
+     */
+    public function normalizeNestedEntryForImport(array $dataItem, BaseImporter $importer, FieldLayout $fieldLayout, ?ElementInterface $owner = null): array
+    {
+        // custom field values may be given loosely rather than wrapped in a `fields` key, so move
+        // the ones that match a custom field in the layout there; anything else (native attributes
+        // like an address's countryCode, or reserved keys) stays where it is
+        if (! isset($dataItem['fields'])) {
+            $customFieldHandles = array_filter(
+                array_map(
+                    fn ($fieldLayoutElement) => $fieldLayoutElement instanceof CustomField ? $fieldLayoutElement->attribute() : null,
+                    $fieldLayout->getAllElements()
+                )
+            );
+
+            $customFields = [];
+            foreach ($dataItem as $key => $value) {
+                if (in_array($key, $customFieldHandles)) {
+                    $customFields[$key] = $value;
+                    unset($dataItem[$key]);
+                }
+            }
+
+            $dataItem['fields'] = $customFields;
+        }
+
+        $fields = $dataItem['fields'] ?? [];
+
+        foreach ($fields as $handle => $value) {
+            if (! is_array($value)) {
+                continue;
+            }
+            $field = $fieldLayout->getFieldByHandle($handle);
+
+            // if we don't have a field, or it's not an importable nested elements type field,
+            // we don't have to worry about extra normalization, so carry on
+            if (! $field instanceof ImportableElementContainerFieldInterface) {
+                continue;
+            }
+
+            $dataItem['fields'][$handle] = $field->normalizeValueForImport($value, $importer, $owner);
+        }
+
+        return $dataItem;
+    }
+
+    /**
+     * Some element container fields only have one field layout provider.
+     * In that case, the new prefix is "simply" based on whatever was passed in as a previous prefix.
+     * For other fields, like Matrix, this is more complex, and those fields implement their own version of this method.
+     *
+     * @see ImportableElementContainerFieldInterface::getMappingUiPrefix()
+     */
+    public function getMappingUiPrefix(FieldLayout $fieldLayout, mixed $provider = null, ?string $prefix = null): string
+    {
+        return ! empty($prefix) ? $prefix : '';
+    }
+
+    /**
+     * By default, let mapping validation pass.
+     *
+     * @see ImportableElementContainerFieldInterface::validateMapping()
+     */
+    public function validateMapping(mixed $value, string $attribute, Closure $fail, Validator $validator, array $params = []): bool
+    {
+        return true;
+    }
+
+    /**
+     * By default, this concept doesn't apply (no list of nested elements to prune).
+     *
+     * @see ImportableElementContainerFieldInterface::canKeepMissingNestedElements()
+     */
+    public function canKeepMissingNestedElements(): bool
+    {
+        return false;
+    }
+
+    /**
+     * By default, this is a no-op.
+     *
+     * @see ImportableElementContainerFieldInterface::setKeepMissingNestedElements()
+     */
+    public function setKeepMissingNestedElements(bool $keep): void
+    {
+        // by default, this doesn't do anything
+    }
+}
diff --git a/src/Field/ContentBlock.php b/src/Field/ContentBlock.php
index be3e8193d21..a07e0b27584 100644
--- a/src/Field/ContentBlock.php
+++ b/src/Field/ContentBlock.php
@@ -15,7 +15,9 @@
 use CraftCms\Cms\Element\Queries\ContentBlockQuery;
 use CraftCms\Cms\Element\Queries\Contracts\ElementQueryInterface;
 use CraftCms\Cms\Element\Validation\ElementRules;
+use CraftCms\Cms\Field\Concerns\ImportableElementContainerField;
 use CraftCms\Cms\Field\Contracts\ElementContainerFieldInterface;
+use CraftCms\Cms\Field\Contracts\ImportableElementContainerFieldInterface;
 use CraftCms\Cms\Field\Elements\ContentBlock as ContentBlockElement;
 use CraftCms\Cms\Field\Enums\TranslationMethod;
 use CraftCms\Cms\Field\Exceptions\FieldNotFoundException;
@@ -36,6 +38,7 @@
 use CraftCms\Cms\Gql\Resolvers\Elements\ContentBlock as ContentBlockResolver;
 use CraftCms\Cms\Gql\Types\Generators\ContentBlock as ContentBlockGenerator;
 use CraftCms\Cms\Gql\Types\Input\ContentBlock as ContentBlockInputType;
+use CraftCms\Cms\Import\Importers\BaseImporter;
 use CraftCms\Cms\Support\Facades\Elements;
 use CraftCms\Cms\Support\Facades\Fields;
 use CraftCms\Cms\Support\Facades\Sites;
@@ -54,8 +57,10 @@
 /**
  * Content Block field type
  */
-class ContentBlock extends Field implements ElementContainerFieldInterface, FieldLayoutProviderInterface
+class ContentBlock extends Field implements ElementContainerFieldInterface, FieldLayoutProviderInterface, ImportableElementContainerFieldInterface
 {
+    use ImportableElementContainerField;
+
     private const string VIEW_MODE_GROUPED = 'grouped';
 
     private const string VIEW_MODE_INLINE = 'inline';
@@ -834,4 +839,26 @@ private function _createContentBlockFromSerializedData(
 
         return $contentBlock;
     }
+
+    /**
+     * Normalizes value so that it can be imported into a Content Block-type field.
+     * The custom field values can be nested under a "fields" key or straight in the top-level array.
+     *
+     * The value has to be an array; each item in the array represents a field inside this singular nested entry.
+     */
+    #[Override]
+    public function normalizeValueForImport(mixed $value, BaseImporter $importer, ?ElementInterface $rootOwner = null): array
+    {
+        if (! is_array($value)) {
+            return [];
+        }
+
+        // Container fields nested in the block belong to the content block element rather than to
+        // the element this field is on, so that's the owner their match criteria has to look under.
+        // Stays null when there's no block yet, so those fields skip matching and create new
+        // elements.
+        $contentBlock = $rootOwner?->id ? $this->createContentBlockQuery($rootOwner)->one() : null;
+
+        return $this->normalizeNestedEntryForImport($value, $importer, $this->getFieldLayout(), $contentBlock);
+    }
 }
diff --git a/src/Field/Contracts/FieldInterface.php b/src/Field/Contracts/FieldInterface.php
index 81671baed8b..496f936cf85 100644
--- a/src/Field/Contracts/FieldInterface.php
+++ b/src/Field/Contracts/FieldInterface.php
@@ -23,6 +23,7 @@
 use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
 use CraftCms\Cms\Form\Contracts\Control;
 use CraftCms\Cms\Gql\Data\GqlSchema;
+use CraftCms\Cms\Import\Importers\BaseImporter;
 use CraftCms\Cms\Validation\Contracts\Validatable;
 use DateTimeInterface;
 use GraphQL\Type\Definition\FieldDefinition;
@@ -532,4 +533,9 @@ public function beforeElementRestore(ElementInterface $element): bool;
      * @param  ElementInterface  $element  The element that was just restored
      */
     public function afterElementRestore(ElementInterface $element): void;
+
+    /**
+     * Normalizes value so that it can be imported into the field.
+     */
+    public function normalizeValueForImport(mixed $value, BaseImporter $importer, ?ElementInterface $rootOwner = null): mixed;
 }
diff --git a/src/Field/Contracts/ImportableElementContainerFieldInterface.php b/src/Field/Contracts/ImportableElementContainerFieldInterface.php
new file mode 100644
index 00000000000..008c2d22f1b
--- /dev/null
+++ b/src/Field/Contracts/ImportableElementContainerFieldInterface.php
@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Field\Contracts;
+
+use Closure;
+use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\FieldLayout\FieldLayout;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use Illuminate\Validation\Validator;
+
+/**
+ * ImportableElementContainerFieldInterface defines the common interface to be implemented by field classes
+ * that contain nested elements and wish to support importing content via the import mechanism.
+ */
+interface ImportableElementContainerFieldInterface extends ElementContainerFieldInterface
+{
+    /**
+     * Normalize the nested entry data for import, applying the specified field layout configuration.
+     *
+     * @param  array  $dataItem  The data item to be normalized.
+     * @param  FieldLayout  $fieldLayout  The field layout to apply to the data item.
+     * @return array The normalized data item.
+     */
+    public function normalizeNestedEntryForImport(array $dataItem, BaseImporter $importer, FieldLayout $fieldLayout, ?ElementInterface $owner = null): array;
+
+    /**
+     * Returns a namespace prefix that is used on the mapping screen.
+     */
+    public function getMappingUiPrefix(FieldLayout $fieldLayout, mixed $provider = null, ?string $prefix = null): string;
+
+    /**
+     * Validates field's mapping.
+     */
+    public function validateMapping(mixed $value, string $attribute, Closure $fail, Validator $validator, array $params = []): bool;
+
+    /**
+     * Returns whether this field type supports keeping nested elements missing from imported data at all.
+     */
+    public function canKeepMissingNestedElements(): bool;
+
+    /**
+     * Sets whether nested elements missing from imported data should be kept (not pruned) on the next save.
+     *
+     * @param  bool  $keep  Whether missing nested elements should be kept.
+     */
+    public function setKeepMissingNestedElements(bool $keep): void;
+}
diff --git a/src/Field/Field.php b/src/Field/Field.php
index 5e53de44cf8..fe4d00921d3 100644
--- a/src/Field/Field.php
+++ b/src/Field/Field.php
@@ -47,6 +47,7 @@
 use CraftCms\Cms\Form\Enums\ControlMode;
 use CraftCms\Cms\Gql\Data\GqlSchema;
 use CraftCms\Cms\Gql\Types\QueryArgument;
+use CraftCms\Cms\Import\Importers\BaseImporter;
 use CraftCms\Cms\Shared\Contracts\Serializable;
 use CraftCms\Cms\Support\Arr;
 use CraftCms\Cms\Support\DateTimeHelper;
@@ -1182,4 +1183,11 @@ public function propagateValue(ElementInterface $from, ElementInterface $to): vo
     {
         $to->setFieldValue($this->handle, $from->getFieldValue($this->handle));
     }
+
+    #[Override]
+    public function normalizeValueForImport(mixed $value, BaseImporter $importer, ?ElementInterface $rootOwner = null): mixed
+    {
+        // by default, just return the value we were given
+        return $value;
+    }
 }
diff --git a/src/Field/Matrix.php b/src/Field/Matrix.php
index 1954a7850fb..0346e299b7c 100644
--- a/src/Field/Matrix.php
+++ b/src/Field/Matrix.php
@@ -28,14 +28,17 @@
 use CraftCms\Cms\Entry\Data\EntryType;
 use CraftCms\Cms\Entry\Elements\Entry;
 use CraftCms\Cms\Entry\EntryTypes;
+use CraftCms\Cms\Field\Concerns\ImportableElementContainerField;
 use CraftCms\Cms\Field\Conditions\EmptyFieldConditionRule;
 use CraftCms\Cms\Field\Contracts\EagerLoadingFieldInterface;
 use CraftCms\Cms\Field\Contracts\ElementContainerFieldInterface;
 use CraftCms\Cms\Field\Contracts\FieldInterface;
+use CraftCms\Cms\Field\Contracts\ImportableElementContainerFieldInterface;
 use CraftCms\Cms\Field\Contracts\MergeableFieldInterface;
 use CraftCms\Cms\Field\Enums\TranslationMethod;
 use CraftCms\Cms\Field\Events\EntryTypesForFieldResolving;
 use CraftCms\Cms\Field\Exceptions\InvalidFieldException;
+use CraftCms\Cms\FieldLayout\FieldLayout;
 use CraftCms\Cms\FieldLayout\FieldLayoutCompiler;
 use CraftCms\Cms\FieldLayout\FieldLayoutElementContext;
 use CraftCms\Cms\Form\Contracts\Control;
@@ -59,6 +62,7 @@
 use CraftCms\Cms\Gql\Resolvers\Elements\Entry as EntryResolver;
 use CraftCms\Cms\Gql\Types\Generators\EntryType as EntryTypeGenerator;
 use CraftCms\Cms\Gql\Types\Input\Matrix as MatrixInputType;
+use CraftCms\Cms\Import\Importers\BaseImporter;
 use CraftCms\Cms\Shared\Enums\Color;
 use CraftCms\Cms\Support\Arr;
 use CraftCms\Cms\Support\Facades\DeltaRegistry;
@@ -69,8 +73,10 @@
 use CraftCms\Cms\Support\Facades\InputNamespace;
 use CraftCms\Cms\Support\Facades\Sites;
 use CraftCms\Cms\Support\Html;
+use CraftCms\Cms\Support\ImportHelper;
 use CraftCms\Cms\Support\Json;
 use CraftCms\Cms\Support\Str;
+use CraftCms\Cms\Support\Typecast;
 use CraftCms\Cms\User\Elements\User;
 use CraftCms\Cms\Validation\Rules\UriFormatRule;
 use CraftCms\Cms\View\Enums\Position;
@@ -84,6 +90,7 @@
 use Illuminate\Support\Facades\Gate;
 use Illuminate\Support\Facades\Validator as ValidatorFacade;
 use Illuminate\Validation\Rule;
+use Illuminate\Validation\Validator;
 use InvalidArgumentException;
 use LogicException;
 use Override;
@@ -104,8 +111,12 @@
  * @phpstan-type SerializedEntryData array{type?:string,title?:string|null,slug?:string|null,uid?:string|null,enabled?:bool|int|string,collapsed?:bool|int|string,fresh?:bool|int|string,fields?:array<string,mixed>}
  * @phpstan-type SerializedEntries array<int|string,SerializedEntryData>
  */
-class Matrix extends Field implements EagerLoadingFieldInterface, ElementContainerFieldInterface, GqlInlineFragmentFieldInterface, MergeableFieldInterface
+class Matrix extends Field implements EagerLoadingFieldInterface, ElementContainerFieldInterface, GqlInlineFragmentFieldInterface, ImportableElementContainerFieldInterface, MergeableFieldInterface
 {
+    use ImportableElementContainerField {
+        validateMapping as traitValidateMapping;
+    }
+
     public const string VIEW_MODE_CARDS = 'cards';
 
     public const string VIEW_MODE_CARDS_GRID = 'cards-grid';
@@ -1798,6 +1809,22 @@ public function afterElementPropagate(ElementInterface $element, bool $isNew): v
         parent::afterElementPropagate($element, $isNew);
     }
 
+    /**
+     * @see ImportableElementContainerFieldInterface::canKeepMissingNestedElements()
+     */
+    public function canKeepMissingNestedElements(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @see ImportableElementContainerFieldInterface::setKeepMissingNestedElements()
+     */
+    public function setKeepMissingNestedElements(bool $keep): void
+    {
+        $this->entryManager()->keepOtherNestedElements = $keep;
+    }
+
     /**
      * Handles nested entry saves.
      */
@@ -2089,4 +2116,169 @@ private function _createEntriesFromSerializedData(array $value, ElementInterface
         /** @var Entry[] $entries */
         return $entries;
     }
+
+    /**
+     * Normalizes value so that it can be imported into a Matrix-type field.
+     *
+     * The value has to be an array; there are 2 options for this:
+     *   option 1:
+     *     each item in the array represents a nested entry (matrix "block");
+     *     in this case the sort order will follow the order of items this array
+     *   option 2:
+     *     it can contain 'sortOrder' and 'entries' keys (as per https://craftcms.com/docs/5.x/reference/field-types/matrix.html#saving-matrix-fields)
+     *
+     * In either case, each item represents a nested entry:
+     *   - must contain the "type" key, with a value containing the handle of the entry type it uses,
+     *   - should have the custom field values nested under a "fields" key
+     * (just as per the first paragraph here: https://craftcms.com/docs/5.x/reference/field-types/matrix.html#entry-data).
+     *
+     * If you want to update existing nested entries, you can find them via an optional "matchCriteria" key.
+     *
+     * Returned should be an array containing 'sortOrder' and 'entries' keys.
+     * The 'entries' array should be keyed by the entry ID if we're updating an existing entry,
+     * or by "new:X" key where X is an incremented integer
+     */
+    #[Override]
+    public function normalizeValueForImport(mixed $value, BaseImporter $importer, ?ElementInterface $rootOwner = null): array
+    {
+        if (! is_array($value)) {
+            return [];
+        }
+
+        $normalizedValue = [
+            'sortOrder' => [],
+            'entries' => [],
+        ];
+        $allowedEntryTypes = Arr::keyBy($this->getEntryTypes(), 'handle');
+
+        if (array_key_exists('entries', $value)) {
+            $entries = $value['entries'];
+        } else {
+            $entries = $value;
+        }
+
+        $arrayIsList = array_is_list($entries);
+        $i = 0;
+
+        foreach ($entries as $entry) {
+            if (! is_array($entry)) {
+                continue;
+            }
+
+            // skip this node if everything other than the reserved keys (matchCriteria, type) is empty
+            if (ImportHelper::isEmptyImportEntryData(Arr::except($entry, ['matchCriteria', 'type']))) {
+                continue;
+            }
+
+            $entryElement = null;
+            $newKey = null;
+
+            // if there's no type or type is not allowed - bail
+            if (! isset($entry['type'])) {
+                continue;
+            }
+            if (! isset($allowedEntryTypes[$entry['type']])) {
+                continue;
+            }
+
+            $entryType = $allowedEntryTypes[$entry['type']];
+
+            // try to match existing matrix entries,
+            // but only if owner already has an ID; no point trying to match nested entry for a new owner element
+            if (($rootOwner?->id)) {
+                $criteria = [];
+
+                if (! empty($entry['matchCriteria'])) {
+                    $criteria = $entry['matchCriteria'];
+                }
+
+                if (! empty($criteria)) {
+                    // try to find an existing entry
+                    $query = Entry::find()
+                        ->type($entry['type'])
+                        ->fieldId($this->id)
+                        ->ownerId($rootOwner->id)
+                        ->siteId($rootOwner->siteId);
+
+                    Typecast::configure($query, $criteria);
+                    $entryElement = $query->one();
+                }
+
+                if ($entryElement) {
+                    $newKey = $entryElement->id;
+                } else {
+                    $newKey = 'new:'.++$i;
+                }
+            }
+
+            // if we still don't have a key, generate a new one
+            $newKey ??= 'new:'.++$i;
+
+            Arr::forget($entry, [/* 'type', */ 'matchCriteria']);
+
+            $normalizedValue['sortOrder'][] = $newKey;
+            $normalizedValue['entries'][$newKey] = $this->normalizeNestedEntryForImport($entry, $importer, $entryType->getFieldLayout(), $entryElement);
+        }
+
+        // if we have a predefined sort order and entries were not a list - use that predefined sortOrder
+        if (! empty($value['sortOrder']) && ! $arrayIsList) {
+            $normalizedValue['sortOrder'] = $value['sortOrder'];
+            // todo (iwona): this doesn't seem needed;
+            // if we were to use it we should also array_intersect($normalizedValue['sortOrder'], $normalizedValue['entries']) or something like that
+            // $normalizedValue['entries'] = array_replace(array_flip($normalizedValue['sortOrder']), $value['entries']);
+        }
+
+        return $normalizedValue;
+    }
+
+    /**
+     * Matrix fields can have multiple field layout providers (multiple entry types),
+     * so the prefix needs to account for that.
+     */
+    #[Override]
+    public function getMappingUiPrefix(FieldLayout $fieldLayout, mixed $provider = null, ?string $prefix = null): string
+    {
+        $newPrefix = '';
+
+        if (! empty($prefix)) {
+            $newPrefix = $prefix;
+        }
+
+        // bail silently if we don't have an entry type here
+        if (empty($provider)) {
+            return $newPrefix;
+        }
+
+        return $newPrefix."[$provider->handle]";
+    }
+
+    #[Override]
+    public function validateMapping(mixed $value, string $attribute, Closure $fail, Validator $validator, array $params = []): bool
+    {
+        $field = $params['field'];
+
+        if (! is_array($value)) {
+            $value = [];
+        }
+
+        // validate that the provider types are allowed
+        $providers = $field->getFieldLayoutProviders();
+        $providerHandles = array_map(fn ($provider) => $provider->getHandle(), $providers);
+
+        $typesFromMap = array_unique(array_keys($value));
+
+        if (array_diff($typesFromMap, $providerHandles)) {
+            $fail($attribute, t('The map contains mapping for entry types that aren’t allowed for this field.'));
+
+            return false;
+        }
+
+        // todo (iwona): validate that the fields in each provider are allowed
+        foreach ($providers as $provider) {
+            $fieldLayout = $provider->getFieldLayout();
+            // self::traitValidateMapping($value,  $attribute,  $fail,  $validator, $params);
+        }
+
+        return true;
+    }
 }
diff --git a/src/FieldLayout/Concerns/ImportableFieldLayoutElement.php b/src/FieldLayout/Concerns/ImportableFieldLayoutElement.php
new file mode 100644
index 00000000000..15f448811f7
--- /dev/null
+++ b/src/FieldLayout/Concerns/ImportableFieldLayoutElement.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\FieldLayout\Concerns;
+
+use CraftCms\Cms\Field\Contracts\FieldInterface;
+use CraftCms\Cms\FieldLayout\FieldLayout;
+use CraftCms\Cms\Support\ImportHelper;
+
+trait ImportableFieldLayoutElement
+{
+    /**
+     * @see ImportableFieldLayoutElementInterface::getFieldsForMapping()
+     */
+    public function getFieldsForMapping(FieldLayout $fieldLayout, ?FieldInterface $ownerField, mixed $provider, ?string $prefix = null): array
+    {
+        $attribute = $this->attribute();
+        [$prefixedHandleForMap, $prefixedHandleForMatchCriteria, $prefixedHandleForClear, $prefixedHandle, $prefixedHandleAsArray] = ImportHelper::getPrefixedHandlesForMapping($attribute, $ownerField, null, $fieldLayout, $provider, $prefix);
+
+        return [
+            'handle' => $attribute,
+            'label' => $this->label(),
+            'prefixedHandleForMap' => $prefixedHandleForMap,
+            'prefixedHandleForMatchCriteria' => $prefixedHandleForMatchCriteria,
+            'prefixedHandleForClear' => $prefixedHandleForClear,
+            'prefixedHandle' => $prefixedHandle,
+            'prefixedHandleAsArray' => $prefixedHandleAsArray,
+            'isContainer' => false,
+            'canBeMatchCriteria' => $this->canBeMatchCriteria() ?? false,
+            'canBeCleared' => $this->canBeCleared(),
+        ];
+    }
+
+    /**
+     * @see ImportableFieldLayoutElementInterface::canBeMatchCriteria()
+     */
+    public function canBeMatchCriteria(): bool
+    {
+        return false;
+    }
+
+    /**
+     * @see ImportableFieldLayoutElementInterface::canBeCleared()
+     */
+    public function canBeCleared(): bool
+    {
+        return false;
+    }
+}
diff --git a/src/FieldLayout/Contracts/ImportableFieldLayoutElementInterface.php b/src/FieldLayout/Contracts/ImportableFieldLayoutElementInterface.php
new file mode 100644
index 00000000000..d180a91d232
--- /dev/null
+++ b/src/FieldLayout/Contracts/ImportableFieldLayoutElementInterface.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\FieldLayout\Contracts;
+
+use CraftCms\Cms\Field\Contracts\FieldInterface;
+use CraftCms\Cms\FieldLayout\FieldLayout;
+
+interface ImportableFieldLayoutElementInterface
+{
+    /**
+     * Returns an array of fields that can be used for mapping.
+     *
+     * Most native fields are single input text fields, so their column mapping is a single field.
+     * Other fields, such as AddressField are more complex and they have their own implementation of this method.
+     * And custom field instances have their own implementation of this method.
+     *
+     * Additionally, for the CustomField instances,
+     * the underlying Field can implement the getFieldsForImportMapping() method to further customise this.
+     */
+    public function getFieldsForMapping(FieldLayout $fieldLayout, ?FieldInterface $ownerField, mixed $provider, ?string $prefix = null): array;
+
+    /**
+     * Returns whether the element can be used as a match criteria.
+     * For the CustomField instances,
+     * the underlying Field can implement the canBeImportMatchCriteria() method to further customise this.
+     *
+     * It's false by default.
+     */
+    public function canBeMatchCriteria(): bool;
+
+    /**
+     * Returns whether the element's value can be cleared on import when no data is provided or the provided value is empty.
+     * For the CustomField instances,
+     * the underlying Field can implement the canBeImportCleared() method to further customise this.
+     *
+     * It's false by default.
+     */
+    public function canBeCleared(): bool;
+}
diff --git a/src/FieldLayout/LayoutElements/Addresses/AddressField.php b/src/FieldLayout/LayoutElements/Addresses/AddressField.php
index c8200cf44ea..b1f18fd3070 100644
--- a/src/FieldLayout/LayoutElements/Addresses/AddressField.php
+++ b/src/FieldLayout/LayoutElements/Addresses/AddressField.php
@@ -7,11 +7,15 @@
 use CraftCms\Cms\Address\Addresses;
 use CraftCms\Cms\Address\Elements\Address;
 use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\Field\Contracts\FieldInterface;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
+use CraftCms\Cms\FieldLayout\FieldLayout;
 use CraftCms\Cms\FieldLayout\FieldLayoutElementContext;
 use CraftCms\Cms\FieldLayout\LayoutElements\BaseField;
 use CraftCms\Cms\Form\Contracts\Control;
 use CraftCms\Cms\Form\Controls\Address as AddressControl;
 use CraftCms\Cms\Support\Html;
+use CraftCms\Cms\Support\ImportHelper;
 use InvalidArgumentException;
 use Override;
 
@@ -20,7 +24,7 @@
 /**
  * AddressField represents an Address field that can be included within an Address field layout designer.
  */
-class AddressField extends BaseField
+class AddressField extends BaseField implements ImportableFieldLayoutElementInterface
 {
     public function attribute(): string
     {
@@ -111,4 +115,63 @@ public function previewPlaceholderHtml(mixed $value, ?ElementInterface $element)
             'class' => 'no-truncate',
         ]);
     }
+
+    #[Override]
+    public function getFieldsForMapping(FieldLayout $fieldLayout, ?FieldInterface $ownerField, mixed $provider, ?string $prefix = null): array
+    {
+        $cols = [
+            'multiple' => true,
+            'heading' => $this->label(),
+        ];
+
+        $subfields = [];
+
+        // we have to show all the possible address fields as at this stage we have no idea which country we're importing for
+        // and each row could be a different country anyway
+        $parts = [
+            ['attribute' => 'addressLine1', 'label' => t('Address Line 1')],
+            ['attribute' => 'addressLine2', 'label' => t('Address Line 2')],
+            ['attribute' => 'addressLine3', 'label' => t('Address Line 3')],
+            ['attribute' => 'administrativeArea', 'label' => t('Administrative Area')],
+            ['attribute' => 'locality', 'label' => t('Locality')],
+            ['attribute' => 'dependentLocality', 'label' => t('Dependent Locality')],
+            ['attribute' => 'postalCode', 'label' => t('Postal Code')],
+            ['attribute' => 'sortingCode', 'label' => t('Sorting Code')],
+        ];
+
+        foreach ($parts as $part) {
+            [$prefixedHandleForMap, $prefixedHandleForMatchCriteria, $prefixedHandleForClear, $prefixedHandle, $prefixedHandleAsArray] = ImportHelper::getPrefixedHandlesForMapping($part['attribute'], $ownerField, null, $fieldLayout, $provider, $prefix);
+
+            $subfields[] = [
+                'handle' => $part['attribute'],
+                'label' => $part['label'],
+                'prefixedHandleForMap' => $prefixedHandleForMap,
+                'prefixedHandleForMatchCriteria' => $prefixedHandleForMatchCriteria,
+                'prefixedHandleForClear' => $prefixedHandleForClear,
+                'prefixedHandle' => $prefixedHandle,
+                'prefixedHandleAsArray' => $prefixedHandleAsArray,
+                'isContainer' => false,
+                'canBeMatchCriteria' => $part['canBeMatchCriteria'] ?? false,
+                'canBeCleared' => $part['canBeCleared'] ?? true,
+            ];
+        }
+
+        $cols['subfields'] = $subfields;
+
+        return $cols;
+    }
+
+    #[Override]
+    public function canBeMatchCriteria(): bool
+    {
+        // this is taken care of by the getFieldsForMapping() method
+        return false;
+    }
+
+    #[Override]
+    public function canBeCleared(): bool
+    {
+        // this is taken care of by the getFieldsForMapping() method
+        return false;
+    }
 }
diff --git a/src/FieldLayout/LayoutElements/Addresses/CountryCodeField.php b/src/FieldLayout/LayoutElements/Addresses/CountryCodeField.php
index 6c4a6885662..d0a291dc4fe 100644
--- a/src/FieldLayout/LayoutElements/Addresses/CountryCodeField.php
+++ b/src/FieldLayout/LayoutElements/Addresses/CountryCodeField.php
@@ -9,6 +9,8 @@
 use CraftCms\Cms\Address\Elements\Address;
 use CraftCms\Cms\Cp\FormFields;
 use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\FieldLayout\Concerns\ImportableFieldLayoutElement;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
 use CraftCms\Cms\FieldLayout\FieldLayoutElementContext;
 use CraftCms\Cms\FieldLayout\LayoutElements\BaseNativeField;
 use CraftCms\Cms\Form\Contracts\Control;
@@ -21,8 +23,10 @@
 use function CraftCms\Cms\currentUser;
 use function CraftCms\Cms\t;
 
-class CountryCodeField extends BaseNativeField
+class CountryCodeField extends BaseNativeField implements ImportableFieldLayoutElementInterface
 {
+    use ImportableFieldLayoutElement;
+
     #[Override]
     public bool $mandatory = true;
 
diff --git a/src/FieldLayout/LayoutElements/Addresses/LatLongField.php b/src/FieldLayout/LayoutElements/Addresses/LatLongField.php
index 677985218bd..bb54246c5ec 100644
--- a/src/FieldLayout/LayoutElements/Addresses/LatLongField.php
+++ b/src/FieldLayout/LayoutElements/Addresses/LatLongField.php
@@ -7,6 +7,9 @@
 use CraftCms\Cms\Address\Elements\Address;
 use CraftCms\Cms\Cp\FormFields;
 use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\Field\Contracts\FieldInterface;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
+use CraftCms\Cms\FieldLayout\FieldLayout;
 use CraftCms\Cms\FieldLayout\FieldLayoutElementContext;
 use CraftCms\Cms\FieldLayout\LayoutElements\BaseNativeField;
 use CraftCms\Cms\Form\Contracts\Node;
@@ -15,13 +18,14 @@
 use CraftCms\Cms\Form\Nodes\Group;
 use CraftCms\Cms\Support\Arr;
 use CraftCms\Cms\Support\Html;
+use CraftCms\Cms\Support\ImportHelper;
 use InvalidArgumentException;
 use Override;
 
 use function CraftCms\Cms\currentUser;
 use function CraftCms\Cms\t;
 
-class LatLongField extends BaseNativeField
+class LatLongField extends BaseNativeField implements ImportableFieldLayoutElementInterface
 {
     #[Override]
     public string $attribute = 'latLong';
@@ -173,4 +177,55 @@ public function previewPlaceholderHtml(mixed $value, ?ElementInterface $element)
 
         return '61.108, -149.779';
     }
+
+    #[Override]
+    public function getFieldsForMapping(FieldLayout $fieldLayout, ?FieldInterface $ownerField, mixed $provider, ?string $prefix = null): array
+    {
+        $cols = [
+            'multiple' => true,
+            'heading' => $this->label(),
+        ];
+
+        $subfields = [];
+
+        $parts = [
+            ['attribute' => 'latitude', 'label' => t('Latitude'), 'canBeMatchCriteria' => true, 'canBeCleared' => true],
+            ['attribute' => 'longitude', 'label' => t('Longitude'), 'canBeMatchCriteria' => true, 'canBeCleared' => true],
+        ];
+
+        foreach ($parts as $part) {
+            [$prefixedHandleForMap, $prefixedHandleForMatchCriteria, $prefixedHandleForClear, $prefixedHandle, $prefixedHandleAsArray] = ImportHelper::getPrefixedHandlesForMapping($part['attribute'], $ownerField, null, $fieldLayout, $provider, $prefix);
+
+            $subfields[] = [
+                'handle' => $part['attribute'],
+                'label' => $part['label'],
+                'prefixedHandleForMap' => $prefixedHandleForMap,
+                'prefixedHandleForMatchCriteria' => $prefixedHandleForMatchCriteria,
+                'prefixedHandleForClear' => $prefixedHandleForClear,
+                'prefixedHandle' => $prefixedHandle,
+                'prefixedHandleAsArray' => $prefixedHandleAsArray,
+                'isContainer' => false,
+                'canBeMatchCriteria' => $part['canBeMatchCriteria'],
+                'canBeCleared' => $part['canBeCleared'],
+            ];
+        }
+
+        $cols['subfields'] = $subfields;
+
+        return $cols;
+    }
+
+    #[Override]
+    public function canBeMatchCriteria(): bool
+    {
+        // this is taken care of by the getFieldsForMapping() method
+        return false;
+    }
+
+    #[Override]
+    public function canBeCleared(): bool
+    {
+        // this is taken care of by the getFieldsForMapping() method
+        return false;
+    }
 }
diff --git a/src/FieldLayout/LayoutElements/Addresses/OrganizationField.php b/src/FieldLayout/LayoutElements/Addresses/OrganizationField.php
index 20ff65ddc1f..ca26af10f07 100644
--- a/src/FieldLayout/LayoutElements/Addresses/OrganizationField.php
+++ b/src/FieldLayout/LayoutElements/Addresses/OrganizationField.php
@@ -5,14 +5,18 @@
 namespace CraftCms\Cms\FieldLayout\LayoutElements\Addresses;
 
 use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\FieldLayout\Concerns\ImportableFieldLayoutElement;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
 use CraftCms\Cms\FieldLayout\LayoutElements\TextField;
 use CraftCms\Cms\Support\Arr;
 use Override;
 
 use function CraftCms\Cms\t;
 
-class OrganizationField extends TextField
+class OrganizationField extends TextField implements ImportableFieldLayoutElementInterface
 {
+    use ImportableFieldLayoutElement;
+
     #[Override]
     public string $attribute = 'organization';
 
diff --git a/src/FieldLayout/LayoutElements/Addresses/OrganizationTaxIdField.php b/src/FieldLayout/LayoutElements/Addresses/OrganizationTaxIdField.php
index 963d0c0b779..9af43bf7714 100644
--- a/src/FieldLayout/LayoutElements/Addresses/OrganizationTaxIdField.php
+++ b/src/FieldLayout/LayoutElements/Addresses/OrganizationTaxIdField.php
@@ -5,14 +5,18 @@
 namespace CraftCms\Cms\FieldLayout\LayoutElements\Addresses;
 
 use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\FieldLayout\Concerns\ImportableFieldLayoutElement;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
 use CraftCms\Cms\FieldLayout\LayoutElements\TextField;
 use CraftCms\Cms\Support\Arr;
 use Override;
 
 use function CraftCms\Cms\t;
 
-class OrganizationTaxIdField extends TextField
+class OrganizationTaxIdField extends TextField implements ImportableFieldLayoutElementInterface
 {
+    use ImportableFieldLayoutElement;
+
     #[Override]
     public string $attribute = 'organizationTaxId';
 
diff --git a/src/FieldLayout/LayoutElements/Assets/AltField.php b/src/FieldLayout/LayoutElements/Assets/AltField.php
index 02a741dd525..2f07360893c 100644
--- a/src/FieldLayout/LayoutElements/Assets/AltField.php
+++ b/src/FieldLayout/LayoutElements/Assets/AltField.php
@@ -7,6 +7,8 @@
 use CraftCms\Cms\Asset\Elements\Asset;
 use CraftCms\Cms\Element\Contracts\ElementInterface;
 use CraftCms\Cms\Field\Enums\TranslationMethod;
+use CraftCms\Cms\FieldLayout\Concerns\ImportableFieldLayoutElement;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
 use CraftCms\Cms\FieldLayout\LayoutElements\TextareaField;
 use CraftCms\Cms\Support\Arr;
 use CraftCms\Cms\Support\Html;
@@ -15,8 +17,10 @@
 
 use function CraftCms\Cms\t;
 
-class AltField extends TextareaField
+class AltField extends TextareaField implements ImportableFieldLayoutElementInterface
 {
+    use ImportableFieldLayoutElement;
+
     #[Override]
     public string $attribute = 'alt';
 
diff --git a/src/FieldLayout/LayoutElements/CustomField.php b/src/FieldLayout/LayoutElements/CustomField.php
index 6340134b72c..d81e2f3942a 100644
--- a/src/FieldLayout/LayoutElements/CustomField.php
+++ b/src/FieldLayout/LayoutElements/CustomField.php
@@ -8,14 +8,18 @@
 use CraftCms\Cms\Cp\FieldLayoutDesigner\CardDesigner;
 use CraftCms\Cms\Element\Conditions\Contracts\ElementConditionInterface;
 use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\Field\BaseRelationField;
 use CraftCms\Cms\Field\ContentBlock;
 use CraftCms\Cms\Field\Contracts\CrossSiteCopyableFieldInterface;
 use CraftCms\Cms\Field\Contracts\FieldInterface;
+use CraftCms\Cms\Field\Contracts\ImportableElementContainerFieldInterface;
 use CraftCms\Cms\Field\Contracts\PreviewableFieldInterface;
 use CraftCms\Cms\Field\Contracts\ThumbableFieldInterface;
 use CraftCms\Cms\Field\Exceptions\FieldNotFoundException;
 use CraftCms\Cms\Field\FieldContext;
 use CraftCms\Cms\Field\MissingField;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
+use CraftCms\Cms\FieldLayout\FieldLayout;
 use CraftCms\Cms\FieldLayout\FieldLayoutElementContext;
 use CraftCms\Cms\Form\Contracts\Control;
 use CraftCms\Cms\Form\Controls\FieldSelect;
@@ -29,6 +33,7 @@
 use CraftCms\Cms\Support\Arr;
 use CraftCms\Cms\Support\Facades\Fields;
 use CraftCms\Cms\Support\Facades\I18N;
+use CraftCms\Cms\Support\ImportHelper;
 use CraftCms\Cms\Support\Str;
 use CraftCms\Cms\User\Conditions\UserCondition;
 use CraftCms\Cms\User\Elements\User;
@@ -50,7 +55,7 @@
  *
  * @phpstan-consistent-constructor
  */
-class CustomField extends BaseField
+class CustomField extends BaseField implements ImportableFieldLayoutElementInterface
 {
     private static UserCondition $defaultEditCondition;
 
@@ -997,4 +1002,115 @@ protected function actionMenuItems(?ElementInterface $element = null, bool $stat
 
         return $items;
     }
+
+    public function getFieldsForMapping(FieldLayout $fieldLayout, ?FieldInterface $ownerField, mixed $provider, ?string $prefix = null): array
+    {
+        try {
+            // getField() needs to be called before label() or we won't always get the label.
+            $field = $this->getField();
+        } catch (FieldNotFoundException) {
+            // skip silently
+            return [];
+        }
+
+        if (method_exists($field, 'getFieldsForImportMapping')) {
+            return $field->getFieldsForImportMapping();
+        }
+
+        $attribute = $this->attribute();
+        [
+            $prefixedHandleForMap,
+            $prefixedHandleForMatchCriteria,
+            $prefixedHandleForClear,
+            $prefixedHandle,
+            $prefixedHandleAsArray,
+            $prefixedHandleForKeep,
+            $prefixedHandleForKeepFlag,
+        ] = ImportHelper::getPrefixedHandlesForMapping($attribute, $ownerField, $field, $fieldLayout, $provider, $prefix);
+
+        $content = [
+            'handle' => $attribute,
+            'label' => $this->label(),
+            'prefixedHandleForMap' => $prefixedHandleForMap,
+            'prefixedHandleForMatchCriteria' => $prefixedHandleForMatchCriteria,
+            'prefixedHandleForClear' => $prefixedHandleForClear,
+            'prefixedHandle' => $prefixedHandle,
+            'prefixedHandleAsArray' => $prefixedHandleAsArray,
+            'isContainer' => $field instanceof ImportableElementContainerFieldInterface,
+            'canBeMatchCriteria' => $this->canBeMatchCriteria(),
+            'canBeCleared' => $this->canBeCleared(),
+            'canKeepMissingNestedElements' => $this->canKeepMissingNestedElements(),
+        ];
+
+        if ($content['isContainer']) {
+            $content['fieldUid'] = $field->uid;
+            $content['prefixedHandleForKeep'] = $prefixedHandleForKeep;
+            $content['prefixedHandleForKeepFlag'] = $prefixedHandleForKeepFlag;
+        }
+
+        return $content;
+    }
+
+    public function canBeMatchCriteria(): bool
+    {
+        try {
+            // getField() needs to be called before label() or we won't always get the label.
+            $field = $this->getField();
+        } catch (FieldNotFoundException) {
+            // skip silently
+            return false;
+        }
+
+        if ($field instanceof ImportableElementContainerFieldInterface) {
+            return false;
+        }
+
+        if ($field instanceof BaseRelationField) {
+            return false;
+        }
+
+        if (method_exists($field, 'canBeImportMatchCriteria')) {
+            return $field->canBeImportMatchCriteria();
+        }
+
+        return true;
+    }
+
+    public function canBeCleared(): bool
+    {
+        try {
+            // getField() needs to be called before label() or we won't always get the label.
+            $field = $this->getField();
+        } catch (FieldNotFoundException) {
+            // skip silently
+            return false;
+        }
+
+        if ($field instanceof ImportableElementContainerFieldInterface) {
+            return false;
+        }
+
+        if (method_exists($field, 'canBeImportCleared')) {
+            return $field->canBeImportCleared();
+        }
+
+        return true;
+    }
+
+    /**
+     * Returns whether this field supports keeping nested elements missing from imported data.
+     * Only container fields (Matrix, Addresses) that declare support for it do.
+     */
+    public function canKeepMissingNestedElements(): bool
+    {
+        try {
+            // getField() needs to be called before label() or we won't always get the label.
+            $field = $this->getField();
+        } catch (FieldNotFoundException) {
+            // skip silently
+            return false;
+        }
+
+        return $field instanceof ImportableElementContainerFieldInterface && $field->canKeepMissingNestedElements();
+    }
 }
diff --git a/src/FieldLayout/LayoutElements/FullNameField.php b/src/FieldLayout/LayoutElements/FullNameField.php
index be3841a75b0..ae3e9d106aa 100644
--- a/src/FieldLayout/LayoutElements/FullNameField.php
+++ b/src/FieldLayout/LayoutElements/FullNameField.php
@@ -6,6 +6,8 @@
 
 use CraftCms\Cms\Cms;
 use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\FieldLayout\Concerns\ImportableFieldLayoutElement;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
 use CraftCms\Cms\FieldLayout\FieldLayoutElementContext;
 use CraftCms\Cms\Form\Contracts\Node;
 use CraftCms\Cms\Form\Controls\Text;
@@ -19,8 +21,10 @@
 
 use function CraftCms\Cms\t;
 
-class FullNameField extends TextField
+class FullNameField extends TextField implements ImportableFieldLayoutElementInterface
 {
+    use ImportableFieldLayoutElement;
+
     #[Override]
     public string $attribute = 'fullName';
 
diff --git a/src/FieldLayout/LayoutElements/TitleField.php b/src/FieldLayout/LayoutElements/TitleField.php
index 1eac42fff70..88e01319b7b 100644
--- a/src/FieldLayout/LayoutElements/TitleField.php
+++ b/src/FieldLayout/LayoutElements/TitleField.php
@@ -5,14 +5,18 @@
 namespace CraftCms\Cms\FieldLayout\LayoutElements;
 
 use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\FieldLayout\Concerns\ImportableFieldLayoutElement;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
 use CraftCms\Cms\Support\Arr;
 use Override;
 
 use function CraftCms\Cms\currentUser;
 use function CraftCms\Cms\t;
 
-class TitleField extends TextField
+class TitleField extends TextField implements ImportableFieldLayoutElementInterface
 {
+    use ImportableFieldLayoutElement;
+
     #[Override]
     public bool $mandatory = true;
 
@@ -80,4 +84,16 @@ protected function actionMenuItems(?ElementInterface $element = null, bool $stat
 
         return $items;
     }
+
+    #[Override]
+    public function canBeMatchCriteria(): bool
+    {
+        return true;
+    }
+
+    #[Override]
+    public function canBeCleared(): bool
+    {
+        return true;
+    }
 }
diff --git a/src/FieldLayout/LayoutElements/Users/AffiliatedSiteField.php b/src/FieldLayout/LayoutElements/Users/AffiliatedSiteField.php
index 2c33cd4cdc3..4dd2f34f04e 100644
--- a/src/FieldLayout/LayoutElements/Users/AffiliatedSiteField.php
+++ b/src/FieldLayout/LayoutElements/Users/AffiliatedSiteField.php
@@ -6,6 +6,8 @@
 
 use CraftCms\Cms\Cp\FormFields;
 use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\FieldLayout\Concerns\ImportableFieldLayoutElement;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
 use CraftCms\Cms\FieldLayout\FieldLayoutElementContext;
 use CraftCms\Cms\FieldLayout\LayoutElements\BaseNativeField;
 use CraftCms\Cms\Form\Contracts\Control;
@@ -20,8 +22,10 @@
 use function CraftCms\Cms\currentUser;
 use function CraftCms\Cms\t;
 
-class AffiliatedSiteField extends BaseNativeField
+class AffiliatedSiteField extends BaseNativeField implements ImportableFieldLayoutElementInterface
 {
+    use ImportableFieldLayoutElement;
+
     #[Override]
     public string $attribute = 'affiliatedSiteId';
 
diff --git a/src/FieldLayout/LayoutElements/Users/EmailField.php b/src/FieldLayout/LayoutElements/Users/EmailField.php
index 3287b6a394f..93d3948fe51 100644
--- a/src/FieldLayout/LayoutElements/Users/EmailField.php
+++ b/src/FieldLayout/LayoutElements/Users/EmailField.php
@@ -6,6 +6,8 @@
 
 use CraftCms\Cms\Edition;
 use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\FieldLayout\Concerns\ImportableFieldLayoutElement;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
 use CraftCms\Cms\FieldLayout\FieldLayoutElementContext;
 use CraftCms\Cms\FieldLayout\LayoutElements\TextField;
 use CraftCms\Cms\Form\Contracts\Control;
@@ -20,8 +22,10 @@
 
 use function CraftCms\Cms\t;
 
-class EmailField extends TextField
+class EmailField extends TextField implements ImportableFieldLayoutElementInterface
 {
+    use ImportableFieldLayoutElement;
+
     #[Override]
     public bool $mandatory = true;
 
@@ -148,4 +152,10 @@ protected function fieldErrors(?ElementInterface $element = null): array
 
         return array_merge($element->errors()->get('email'), $element->errors()->get('unverifiedEmail'));
     }
+
+    #[Override]
+    public function canBeMatchCriteria(): bool
+    {
+        return true;
+    }
 }
diff --git a/src/FieldLayout/LayoutElements/Users/UsernameField.php b/src/FieldLayout/LayoutElements/Users/UsernameField.php
index f1948243c5d..ff805a8fccb 100644
--- a/src/FieldLayout/LayoutElements/Users/UsernameField.php
+++ b/src/FieldLayout/LayoutElements/Users/UsernameField.php
@@ -6,6 +6,8 @@
 
 use CraftCms\Cms\Cms;
 use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\FieldLayout\Concerns\ImportableFieldLayoutElement;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
 use CraftCms\Cms\FieldLayout\FieldLayoutElementContext;
 use CraftCms\Cms\FieldLayout\LayoutElements\TextField;
 use CraftCms\Cms\Form\Contracts\Control;
@@ -16,8 +18,10 @@
 
 use function CraftCms\Cms\t;
 
-class UsernameField extends TextField
+class UsernameField extends TextField implements ImportableFieldLayoutElementInterface
 {
+    use ImportableFieldLayoutElement;
+
     #[Override]
     public bool $mandatory = true;
 
@@ -89,4 +93,10 @@ protected function inputAttributes(?ElementInterface $element = null, bool $stat
             'autocomplete' => $element->getIsCurrent() ? 'username' : 'off',
         ];
     }
+
+    #[Override]
+    public function canBeMatchCriteria(): bool
+    {
+        return true;
+    }
 }
diff --git a/src/Gql/Resolvers/Mutations/Asset.php b/src/Gql/Resolvers/Mutations/Asset.php
index fe7d9d6874e..2ed9fa57d43 100644
--- a/src/Gql/Resolvers/Mutations/Asset.php
+++ b/src/Gql/Resolvers/Mutations/Asset.php
@@ -20,7 +20,6 @@
 use CraftCms\Cms\Support\Facades\Folders;
 use CraftCms\Cms\Support\File;
 use CraftCms\Cms\Support\Url;
-use CraftCms\UrlValidator\UrlValidationException;
 use CraftCms\UrlValidator\UrlValidator;
 use GraphQL\Error\Error;
 use GraphQL\Error\UserError;
@@ -233,17 +232,8 @@ protected function handleUpload(AssetElement $asset, array $fileInformation): bo
                 ]));
             }
 
-            // Validate the URL and resolve it to a known-good set of IPs *before*
-            // opening any connection (guards against SSRF + DNS rebinding).
-            try {
-                $ips = $this->urlValidator()->validate($url);
-            } catch (UrlValidationException $e) {
-                throw new UserError("$url is invalid.", previous: $e);
-            }
-
-            // Download the file, pinning the connection to the validated IPs
             $tempPath = AssetsHelper::tempFilePath($extension);
-            $this->downloadUrl($url, $ips, $tempPath);
+            AssetsHelper::downloadUrl($url, $tempPath);
         }
 
         if (! $tempPath || ! $filename) {
diff --git a/src/Http/Controllers/Import/ImportController.php b/src/Http/Controllers/Import/ImportController.php
new file mode 100644
index 00000000000..b5484bd4530
--- /dev/null
+++ b/src/Http/Controllers/Import/ImportController.php
@@ -0,0 +1,495 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Http\Controllers\Import;
+
+use CraftCms\Cms\Component\Contracts\Chippable;
+use CraftCms\Cms\Config\GeneralConfig;
+use CraftCms\Cms\Element\Import\ElementImporter;
+use CraftCms\Cms\Field\Contracts\FieldInterface;
+use CraftCms\Cms\Field\Contracts\ImportableElementContainerFieldInterface;
+use CraftCms\Cms\Field\Fields;
+use CraftCms\Cms\Form\FormResolver;
+use CraftCms\Cms\Http\RespondsWithFlash;
+use CraftCms\Cms\Http\Responses\CpScreenResponse;
+use CraftCms\Cms\Http\ViewModels\ImportEditViewModel;
+use CraftCms\Cms\Http\ViewModels\ImportMapViewModel;
+use CraftCms\Cms\Http\ViewModels\ImportStepFormViewModel;
+use CraftCms\Cms\Import\Data\Import as ImportData;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use CraftCms\Cms\Import\Imports;
+use CraftCms\Cms\Support\Arr;
+use CraftCms\Cms\Support\Facades\ImportLog;
+use CraftCms\Cms\Support\ImportHelper;
+use CraftCms\Cms\Support\Url;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Crypt;
+use Illuminate\Validation\Rule;
+use Illuminate\Validation\ValidationException;
+use Inertia\Inertia;
+use Inertia\Response as InertiaResponse;
+use Symfony\Component\HttpFoundation\Response;
+use Throwable;
+
+use function CraftCms\Cms\t;
+
+class ImportController
+{
+    use RespondsWithFlash;
+
+    private bool $readOnly;
+
+    public function __construct(
+        private Request $request,
+        GeneralConfig $generalConfig,
+        private readonly Import $importService,
+        private readonly Imports $importsService,
+        private readonly Fields $fieldsService,
+    ) {
+        $this->readOnly = ! $generalConfig->allowAdminChanges;
+    }
+
+    public function index(): InertiaResponse
+    {
+        $currentUser = $this->request->craftUser();
+
+        return Inertia::render('import/Index', [
+            'title' => t('Imports'),
+            'crumbs' => [
+                ['label' => t('Import')],
+            ],
+            'readOnly' => $this->readOnly,
+            'canSave' => ! $this->readOnly && (bool) $currentUser?->can('saveImports'),
+            'canDelete' => ! $this->readOnly && (bool) $currentUser?->can('deleteImports'),
+            'canTrigger' => (bool) $currentUser?->can('triggerImports'),
+            'editableImports' => $this->importsService->getEditableImports()
+                ->map(fn (ImportData $import) => $this->importRow($import, true))
+                ->values()
+                ->all(),
+            'nonEditableImports' => $this->importsService->getNonEditableImports()
+                ->map(fn (ImportData $import) => $this->importRow($import, false))
+                ->values()
+                ->all(),
+        ]);
+    }
+
+    /** @return array<string, mixed> */
+    private function importRow(ImportData $import, bool $editable): array
+    {
+        return [
+            'uid' => $import->uid,
+            'name' => $import->name,
+            'handle' => $import->handle,
+            'description' => $import->description,
+            'stepCount' => count($import->steps ?? []),
+            'stepLabels' => array_map(
+                $this->stepTypeLabel(...),
+                $import->steps ?? [],
+            ),
+            'editUrl' => $editable ? Url::cpUrl('import/'.$import->handle) : null,
+        ];
+    }
+
+    private function stepTypeLabel(BaseImporter $step): string
+    {
+        $type = $step::class ?? null;
+
+        return is_string($type) && class_exists($type) ? $type::displayName() : t('Unknown importer');
+    }
+
+    public function create(): CpScreenResponse
+    {
+        $old = $this->request->session()->get('import');
+
+        return $this->cpScreenResponse(! empty($old) ? new ImportData($old) : new ImportData);
+    }
+
+    public function edit(?ImportData $import = null, ?string $handle = null): CpScreenResponse
+    {
+        $handle ??= $import->handle ?? $this->request->input('handle');
+
+        if (is_null($handle)) {
+            return $this->create();
+        }
+
+        abort_if(is_null($found = $this->importsService->getImportByHandle($handle)), 404, 'Import not found');
+        abort_if(! $found->isEditable(), 400, "This import is not editable: $found->handle");
+
+        $old = $this->request->session()->get('import');
+        if (! empty($old)) {
+            $import = new ImportData($old);
+        }
+
+        $import ??= $found;
+
+        return $this->cpScreenResponse($import);
+    }
+
+    public function store(): Response
+    {
+        $importUid = $this->request->input('uid');
+
+        $this->request->validate([
+            'uid' => ['nullable', 'string', 'max:36'],
+        ]);
+
+        if ($importUid) {
+            abort_if(is_null($import = $this->importsService->getImportByUid($importUid, true)), 400, "Invalid import UID: $importUid");
+        } else {
+            $import = new ImportData(['editable' => true]);
+        }
+
+        $import->name($this->request->input('name', $import->name));
+        $import->handle($this->request->input('handle', $import->handle));
+        $import->description($this->request->input('description', $import->description));
+        $import->steps($this->request->input('steps', $import->steps ?? []));
+
+        if (! $this->importsService->saveImport($import)) {
+            return $this->asModelFailure($import, t('Couldn’t save import.'), 'import');
+        }
+
+        return $this->asModelSuccess(
+            $import,
+            t('Import saved.'),
+            'import',
+        );
+    }
+
+    /**
+     * Returns the form payload for a single step, built from the posted draft step rather than
+     * anything persisted, so a step can be configured before the import is ever saved.
+     */
+    public function stepSettings(): JsonResponse
+    {
+        $importer = $this->draftImporter(requireType: false);
+        $batchSize = $this->request->input('step.batchSize');
+
+        return new JsonResponse([
+            'form' => new ImportStepFormViewModel(
+                $importer,
+                $this->importService,
+                app(FormResolver::class),
+                $this->readOnly,
+                (bool) $this->request->craftUser()?->can('saveImports'),
+                $batchSize === null || $batchSize === '' ? null : (int) $batchSize,
+            )->form(),
+            'canMap' => $this->canMapStep($importer),
+        ]);
+    }
+
+    /**
+     * Returns whether a step has settled enough for its data to be mapped.
+     *
+     * An element importer resolves its field layout from whatever it's importing into — an
+     * entry type, a volume — so until that's chosen there are no destination columns to map
+     * onto, and without a valid file there are no incoming ones either.
+     *
+     * @param  BaseImporter|null  $importer  The step's importer, or null when it has no type yet.
+     */
+    private function canMapStep(?BaseImporter $importer): bool
+    {
+        if ($importer === null || ! BaseImporter::isFileValid($importer->file)) {
+            return false;
+        }
+
+        return ! $importer instanceof ElementImporter || ! empty($importer->fieldLayout);
+    }
+
+    /**
+     * Validates a single draft step, for the slideout to check before it lets the step close.
+     */
+    public function validateStep(): JsonResponse
+    {
+        $data = $this->request->validate([
+            'step' => ['required', 'array'],
+            'step.uid' => ['nullable', 'string', 'max:36'],
+            'step.type' => ['nullable', 'string', Rule::in($this->importService->getAllImporterTypes())],
+            'step.file' => ['nullable', 'string'],
+            'step.transformer' => ['nullable', 'string'],
+            'step.batchSize' => ['nullable', 'integer'],
+            'step.settings' => ['nullable', 'array'],
+        ]);
+
+        $step = $data['step'];
+        $step['settings'] = ImportHelper::decodeRecursive($step['settings'] ?? []);
+
+        $errors = ImportData::stepErrors($step);
+
+        if (! empty($errors)) {
+            throw ValidationException::withMessages($errors);
+        }
+
+        return new JsonResponse(['success' => true]);
+    }
+
+    /**
+     * Returns the mapping structure for a draft step: its destination columns, the source
+     * columns read from its file, and a best guess at a mapping between the two.
+     */
+    public function stepMapping(): JsonResponse
+    {
+        $importer = $this->draftImporter();
+
+        // the panel's button is hidden until this passes, so reaching here means the step
+        // changed between the last refresh and the click
+        if (! $this->canMapStep($importer)) {
+            return $this->asJsonSuccess(null, [
+                'available' => false,
+                'message' => t('Choose what this step imports into before mapping its data.'),
+            ]);
+        }
+
+        $destinationCols = $importer->getDestinationCols();
+        $sourceDataCols = $importer->getSourceDataCols();
+
+        return $this->asJsonSuccess(null, [
+            'available' => true,
+            'destinationCols' => $destinationCols,
+            'sourceDataCols' => $sourceDataCols,
+            'values' => new ImportMapViewModel($importer)->values(),
+            'suggestions' => ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, $importer->map),
+        ]);
+    }
+
+    /**
+     * Returns the destination columns for a container field or property, for the nested
+     * mapping panel.
+     *
+     * Only the structure: the panel is opened around client state the mapping panel already
+     * holds, so there is nothing to relay back and forth.
+     */
+    public function nestedMappingCols(): JsonResponse
+    {
+        $importer = $this->draftImporter();
+
+        $fieldUid = $this->request->input('fieldUid');
+        $field = ! empty($fieldUid) ? $this->fieldsService->getFieldByUid($fieldUid) : null;
+
+        $fieldHandle = $this->request->input('fieldHandle');
+        $fieldIsProperty = $this->request->boolean('fieldIsProperty');
+
+        $fieldName = $field instanceof FieldInterface ? $field->name : $fieldHandle;
+        $groups = [];
+
+        if ($field instanceof ImportableElementContainerFieldInterface) {
+            foreach ($field->getFieldLayoutProviders() as $provider) {
+                $groups[] = [
+                    'providerName' => $provider instanceof Chippable ? $provider->getUiLabel() : $provider->getHandle(),
+                    'destinationCols' => ImportHelper::getDestinationColsForFieldLayout(
+                        $provider->getFieldLayout(),
+                        $field,
+                        $provider,
+                        $fieldHandle,
+                    ),
+                ];
+            }
+        }
+
+        // if it's a property, and the target element type has the method that takes care of
+        // importing into that property, use that method
+        $targetClass = $importer::targetClass();
+        if (! $field && $fieldIsProperty && method_exists($targetClass, 'getDestinationColsForProperty')) {
+            $groups[] = [
+                'providerName' => null,
+                'destinationCols' => $targetClass::getDestinationColsForProperty($importer, $fieldHandle),
+            ];
+        }
+
+        $sourceDataCols = $importer->getSourceDataCols();
+        $allDestinationCols = array_merge(...array_column($groups, 'destinationCols'));
+
+        // the top-level columns are thrown in so a heading that exactly matches one of them
+        // isn't also guessed at in here, then the guesses are narrowed back down to this panel
+        $suggestions = ImportHelper::suggestMapValues(
+            array_merge($importer->getDestinationCols(), $allDestinationCols),
+            $sourceDataCols,
+            $importer->map ?? [],
+        );
+        $rootPath = implode('.', Arr::bracketsToArray((string) $fieldHandle));
+
+        return $this->asJsonSuccess(null, [
+            'title' => t('Edit map for {fieldName}', ['fieldName' => $fieldName]),
+            'fieldName' => $fieldName,
+            'groups' => $groups,
+            'sourceDataCols' => $sourceDataCols,
+            'suggestions' => self::subtree($suggestions, $rootPath),
+        ]);
+    }
+
+    /**
+     * Builds a transient importer from the posted draft step. Nothing is looked up in the
+     * database, so this works for a step that has never been saved.
+     *
+     * @param  bool  $requireType  Whether the step must name an importer type.
+     */
+    private function draftImporter(bool $requireType = true): ?BaseImporter
+    {
+        $data = $this->request->validate([
+            'step' => ['required', 'array'],
+            'step.uid' => ['nullable', 'string', 'max:36'],
+            'step.type' => [$requireType ? 'required' : 'nullable', 'nullable', 'string', Rule::in($this->importService->getAllImporterTypes())],
+            'step.file' => ['nullable', 'string'],
+            'step.transformer' => ['nullable', 'string'],
+            'step.batchSize' => ['nullable', 'integer'],
+            'step.settings' => ['nullable', 'array'],
+        ]);
+
+        $step = $data['step'];
+
+        if (empty($step['type'])) {
+            return null;
+        }
+
+        $step['settings'] = ImportHelper::decodeRecursive($step['settings'] ?? []);
+
+        return Imports::createImporter($step);
+    }
+
+    /**
+     * Returns a tree holding only `$path`'s branch of `$tree`, still rooted at the top level.
+     */
+    private static function subtree(array $tree, string $path): array
+    {
+        $branch = Arr::get($tree, $path);
+
+        if ($branch === null) {
+            return [];
+        }
+
+        $subtree = [];
+        Arr::set($subtree, $path, $branch);
+
+        return $subtree;
+    }
+
+    public function duplicate(): Response
+    {
+        $uid = $this->request->input('uid');
+
+        if (! $uid) {
+            throw ValidationException::withMessages([
+                'id' => t('uid is required.'),
+            ]);
+        }
+
+        $import = $this->importsService->getImportByUid($uid);
+
+        abort_if(is_null($import), 404, "Invalid import UID: $uid");
+        abort_if(! $import->isEditable(), 400, "This import is not editable, so it can’t be duplicated via the Control Panel: $uid");
+
+        $this->importsService->duplicateImport($import);
+
+        return $this->asSuccess(t('“{name}” duplicated.', [
+            'name' => $import->name,
+        ]));
+    }
+
+    public function destroy(): Response
+    {
+        $uid = $this->request->input('uid');
+
+        if (! $uid) {
+            throw ValidationException::withMessages([
+                'id' => t('uid is required.'),
+            ]);
+        }
+
+        $import = $this->importsService->getImportByUid($uid);
+
+        abort_if(is_null($import), 404, "Invalid import UID: $uid");
+        abort_if(! $import->isEditable(), 400, "This import is not editable, so it can’t be deleted via the Control Panel: $uid");
+
+        $this->importsService->deleteImport($import);
+
+        return $this->asSuccess(t('“{name}” deleted.', [
+            'name' => $import->name,
+        ]));
+    }
+
+    public function run(): Response
+    {
+        $uid = $this->request->input('uid');
+        $handle = $this->request->input('handle');
+
+        abort_if(is_null($uid) && is_null($handle), 400, 'An import uid or handle is required.');
+
+        $import = $uid !== null
+            ? $this->importsService->getImportByUid($uid)
+            : $this->importsService->getImportByHandle($handle);
+
+        abort_if(is_null($import), 400, 'Import not found.');
+
+        try {
+            $this->importService->dispatchImport($import);
+        } catch (Throwable $e) {
+            ImportLog::warning("Import failed: {$e->getMessage()}");
+
+            return $this->asFailure(t('Import could not be started.'));
+        }
+
+        return $this->asSuccess(t('Import started'));
+    }
+
+    private function cpScreenResponse(ImportData $import): CpScreenResponse
+    {
+        $currentUser = $this->request->craftUser();
+        $canSave = (bool) $currentUser?->can('saveImports');
+        $editable = ! $this->readOnly && $canSave;
+
+        return new CpScreenResponse()
+            ->title(! isset($import->uid) ? t('Create a new import') : t('Edit {name} import', ['name' => $import->name]))
+            ->addCrumb(t('Import'), 'import')
+            ->formAttributes(['action' => action([self::class, 'store'])])
+            ->inertiaPage('import/Edit', new ImportEditViewModel(
+                $import,
+                $this->importService,
+                app(FormResolver::class),
+                $this->readOnly,
+                $canSave,
+            ))
+            ->when(
+                $editable,
+                callback: function (CpScreenResponse $response) use ($import) {
+                    $response
+                        ->action('import/save')
+                        ->redirectUrl('import/{handle}');
+
+                    if ($import->isEditable()) {
+                        $response->addAltAction(t('Delete'), [
+                            'variant' => 'danger',
+                            'action' => [
+                                'type' => 'http',
+                                'method' => 'DELETE',
+                                'url' => action([self::class, 'destroy']),
+                                'body' => [
+                                    'uid' => $import->uid,
+                                    'redirect' => Crypt::encrypt(action([self::class, 'index'])),
+                                ],
+                                'confirm' => t('Are you sure you want to delete “{name}”?', [
+                                    'name' => $import->name,
+                                ]),
+                            ],
+                        ]);
+
+                        $response->addAltAction(t('Run this import'), [
+                            'action' => [
+                                'type' => 'http',
+                                'method' => 'POST',
+                                'url' => action([self::class, 'run']),
+                                'body' => [
+                                    'uid' => $import->uid,
+                                    'redirect' => Crypt::encrypt(action([self::class, 'index'])),
+                                ],
+                                'confirm' => t('Are you sure you want to run “{name}”?', [
+                                    'name' => $import->name,
+                                ]),
+                            ],
+                        ]);
+                    }
+                },
+            );
+    }
+}
diff --git a/src/Http/ViewModels/ImportEditViewModel.php b/src/Http/ViewModels/ImportEditViewModel.php
new file mode 100644
index 00000000000..8e82a70b3b4
--- /dev/null
+++ b/src/Http/ViewModels/ImportEditViewModel.php
@@ -0,0 +1,125 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Http\ViewModels;
+
+use CraftCms\Cms\Form\Controls\Handle;
+use CraftCms\Cms\Form\Controls\Text;
+use CraftCms\Cms\Form\Controls\Textarea;
+use CraftCms\Cms\Form\Enums\ControlMode;
+use CraftCms\Cms\Form\Form;
+use CraftCms\Cms\Form\FormContext;
+use CraftCms\Cms\Form\FormPayload;
+use CraftCms\Cms\Form\FormResolver;
+use CraftCms\Cms\Form\Nodes\Field as FormField;
+use CraftCms\Cms\Form\Nodes\HiddenField;
+use CraftCms\Cms\Http\Controllers\Import\ImportController;
+use CraftCms\Cms\Import\Data\Import as ImportData;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+
+use function CraftCms\Cms\t;
+
+class ImportEditViewModel extends ViewModel
+{
+    public function __construct(
+        private readonly ImportData $import,
+        private readonly Import $importService,
+        private readonly FormResolver $formResolver,
+        private readonly bool $readOnly = false,
+        private readonly bool $canSave = true,
+    ) {}
+
+    public function form(): FormPayload
+    {
+        $mode = $this->readOnly || ! $this->canSave ? ControlMode::ReadOnly : ControlMode::Editable;
+
+        $handle = Handle::make('handle');
+        if (! $this->import->uid) {
+            $handle->source('name');
+        }
+
+        return $this->formResolver->resolve(Form::make([
+            HiddenField::make('uid'),
+            FormField::make(t('Name'), Text::make('name')->autofocus())
+                ->instructions(t('What this import will be called in the control panel.'))
+                ->required(),
+            FormField::make(t('Handle'), $handle)
+                ->instructions(t('How you’ll refer to this import in the code.'))
+                ->required(),
+            FormField::make(t('Description'), Textarea::make('description'))
+                ->instructions(t('A description of what this import is for.')),
+        ]), new FormContext(
+            values: [
+                'uid' => $this->import->uid,
+                'name' => $this->import->name,
+                'handle' => $this->import->handle,
+                'description' => $this->import->description,
+            ],
+            mode: $mode,
+        ));
+    }
+
+    /**
+     * The import's steps, as the step list on the edit screen holds them.
+     *
+     * @return list<array<string, mixed>>
+     */
+    public function steps(): array
+    {
+        return $this->import->serializeSteps() ?? [];
+    }
+
+    /**
+     * The importer types a step can be, for the step slideout's type select.
+     *
+     * @return list<array{value: class-string<BaseImporter>, label: string}>
+     */
+    public function importerTypes(): array
+    {
+        return array_map(fn (string $type): array => [
+            'label' => $type::displayName(),
+            'value' => $type,
+        ], $this->importService->getAllImporterTypes());
+    }
+
+    /** @return array{method: 'post', url: string} */
+    public function submit(): array
+    {
+        return [
+            'method' => 'post',
+            'url' => action([ImportController::class, 'store']),
+        ];
+    }
+
+    public function stepSettingsUrl(): ?string
+    {
+        return $this->readOnly ? null : action([ImportController::class, 'stepSettings']);
+    }
+
+    public function validateStepUrl(): ?string
+    {
+        return $this->readOnly ? null : action([ImportController::class, 'validateStep']);
+    }
+
+    public function stepMappingUrl(): string
+    {
+        return action([ImportController::class, 'stepMapping']);
+    }
+
+    public function nestedColsUrl(): string
+    {
+        return action([ImportController::class, 'nestedMappingCols']);
+    }
+
+    public function readOnly(): bool
+    {
+        return $this->readOnly;
+    }
+
+    public function canSave(): bool
+    {
+        return $this->canSave;
+    }
+}
diff --git a/src/Http/ViewModels/ImportMapViewModel.php b/src/Http/ViewModels/ImportMapViewModel.php
new file mode 100644
index 00000000000..e4f5bcc2203
--- /dev/null
+++ b/src/Http/ViewModels/ImportMapViewModel.php
@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Http\ViewModels;
+
+use CraftCms\Cms\Element\Import\ElementImporter;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use CraftCms\Cms\Support\ImportHelper;
+
+class ImportMapViewModel extends ViewModel
+{
+    private ?array $destinationCols = null;
+
+    private ?array $sourceDataCols = null;
+
+    public function __construct(
+        private readonly BaseImporter $importer,
+        private readonly bool $readOnly = false,
+        private readonly bool $canSave = true,
+    ) {}
+
+    /** @return array{uid: string|null, file: string|null} */
+    public function step(): array
+    {
+        return [
+            'uid' => $this->importer->uid,
+            'file' => $this->importer->file,
+        ];
+    }
+
+    /** @return array<int, array<string, mixed>> */
+    public function destinationCols(): array
+    {
+        return $this->destinationCols ??= $this->importer->getDestinationCols();
+    }
+
+    /** @return array<array-key, mixed> */
+    public function sourceDataCols(): array
+    {
+        // memoized alongside destinationCols(): both are asked for twice per page — once for
+        // the screen, once to work out the suggestions — and this one parses the data file
+        return $this->sourceDataCols ??= $this->importer->getSourceDataCols();
+    }
+
+    /**
+     * The mapping state the page edits, as nested objects keyed the same way as each
+     * column's `prefixedHandleAsArray`.
+     *
+     * @return array<string, array<array-key, mixed>>
+     */
+    public function values(): array
+    {
+        return [
+            'map' => $this->importer->map,
+            'matchCriteria' => $this->importer->matchCriteria ?? [],
+            'clearableItems' => $this->importer->clearableItems ?? [],
+            'keepMissingNestedElements' => $this->importer instanceof ElementImporter
+                ? $this->importer->keepMissingNestedElements ?? []
+                : [],
+        ];
+    }
+
+    /**
+     * A best guess at a source column for each leaf the map doesn't already have a value at,
+     * keyed the same way as the map. The screen fills them in and flags them as guesses.
+     *
+     * @return array<array-key, mixed>
+     */
+    public function suggestions(): array
+    {
+        return ImportHelper::suggestMapValues(
+            $this->destinationCols(),
+            $this->sourceDataCols(),
+            $this->importer->map,
+        );
+    }
+
+    public function readOnly(): bool
+    {
+        return $this->readOnly;
+    }
+
+    public function canSave(): bool
+    {
+        return $this->canSave;
+    }
+}
diff --git a/src/Http/ViewModels/ImportStepFormViewModel.php b/src/Http/ViewModels/ImportStepFormViewModel.php
new file mode 100644
index 00000000000..0b5cc492d34
--- /dev/null
+++ b/src/Http/ViewModels/ImportStepFormViewModel.php
@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Http\ViewModels;
+
+use CraftCms\Cms\Element\Import\ElementTransformer;
+use CraftCms\Cms\Form\Controls\Choice;
+use CraftCms\Cms\Form\Controls\Number;
+use CraftCms\Cms\Form\Controls\Text;
+use CraftCms\Cms\Form\Enums\ControlMode;
+use CraftCms\Cms\Form\Form;
+use CraftCms\Cms\Form\FormContext;
+use CraftCms\Cms\Form\FormPayload;
+use CraftCms\Cms\Form\FormResolver;
+use CraftCms\Cms\Form\Nodes\Field as FormField;
+use CraftCms\Cms\Form\Nodes\Group;
+use CraftCms\Cms\Form\Nodes\HiddenField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+
+use function CraftCms\Cms\t;
+
+/**
+ * The form shown in an import step's slideout: the importer type, the data it reads, and
+ * whatever settings that importer type asks for.
+ */
+class ImportStepFormViewModel extends ViewModel
+{
+    public function __construct(
+        private readonly ?BaseImporter $importer,
+        private readonly Import $importService,
+        private readonly FormResolver $formResolver,
+        private readonly bool $readOnly = false,
+        private readonly bool $canSave = true,
+        private readonly ?int $batchSize = null,
+    ) {}
+
+    public function form(): FormPayload
+    {
+        $hasType = $this->importer !== null;
+        $mode = $this->readOnly || ! $this->canSave ? ControlMode::ReadOnly : ControlMode::Editable;
+        $refreshable = ! $this->readOnly;
+
+        $form = $this->formResolver->resolve(Form::make([
+            HiddenField::make('uid'),
+            FormField::make(t('Importer Type'), Choice::make('type')
+                ->options($this->importerTypeOptions())
+                ->placeholder(t('Please select'))
+                ->reactive())
+                ->instructions(t('What this step imports.')),
+            FormField::make(t('Data File'), Text::make('file')
+                ->placeholder('@root/resources/my-data.json')
+                ->reactive())
+                ->instructions(t('The @root-relative path to the file containing the data you want this step to import.'))
+                ->required()
+                ->visible($hasType),
+            FormField::make(t('Transformer'), Text::make('transformer')
+                ->value($this->importer?->usesDefaultTransformer() ? null : $this->importer?->transformerAsString())
+                ->placeholder(ElementTransformer::class))
+                ->instructions(t('The fully qualified class name of the transformer you’d like to use.'))
+                ->visible($hasType),
+            FormField::make(t('Custom batch size'), Number::make('batchSize'))
+                ->instructions(t('By default, this step will be run in batches containing up to 100 items. You can provide a different size, if you wish. Set to 0 to disable batching.'))
+                ->visible($hasType),
+        ]), new FormContext(
+            values: [
+                'uid' => $this->importer?->uid,
+                'type' => $this->importer !== null ? $this->importer::class : null,
+                'file' => $this->importer?->file,
+                'batchSize' => $this->batchSize,
+            ],
+            mode: $mode,
+            refreshable: $refreshable,
+        ));
+
+        $settingsContext = new FormContext(namespace: 'settings', mode: $mode, refreshable: $refreshable);
+        $settingsForm = $this->importer?->settingsForm($settingsContext);
+        $settingsNodes = $settingsForm['nodes'] ?? null;
+        $settingsContext = $settingsForm['context'] ?? $settingsContext;
+
+        $settings = $this->formResolver->resolve(
+            empty($settingsNodes)
+                ? Form::make()
+                : Form::make([
+                    Group::make('import-step-settings', $settingsNodes)->dependsOn('type'),
+                ]),
+            $settingsContext,
+        );
+
+        return new FormPayload(
+            scope: [],
+            refreshable: $refreshable,
+            nodes: [...$form->nodes, ...$settings->nodes],
+            values: [...$form->values, ...$settings->values],
+            errors: [...$form->errors, ...$settings->errors],
+            globalErrors: [...$form->globalErrors, ...$settings->globalErrors],
+        );
+    }
+
+    /** @return list<array{value: class-string<BaseImporter>, label: string}> */
+    private function importerTypeOptions(): array
+    {
+        return array_map(fn (string $type): array => [
+            'label' => $type::displayName(),
+            'value' => $type,
+        ], $this->importService->getAllImporterTypes());
+    }
+}
diff --git a/src/Import/Commands/Import.php b/src/Import/Commands/Import.php
new file mode 100644
index 00000000000..1d3d4a0b3ef
--- /dev/null
+++ b/src/Import/Commands/Import.php
@@ -0,0 +1,186 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Commands;
+
+use CraftCms\Cms\Console\CraftCommand;
+use CraftCms\Cms\Site\Data\Site;
+use CraftCms\Cms\Support\Facades\Import as ImportFacade;
+use CraftCms\Cms\Support\Facades\Imports;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Support\ImportHelper;
+use CraftCms\Cms\Support\Json;
+use Illuminate\Console\Command;
+use Illuminate\Contracts\Console\PromptsForMissingInput;
+use Illuminate\Validation\ValidationException;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputOption;
+
+use function Laravel\Prompts\form;
+use function Laravel\Prompts\select;
+use function Laravel\Prompts\text;
+
+/**
+ * If you create a new element import command that extends this class,
+ * you should register it from your Plugin's boot() method via
+ * $this->commands() method and pass an array containing FQCN of the new command(s).
+ */
+abstract class Import extends Command implements PromptsForMissingInput
+{
+    use CraftCommand;
+
+    protected function configure(): void
+    {
+        $this->addArgument('file', InputArgument::REQUIRED, '`@root`-relative path to the file containing the data you want to import.')
+            ->addOption('site', null, InputOption::VALUE_OPTIONAL, 'The handle of the site you want to import into.')
+            ->addOption('transformer', null, InputOption::VALUE_OPTIONAL, 'The fully qualified class name of the transformer you want to use to manipulate the data on import.')
+            ->addOption('matchCriteria', null, InputOption::VALUE_OPTIONAL, 'An array of key-value pairs that will be used to match existing elements when importing.');
+    }
+
+    /**
+     * The importer class that will be used to import the data.
+     */
+    abstract public static function importerClass(): string;
+
+    /**
+     * Builds an interactive prompt form for missing CLI options, normalizes match criteria, constructs an ElementImporter config from options/prompt answers, and dispatches the import.
+     */
+    public function handle(): int
+    {
+        $options = form()
+            ->addIf(! $this->option('site') && Sites::isMultiSite(), fn ($form) => select(
+                label: 'Which site you want to import into?',
+                options: Sites::getAllSites()
+                    ->mapWithKeys(fn (Site $site) => [$site->handle => $site->name])
+                    ->all(),
+                default: Sites::getPrimarySite()->handle,
+            ), 'site')
+            ->addIf(! $this->option('transformer'), fn () => text(
+                label: 'The transformer you want to use to manipulate the data on import (fully qualified class name for the transformer)',
+                validate: [
+                    'string',
+                ]
+            ), 'transformer')
+            ->addIf(! $this->option('matchCriteria'), fn () => text(
+                label: 'A JSON-encoded array of match criteria you’d like to use to match against existing elements. If none provided, ID will be used for matching.',
+                validate: [
+                    'string',
+                ]
+            ), 'matchCriteria');
+
+        foreach ($this->getAdditionalOptions() as $handle => $params) {
+            $options->addIf(! $this->option($handle) && ($params['condition'] ?? true), $params['prompt'], $handle);
+        }
+        $responses = $options->submit();
+
+        $matchCriteria = null;
+        if ($this->option('matchCriteria')) {
+            $matchCriteria = self::normalizeMatchCriteria($this->option('matchCriteria'));
+        } elseif ($responses['matchCriteria']) {
+            if (! str_starts_with((string) $responses['matchCriteria'], '=')) {
+                $responses['matchCriteria'] = '='.$responses['matchCriteria'];
+            }
+            $matchCriteria = self::normalizeMatchCriteria($responses['matchCriteria']);
+        }
+
+        $settings = [
+            ...$responses,
+            ...$this->options(),
+        ];
+        unset($settings['matchCriteria']);
+
+        // IMPORTANT: don't change "?:" to "??" as it'll treat an empty string passed into --optionName as valid
+        $config = [
+            'type' => static::importerClass(),
+            'file' => $this->argument('file'),
+            'transformer' => $this->option('transformer') ?: $responses['transformer'] ?: null,
+            'settings' => $settings,
+        ];
+
+        $importConfig = Imports::createImporter($config);
+
+        if ($importConfig === null) {
+            return self::FAILURE;
+        }
+
+        if ($matchCriteria) {
+            $importConfig->matchCriteria($matchCriteria);
+        }
+
+        $this->components->info('Importing data into:');
+
+        $list = [
+            "Import Type: `{$importConfig::targetClass()}`",
+            "File: `$importConfig->file`",
+            'Transformer: '.($importConfig->transformer ? "`{$importConfig->transformerAsString()}`" : 'NULL'),
+            'Match Criteria: '.($importConfig->matchCriteria ? json_encode($importConfig->matchCriteria) : 'NULL'),
+        ];
+        $this->components->bulletList($list);
+
+        try {
+            // $importConfig->validateSettings();
+            $filePath = $importConfig::resolvedFilePath($importConfig->file);
+            $matchCriteria = ImportHelper::normalizeMatchCriteriaFromImporterConfig($importConfig);
+            $allData = ImportFacade::getFormattedData($filePath);
+            $count = count($allData);
+
+            foreach ($allData as $i => $item) {
+                $this->components->info('Importing item ('.($i + 1)."/{$count}) ...");
+                ImportFacade::importItem($importConfig, $item, $matchCriteria);
+            }
+        } catch (ValidationException $e) {
+            foreach ($e->errors() as $attribute => $messages) {
+                $this->components->error("$attribute: ".implode(' ', $messages));
+            }
+            $this->fail('Import configuration is invalid.');
+        }
+
+        $this->components->info('Done');
+
+        return self::SUCCESS;
+    }
+
+    /**
+     * Prompt for missing input arguments using the returned questions.
+     *
+     * @return array<string, string>
+     */
+    protected function promptForMissingArgumentsUsing(): array
+    {
+        return [
+            // todo (iwona): do we want to support URLs containing all the data (like in feed me where you can use rss feed) or just files?
+            'file' => fn () => text(
+                label: 'The `@root`-relative path to the file containing the data you want to import',
+                required: true,
+                validate: [
+                    'string',
+                ]
+            ),
+        ];
+    }
+
+    /**
+     * Returns an array of additional options that concrete classes should prompt for if missing.
+     */
+    protected function getAdditionalOptions(): array
+    {
+        return [];
+    }
+
+    /**
+     * Strips a leading `=` from a match-criteria string and JSON-decodes it, returning null if not prefixed.
+     */
+    private static function normalizeMatchCriteria(string $matchCriteria): ?array
+    {
+        if (str_starts_with($matchCriteria, '=')) {
+            $matchCriteria = substr($matchCriteria, 1);
+        }
+
+        try {
+            return Json::decode($matchCriteria);
+        } catch (\InvalidArgumentException) {
+            return null;
+        }
+    }
+}
diff --git a/src/Import/Data/Import.php b/src/Import/Data/Import.php
new file mode 100644
index 00000000000..94639db142d
--- /dev/null
+++ b/src/Import/Data/Import.php
@@ -0,0 +1,301 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Data;
+
+use CraftCms\Cms\Component\Component;
+use CraftCms\Cms\Component\Contracts\CpEditable;
+use CraftCms\Cms\Database\Table;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use CraftCms\Cms\Support\Facades\Import as ImportFacade;
+use CraftCms\Cms\Support\Facades\Imports as ImportsFacade;
+use CraftCms\Cms\Support\Json;
+use CraftCms\Cms\Support\Str;
+use CraftCms\Cms\Support\Url;
+use CraftCms\Cms\Validation\Contracts\Validatable;
+use CraftCms\Cms\Validation\Rules\HandleRule;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Validator as ValidatorFacade;
+use Illuminate\Validation\Rule;
+use Illuminate\Validation\Validator;
+use Override;
+
+use function CraftCms\Cms\t;
+
+/**
+ * A named, handled import: an ordered list of steps, each of which pairs an importer type
+ * with its own file, transformer, settings and mapping.
+ */
+class Import extends Component implements CpEditable, Validatable
+{
+    public ?string $name = null;
+
+    public ?string $handle = null;
+
+    public ?string $description = null;
+
+    /**
+     * @var array<int, array<string, mixed>>|null An ordered list of step arrays, each shaped
+     *                                            `{uid, type, file, transformer, batchSize, settings}`.
+     */
+    public ?array $steps = null;
+
+    public ?string $uid = null;
+
+    /**
+     * Whether this import is stored in the database, and so editable via the control panel.
+     * File-based imports, declared through the `craft.import` config, are not.
+     */
+    public bool $editable = false;
+
+    public function __construct(array $config = [])
+    {
+        $steps = [];
+        if (isset($config['steps']) && is_string($config['steps'])) {
+            $items = Json::decode($config['steps']);
+            foreach ($items as $item) {
+                $step = ImportsFacade::createImporter($item);
+                $steps[] = $step;
+            }
+            $config['steps'] = array_filter($steps);
+        }
+
+        parent::__construct($config);
+    }
+
+    /**
+     * Sets the name for the import.
+     *
+     * @param  string|null  $name  The name to set.
+     */
+    public function name(?string $name): self
+    {
+        $this->name = $name;
+
+        return $this;
+    }
+
+    /**
+     * Sets the handle for the import.
+     *
+     * @param  string|null  $handle  The handle to be assigned.
+     */
+    public function handle(?string $handle): self
+    {
+        $this->handle = $handle;
+
+        return $this;
+    }
+
+    /**
+     * Sets the description for the import.
+     *
+     * @param  string|null  $description  The description to be assigned.
+     */
+    public function description(?string $description): self
+    {
+        $this->description = $description;
+
+        return $this;
+    }
+
+    /**
+     * Sets the import's steps, assigning a UID to any step that doesn't have one yet.
+     *
+     * @param  array<array-key, array<string, mixed>>|null  $steps  The steps to set.
+     */
+    public function steps(?array $steps): self
+    {
+        if ($steps === null) {
+            $this->steps = null;
+
+            return $this;
+        }
+
+        $this->steps = self::normalizeSteps($steps);
+
+        return $this;
+    }
+
+    /**
+     * Normalize an array of steps (which could be an array or arrays) into an array of BaseImporter objects.
+     */
+    private static function normalizeSteps(array $steps): ?array
+    {
+        if (empty($steps)) {
+            return null;
+        }
+
+        $items = [];
+        foreach ($steps as $step) {
+            if (is_array($step)) {
+                $step = ImportsFacade::createImporter($step);
+            }
+            if (empty($step->uid)) {
+                $step->uid = Str::uuid7()->toString();
+            }
+
+            $items[] = $step;
+        }
+
+        return $items;
+    }
+
+    /**
+     * Serializes the import's steps into an array of arrays.'
+     */
+    public function serializeSteps(): ?array
+    {
+        if ($this->steps === null) {
+            return null;
+        }
+
+        return array_map(fn (array|BaseImporter $importer) => is_array($importer) ? $importer : $importer->toArrayData(), $this->steps);
+    }
+
+    /**
+     * Defines validation rules for the import itself. Each step is validated separately,
+     * against its own importer's rules, in `afterValidate()`.
+     */
+    #[Override]
+    public function getRules(): array
+    {
+        return [
+            'name' => [
+                'required',
+                'string',
+                'max:255',
+            ],
+            'handle' => [
+                'required',
+                'string',
+                'max:255',
+                new HandleRule(reservedWords: ['id', 'dateCreated', 'dateUpdated', 'uid', 'title']),
+                // ensure DB-stored imports have unique handles
+                Rule::unique(Table::IMPORTS, 'handle')->ignore($this->uid, 'uid')->withoutTrashed('dateDeleted'),
+            ],
+            'description' => [
+                'string',
+                'nullable',
+            ],
+            'steps' => [
+                'required',
+                'array',
+                'min:1',
+            ],
+        ];
+    }
+
+    /**
+     * Defines custom validation messages for the import.
+     */
+    #[Override]
+    public function getMessages(): array
+    {
+        return [
+            'steps.required' => t('An import needs at least one step.'),
+            'steps.min' => t('An import needs at least one step.'),
+        ];
+    }
+
+    /**
+     * Validates each step against its own importer type's rules, folding any errors back into
+     * the import's error bag under `steps.<key>.<attribute>`.
+     */
+    #[Override]
+    public function afterValidate(?Validator $validator = null): void
+    {
+        if ($validator === null) {
+            return;
+        }
+
+        foreach ($this->steps ?? [] as $i => $step) {
+            $key = $step->uid ?? $i;
+
+            foreach (self::stepErrors($step) as $attribute => $messages) {
+                $validator->errors()->add("steps.$key.$attribute", ...$messages);
+            }
+        }
+    }
+
+    /**
+     * Validates a single step's data against its importer type's rules. Used both when
+     * validating the import as a whole, and by the step slideout to check a draft step
+     * before it lets the step close.
+     *
+     * @param  array<string, mixed>  $step  The step to validate.
+     * @return array<string, array<int, string>> Validation messages keyed by attribute.
+     */
+    public static function stepErrors(array|BaseImporter $step): array
+    {
+        if (is_array($step)) {
+            $type = $step['type'] ?? null;
+            $stepArray = $step;
+        } else {
+            $type = $step::class ?? null;
+            $stepArray = $step->toArrayData();
+        }
+
+        $typeValidator = ValidatorFacade::make(['type' => $type], [
+            'type' => ['required', 'string', Rule::in(ImportFacade::getAllImporterTypes())],
+        ]);
+
+        if ($typeValidator->fails()) {
+            return ['type' => $typeValidator->errors()->get('type')];
+        }
+
+        $stepValidator = ValidatorFacade::make($stepArray, $type::getRules());
+
+        return $stepValidator->fails() ? $stepValidator->errors()->messages() : [];
+    }
+
+    /**
+     * Returns an importer instance per step, skipping any step whose importer can't be built.
+     *
+     * @return Collection<array-key, BaseImporter>
+     */
+    public function getImporters(): Collection
+    {
+        return collect($this->steps ?? [])
+            ->map(fn (array $step) => ImportsFacade::createImporter($step))
+            ->filter()
+            ->values();
+    }
+
+    /**
+     * Returns a plain array snapshot of the import's properties.
+     */
+    public function getConfig(): array
+    {
+        return [
+            'name' => $this->name,
+            'handle' => $this->handle,
+            'description' => $this->description,
+            'steps' => $this->steps,
+            'uid' => $this->uid,
+        ];
+    }
+
+    /**
+     * Determines whether the import is stored in the database, and therefore editable via the
+     * control panel. File-based imports are not.
+     */
+    public function isEditable(): bool
+    {
+        return $this->editable;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getCpEditUrl(): ?string
+    {
+        if (! $this->handle || ! Auth::user()?->isAdmin()) {
+            return null;
+        }
+
+        return Url::cpUrl("import/$this->handle");
+    }
+}
diff --git a/src/Import/DataTypes/Csv.php b/src/Import/DataTypes/Csv.php
new file mode 100644
index 00000000000..684bb601a18
--- /dev/null
+++ b/src/Import/DataTypes/Csv.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\DataTypes;
+
+use InvalidArgumentException;
+use Override;
+use PhpOffice\PhpSpreadsheet\Reader\Csv as CsvReader;
+
+class Csv implements DataTypeInterface
+{
+    #[Override]
+    public static function format(string $data): array
+    {
+        try {
+            $array = self::getData($data);
+        } catch (InvalidArgumentException $e) {
+            $error = 'Invalid CSV: '.$e->getMessage();
+
+            return ['success' => false, 'error' => $error];
+        }
+
+        $headings = array_shift($array);
+        $body = array_map(fn ($row) => array_combine($headings, $row), $array);
+
+        return ['success' => true, 'data' => $body];
+    }
+
+    #[Override]
+    public static function getHeadings(string $data): array
+    {
+        try {
+            $data = self::getData($data);
+        } catch (InvalidArgumentException $e) {
+            $error = 'Invalid CSV: '.$e->getMessage();
+
+            return ['success' => false, 'error' => $error];
+        }
+
+        $keys = array_shift($data);
+        $firstRow = $data[0] ?? null;
+
+        $headings = [];
+        foreach ($keys as $index => $key) {
+            $hint = $firstRow[$index] ?? null;
+            $headings[] = array_filter([
+                'label' => $key,
+                'value' => $key,
+                'data' => $hint !== null && $hint !== '' ? ['hint' => (string) $hint] : null,
+            ], fn ($value) => $value !== null);
+        }
+
+        usort($headings, fn ($a, $b) => $a['label'] <=> $b['label']);
+
+        return $headings;
+    }
+
+    /**
+     * Uses PhpSpreadsheet's CSV reader to load the string into a 2D array.
+     */
+    private static function getData(string $data): array
+    {
+        $reader = new CsvReader;
+        $reader->setDelimiter(',');
+        $reader->setReadDataOnly(true);
+        // $reader->setSheetIndex(0);
+
+        $spreadsheet = $reader->loadSpreadsheetFromString($data);
+        $sheet = $spreadsheet->getSheet(0);
+
+        return $sheet->toArray();
+    }
+}
diff --git a/src/Import/DataTypes/DataTypeInterface.php b/src/Import/DataTypes/DataTypeInterface.php
new file mode 100644
index 00000000000..367bbba6024
--- /dev/null
+++ b/src/Import/DataTypes/DataTypeInterface.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\DataTypes;
+
+interface DataTypeInterface
+{
+    /**
+     * Formats the data string according to the Data Type rules.
+     *
+     * @param  string  $data  The raw file contents to parse.
+     */
+    public static function format(string $data): array;
+
+    /**
+     * Returns a list of unique column names/headings/properties present in the data.
+     *
+     * @param  string  $data  The raw file contents to parse.
+     */
+    public static function getHeadings(string $data): array;
+}
diff --git a/src/Import/DataTypes/Json.php b/src/Import/DataTypes/Json.php
new file mode 100644
index 00000000000..c4696f5838d
--- /dev/null
+++ b/src/Import/DataTypes/Json.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\DataTypes;
+
+use CraftCms\Cms\Support\Arr;
+use CraftCms\Cms\Support\Json as JsonHelper;
+use InvalidArgumentException;
+use Override;
+
+class Json implements DataTypeInterface
+{
+    #[Override]
+    public static function format(string $data): array
+    {
+        // Parse the JSON string
+        try {
+            $array = self::getData($data);
+        } catch (InvalidArgumentException $e) {
+            $error = 'Invalid JSON: '.$e->getMessage();
+
+            return ['success' => false, 'error' => $error];
+        }
+
+        return ['success' => true, 'data' => $array];
+    }
+
+    #[Override]
+    public static function getHeadings(string $data): array
+    {
+        try {
+            $array = self::getData($data);
+        } catch (InvalidArgumentException $e) {
+            $error = 'Invalid JSON: '.$e->getMessage();
+
+            return ['success' => false, 'error' => $error];
+        }
+
+        //        $keys = static::collectUniqueKeys($array);
+        $keys = Arr::uniqueDotifiedKeys($array);
+
+        $headings = [];
+        foreach ($keys as $key) {
+            $sample = Arr::sampleValueAtDotifiedKey($array, $key);
+            $hint = is_scalar($sample) && $sample !== '' ? (string) $sample : null;
+            $headings[] = array_filter([
+                'label' => $key,
+                'value' => $key,
+                'data' => $hint !== null ? ['hint' => $hint] : null,
+            ], fn ($value) => $value !== null);
+        }
+
+        usort($headings, fn ($a, $b) => $a['label'] <=> $b['label']);
+
+        return $headings;
+    }
+
+    /**
+     * Thin wrapper around the app's JsonHelper::decode.
+     */
+    private static function getData(string $data): array
+    {
+        return JsonHelper::decode($data);
+    }
+
+    /**
+     * Recursively walks a nested array collecting keys by reference.
+     */
+    private static function collectKeysFromArray(array $array, array &$keys): void
+    {
+        foreach ($array as $key => $value) {
+            $keys[$key] ??= [];
+
+            if (is_array($value)) {
+                self::collectKeysFromArray($value, $keys[$key]);
+            }
+        }
+    }
+}
diff --git a/src/Import/DataTypes/Xml.php b/src/Import/DataTypes/Xml.php
new file mode 100644
index 00000000000..79b8662d7bf
--- /dev/null
+++ b/src/Import/DataTypes/Xml.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\DataTypes;
+
+use CraftCms\Cms\Support\Arr;
+use CraftCms\Cms\Support\Json as JsonHelper;
+use Exception;
+use Override;
+
+class Xml implements DataTypeInterface
+{
+    #[Override]
+    public static function format(string $data): array
+    {
+        try {
+            $array = self::getData($data);
+        } catch (Exception $e) {
+            $error = "Invalid XML: {$e->getMessage()}";
+
+            return ['success' => false, 'error' => $error];
+        }
+
+        return ['success' => true, 'data' => $array];
+    }
+
+    #[Override]
+    public static function getHeadings(string $data): array
+    {
+        try {
+            $array = self::getData($data);
+        } catch (Exception $e) {
+            $error = "Invalid XML: {$e->getMessage()}";
+
+            return ['success' => false, 'error' => $error];
+        }
+
+        // iterate through the array and get all unique properties;
+        $keys = Arr::uniqueDotifiedKeys($array);
+
+        $headings = [];
+        foreach ($keys as $key) {
+            $sample = Arr::sampleValueAtDotifiedKey($array, $key);
+            $hint = is_scalar($sample) && $sample !== '' ? (string) $sample : null;
+            $headings[] = array_filter([
+                'label' => $key,
+                'value' => $key,
+                'data' => $hint !== null ? ['hint' => $hint] : null,
+            ], fn ($value) => $value !== null);
+        }
+
+        usort($headings, fn ($a, $b) => $a['label'] <=> $b['label']);
+
+        return $headings;
+    }
+
+    /**
+     * Converts an XML string to array via SimpleXML + JSON round-trip, unwrapping the first key if it's itself an array.
+     */
+    private static function getData(string $data): array
+    {
+        $xmlObj = simplexml_load_string($data);
+        $array = JsonHelper::decode(json_encode($xmlObj));
+
+        $firstKey = array_key_first($array);
+        if (is_array($array[$firstKey])) {
+            return $array[$firstKey];
+        }
+
+        return $array;
+    }
+}
diff --git a/src/Import/Events/DataImported.php b/src/Import/Events/DataImported.php
new file mode 100644
index 00000000000..04440ebd5cf
--- /dev/null
+++ b/src/Import/Events/DataImported.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Events;
+
+use CraftCms\Cms\Import\Importers\BaseImporter;
+
+/**
+ * @event DataImported The event that is triggered after data is imported.
+ */
+final readonly class DataImported
+{
+    /**
+     * Promotes the importer config and imported data into a readonly event payload fired after import.
+     */
+    public function __construct(
+        public BaseImporter $importer,
+        public array $data,
+    ) {}
+}
diff --git a/src/Import/Events/DataImporting.php b/src/Import/Events/DataImporting.php
new file mode 100644
index 00000000000..ada2a1df5b7
--- /dev/null
+++ b/src/Import/Events/DataImporting.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Events;
+
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use CraftCms\Cms\Shared\Concerns\ValidatableEvent;
+
+/**
+ * @event DataImporting The event that is triggered before data is imported.
+ */
+class DataImporting
+{
+    use ValidatableEvent;
+
+    /**
+     * Promotes the importer config and raw data into a cancellable event fired before import.
+     *
+     * @param  BaseImporter  $importer  The importer config for this event.
+     */
+    public function __construct(
+        public BaseImporter $importer,
+        public array $data,
+    ) {}
+}
diff --git a/src/Import/Events/ImportDispatched.php b/src/Import/Events/ImportDispatched.php
new file mode 100644
index 00000000000..f20afce59d5
--- /dev/null
+++ b/src/Import/Events/ImportDispatched.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Events;
+
+use CraftCms\Cms\Import\Data\Import;
+
+/**
+ * @event ImportDispatched The event that is triggered after an import is dispatched to the queue.
+ */
+class ImportDispatched
+{
+    /**
+     * Carries the dispatched job steps and the import, fired after queue dispatch.
+     *
+     * @param  array  $steps  The queue job steps to be dispatched.
+     */
+    public function __construct(
+        public array $steps,
+        public Import $import,
+    ) {}
+}
diff --git a/src/Import/Events/ImportDispatching.php b/src/Import/Events/ImportDispatching.php
new file mode 100644
index 00000000000..0e14c02db72
--- /dev/null
+++ b/src/Import/Events/ImportDispatching.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Events;
+
+use CraftCms\Cms\Import\Data\Import;
+use CraftCms\Cms\Shared\Concerns\ValidatableEvent;
+
+/**
+ * @event ImportDispatching The event that is triggered before an import is dispatched to the queue.
+ */
+class ImportDispatching
+{
+    use ValidatableEvent;
+
+    /**
+     * Carries the steps and import for a cancellable pre-dispatch event.
+     *
+     * @param  array  $steps  The queue job steps to be dispatched.
+     */
+    public function __construct(
+        public array $steps,
+        public Import $import,
+    ) {}
+}
diff --git a/src/Import/Events/ImportSaved.php b/src/Import/Events/ImportSaved.php
new file mode 100644
index 00000000000..f536f04e97d
--- /dev/null
+++ b/src/Import/Events/ImportSaved.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Events;
+
+use CraftCms\Cms\Import\Data\Import;
+
+/**
+ * @event ImportSaved The event that is triggered after an import is saved.
+ */
+final readonly class ImportSaved
+{
+    /**
+     * Carries the saved import and isNew flag, fired after save.
+     *
+     * @param  Import  $import  The import this event concerns.
+     */
+    public function __construct(
+        public Import $import,
+        public bool $isNew,
+    ) {}
+}
diff --git a/src/Import/Events/ImportSaving.php b/src/Import/Events/ImportSaving.php
new file mode 100644
index 00000000000..38ae6e0efb3
--- /dev/null
+++ b/src/Import/Events/ImportSaving.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Events;
+
+use CraftCms\Cms\Import\Data\Import;
+use CraftCms\Cms\Shared\Concerns\ValidatableEvent;
+
+/**
+ * @event ImportSaving The event that is triggered before an import is saved.
+ */
+class ImportSaving
+{
+    use ValidatableEvent;
+
+    /**
+     * Carries the import and isNew flag for a cancellable pre-save event.
+     *
+     * @param  Import  $import  The import this event concerns.
+     * @param  bool  $isNew  Whether the import is newly created.
+     */
+    public function __construct(
+        public Import $import,
+        public bool $isNew,
+    ) {}
+}
diff --git a/src/Import/Events/RegisterDataTypes.php b/src/Import/Events/RegisterDataTypes.php
new file mode 100644
index 00000000000..6c24db8c2ed
--- /dev/null
+++ b/src/Import/Events/RegisterDataTypes.php
@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Events;
+
+use CraftCms\Cms\Import\DataTypes\DataTypeInterface;
+
+/**
+ * @event RegisterDataTypes The event that is triggered when registering available import data types.
+ *
+ * Data types must implement {@see DataTypeInterface}.
+ * ---
+ * ```php
+ * use CraftCms\Cms\Import\Events\RegisterDataTypes;
+ * use Illuminate\Support\Facades\Event;
+ *
+ * Event::listen(RegisterDataTypes::class, function(RegisterDataTypes $event) {
+ *     $event->dataTypes['xyz'] = MyDataType::class;
+ * });
+ * ```
+ */
+class RegisterDataTypes
+{
+    /**
+     * Carries the mutable list of registered data type classes for listeners to add to.
+     *
+     * @param  array<class-string<DataTypeInterface>>  $dataTypes  The registered data type classes.
+     */
+    public function __construct(
+        /** @var array<class-string<DataTypeInterface>> */
+        public array $dataTypes,
+    ) {}
+}
diff --git a/src/Import/Events/RegisterImporterTypes.php b/src/Import/Events/RegisterImporterTypes.php
new file mode 100644
index 00000000000..0fcd504b222
--- /dev/null
+++ b/src/Import/Events/RegisterImporterTypes.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Events;
+
+class RegisterImporterTypes
+{
+    /**
+     * Carries the mutable list of registered importer classes for listeners to add to.
+     *
+     * @param  array  $importers  The registered importer classes.
+     */
+    public function __construct(
+        public array $importers,
+    ) {}
+}
diff --git a/src/Import/Import.php b/src/Import/Import.php
new file mode 100644
index 00000000000..908af7f9ddc
--- /dev/null
+++ b/src/Import/Import.php
@@ -0,0 +1,535 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import;
+
+use CraftCms\Cms\Asset\Import\AssetImporter;
+use CraftCms\Cms\Element\Import\ElementImporter;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Import\Data\Import as ImportData;
+use CraftCms\Cms\Import\DataTypes\Csv;
+use CraftCms\Cms\Import\DataTypes\Json;
+use CraftCms\Cms\Import\DataTypes\Xml;
+use CraftCms\Cms\Import\Events\DataImported;
+use CraftCms\Cms\Import\Events\DataImporting;
+use CraftCms\Cms\Import\Events\ImportDispatched;
+use CraftCms\Cms\Import\Events\ImportDispatching;
+use CraftCms\Cms\Import\Events\RegisterDataTypes;
+use CraftCms\Cms\Import\Events\RegisterImporterTypes;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use CraftCms\Cms\Import\Importers\ModelImporter;
+use CraftCms\Cms\Import\Jobs\Import as ImportJob;
+use CraftCms\Cms\Import\Jobs\ImportPipeline;
+use CraftCms\Cms\Import\Transformers\BaseTransformer;
+use CraftCms\Cms\Support\Arr;
+use CraftCms\Cms\Support\Facades\ImportLog;
+use CraftCms\Cms\Support\ImportHelper;
+use CraftCms\Cms\SystemMessage\Import\SystemMessageImporter;
+use CraftCms\Cms\User\Import\UserImporter;
+use Exception;
+use Illuminate\Container\Attributes\Singleton;
+use Illuminate\Support\Facades\Event;
+use Illuminate\Support\Facades\File;
+use League\Fractal\Manager;
+use League\Fractal\Resource\Item;
+use League\Fractal\Serializer\DataArraySerializer;
+use Throwable;
+
+use function CraftCms\Cms\t;
+
+#[Singleton]
+class Import
+{
+    public function __construct(
+        private readonly Imports $imports,
+    ) {}
+
+    /**
+     * Returns the available data type classes, keyed by extension.
+     * The list includes built-in json/csv/xml data type map, extended via `RegisterDataTypes` event listeners.
+     */
+    public function getAllDataTypes(): array
+    {
+        $dataTypes = [
+            'json' => Json::class,
+            'csv' => Csv::class,
+            'xml' => Xml::class,
+        ];
+
+        if (Event::hasListeners(RegisterDataTypes::class)) {
+            Event::dispatch($event = new RegisterDataTypes($dataTypes));
+
+            $dataTypes = $event->dataTypes;
+        }
+
+        return $dataTypes;
+    }
+
+    /**
+     * Returns the available importer classes.
+     * The list includes built-in Element/Model importer classes, extended via `RegisterImporterTypes` event.
+     *
+     * @return array The available importer classes.
+     */
+    public function getAllImporterTypes(): array
+    {
+        $importers = [
+            EntryImporter::class,
+            AssetImporter::class,
+            UserImporter::class,
+            SystemMessageImporter::class,
+        ];
+
+        if (Event::hasListeners(RegisterImporterTypes::class)) {
+            Event::dispatch($event = new RegisterImporterTypes($importers));
+
+            $importers = $event->importers;
+        }
+
+        return $importers;
+    }
+
+    /**
+     * Returns the registered `ElementImporter` subclass (core or plugin-registered) whose
+     * `elementClass()` matches the given element type, or null if none is registered for it.
+     *
+     * @param  string  $elementClass  The element type's FQCN.
+     */
+    public function getElementImporterTypeFor(string $elementClass): ?string
+    {
+        foreach ($this->getAllImporterTypes() as $type) {
+            if (is_subclass_of($type, ElementImporter::class) && $type::targetClass() === $elementClass) {
+                return $type;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Returns the registered `ModelImporter` subclass (core or plugin-registered) whose
+     * `modelClass()` matches the given model, or null if none is registered for it.
+     *
+     * @param  string  $modelClass  The model's FQCN.
+     */
+    public function getModelImporterTypeFor(string $modelClass): ?string
+    {
+        foreach ($this->getAllImporterTypes() as $type) {
+            if (is_subclass_of($type, ModelImporter::class) && $type::targetClass() === $modelClass) {
+                return $type;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Resolves each of the import's steps into a queued Import job, fires
+     * dispatching/dispatched events, and dispatches an ImportPipeline job chain.
+     *
+     * @param  ImportData  $import  The import to dispatch.
+     */
+    public function dispatchImport(ImportData $import): bool
+    {
+        $steps = [];
+
+        // for each step in the $import
+        foreach ($import->steps as $key => $step) {
+            $filePath = BaseImporter::resolvedFilePath($step->file);
+
+            // name for this batch of jobs
+            $steps[$key]['name'] = self::stepLabel($import, $step);
+            $steps[$key]['job'] = new ImportJob($import->uid ?? $import->handle, $step->uid, $filePath, 0);
+        }
+
+        event($event = new ImportDispatching($steps, $import));
+
+        if (! $event->isValid) {
+            return false;
+        }
+
+        $steps = $event->steps;
+        $import = $event->import;
+
+        // todo (iwona): think about scheduling batch pruning
+
+        // we need to go through a single job because we want to name our chain
+        dispatch(new ImportPipeline($steps, $import));
+
+        event(new ImportDispatched($steps, $import));
+
+        return true;
+    }
+
+    /**
+     * Returns a human-readable label for one of an import's steps.
+     *
+     * @param  ImportData  $import  The import the step belongs to.
+     * @param  BaseImporter  $step  The step to label.
+     */
+    public static function stepLabel(ImportData $import, BaseImporter $step): string
+    {
+        $type = $step::class ?? null;
+
+        return sprintf(
+            '%s: %s',
+            $import->name,
+            is_string($type) && class_exists($type) ? $type::displayName() : t('Unknown importer'),
+        );
+    }
+
+    /**
+     * Fires the importing event, applies map remapping, resolves/applies match criteria and clearable items,
+     * then hands the item to the importer and fires the imported event.
+     *
+     * @param  BaseImporter  $importer  The importer config to import into.
+     * @param  array  $data  The raw item data being imported.
+     * @param  array  $matchCriteria  any criteria that should be used to match incoming data against existing elements
+     */
+    public function importItem(BaseImporter $importer, array $data, array $matchCriteria = []): void
+    {
+        event($event = new DataImporting($importer, $data));
+
+        if (! $event->isValid) {
+            return;
+        }
+
+        $data = $event->data;
+        // if we have a map here, hook it up; if we have both the map and the transformer,
+        // then the map is used first and then transformer can do further manipulation;
+        // if there's no map, the transformer acts as one on its own;
+        if ($importer->map) {
+            $data = ImportHelper::remapData($importer->map, $data);
+        }
+
+        // the order or priority in which match criteria is used (the higher the priority, the more important it is):
+        // 1. matchCriteria coming from the importer config (either UI- or file-based);
+        //      those values are the same for all the items in the import (it doesn't change for the entire import step),
+        //      which is why we grab it once, in the Import job
+        // 2. matchCriteria coming from the data
+        //      those values can differ from data item to data item, and they're a "simple" array of key => value pairs where
+        //      the key is the property, field handle or column name in the system
+        //      the value is the handle used to locate the data in the incoming dataset,
+        //      for example: I want to match on a title field value, the value I want to match on is "my first title",
+        //      and it's stored in the incoming dataset as ["incomingTitle" => "my first title"];
+        //      the matchCriteria value in the data should be listed as ["matchCriteria" => ["title" => "incomingTitle"]]
+        // 3. matchCriteria coming from the BaseTransformer::additionalMatchCriteria() method - if the import uses a transformer that has it
+        //      those values can be computed dynamically based on the incoming data and can impact the array returned by that method;
+        //      the array should be an array of key-value pairs where
+        //      the key is the property, field handle or column name in the system
+        //      the value is the actual value to match on (not the handle)
+        // and now top that up with any additional (computed) match criteria
+
+        // additional match criteria
+        $additionalMatchCriteria = $importer->transformer instanceof BaseTransformer ?
+            $importer->transformer->additionalMatchCriteria($importer, $data) : [];
+        $this->resolveMatchCriteria($data, $matchCriteria, $additionalMatchCriteria);
+
+        $this->applyClearableItems($data, $importer->clearableItems ?? []);
+
+        $importer->importItem($data);
+
+        event(new DataImported($importer, $data));
+    }
+
+    /**
+     * Resolves the match criteria so that the returned array contains keys that represent the fields/attributes/properties to update
+     * and values containing the incoming data values (not keys).
+     */
+    private function resolveMatchCriteria(array &$data, array $criteria, array $additionalMatchCriteria): void
+    {
+        $importerConfigLevelCriteria = [];
+        foreach ($criteria as $key => $value) {
+            if ($value !== null && ! is_array($value) && isset($data[$key])/* array_key_exists($key, $data) */) {
+                $importerConfigLevelCriteria[$key] = $data[$key];
+            }
+        }
+
+        $dataSourcedMatchCriteria = $data['matchCriteria'] ?? [];
+
+        if (! empty($dataSourcedMatchCriteria)) {
+            $fields = is_array($data['fields'] ?? null) ? $data['fields'] : [];
+            array_walk(
+                $dataSourcedMatchCriteria,
+                function (&$value, $key) use ($data, $fields) {
+                    if (is_string($value)) {
+                        $value = $data[$key] ?? $fields[$key] ?? $value;
+                    }
+                }
+            );
+        }
+
+        if (! empty($importerConfigLevelCriteria) || ! empty($dataSourcedMatchCriteria)) {
+            $matchCriteria = array_merge($dataSourcedMatchCriteria, $importerConfigLevelCriteria);
+            $data = ['matchCriteria' => $matchCriteria] + $data;
+        }
+
+        if (! empty($additionalMatchCriteria)) {
+            $matchCriteria = Arr::undot(array_replace(
+                Arr::dot($data['matchCriteria'] ?? []),
+                Arr::dot($additionalMatchCriteria)
+            ));
+            $data = ['matchCriteria' => $matchCriteria] + $data;
+        }
+
+        // walk every array-valued key present in either the data or the configured criteria, not
+        // just ones the importer's own criteria config happens to mention, so that inline
+        // matchCriteria on blocks the config doesn't cover (e.g. a container field the importer
+        // never configured matching for) still gets resolved.
+        $keys = array_unique(array_merge(array_keys($criteria), array_keys($data)));
+
+        foreach ($keys as $key) {
+            if ($key === 'matchCriteria' || ! isset($data[$key]) || ! is_array($data[$key])) {
+                continue;
+            }
+
+            $value = $criteria[$key] ?? [];
+
+            if (! is_array($value)) {
+                continue;
+            }
+
+            if (array_is_list($data[$key])) {
+                foreach ($data[$key] as &$item) {
+                    if (! is_array($item)) {
+                        continue;
+                    }
+
+                    // typed rows (matrix blocks) carry their criteria under their own block type;
+                    // rows without a type (addresses) use the container's criteria directly
+                    $type = is_string($item['type'] ?? null) ? $item['type'] : null;
+
+                    $this->resolveMatchCriteria(
+                        $item,
+                        $type !== null ? ($value[$type] ?? []) : $value,
+                        $type !== null ? ($additionalMatchCriteria[$type] ?? []) : ($additionalMatchCriteria[$key] ?? []),
+                    );
+                }
+                unset($item);
+            } else {
+                $this->resolveMatchCriteria($data[$key], $value, $additionalMatchCriteria[$key] ?? []);
+            }
+        }
+    }
+
+    /**
+     * Clears out any handles marked as clearable in $clearableItems whose incoming value is missing or empty,
+     * forcing them to null so they're explicitly applied (rather than silently left untouched) further downstream.
+     */
+    private function applyClearableItems(array &$data, array $clearableItems): void
+    {
+        foreach ($clearableItems as $key => $value) {
+            if (! is_array($value)) {
+                if ($value && (! array_key_exists($key, $data) || self::isEmptyValue($data[$key]))) {
+                    $data[$key] = null;
+                }
+
+                continue;
+            }
+            if (! isset($data[$key])) {
+                continue;
+            }
+            if (! is_array($data[$key])) {
+                continue;
+            }
+
+            if (! empty($data[$key]) && array_is_list($data[$key]) && ! array_is_list($value)) {
+                foreach ($data[$key] as &$item) {
+                    if (! is_array($item)) {
+                        continue;
+                    }
+
+                    // as in resolveMatchCriteria(): typed rows look their map up by block type,
+                    // rows without a type (addresses) use the container's own map
+                    if (isset($item['type'])) {
+                        if (isset($value[$item['type']])) {
+                            $this->applyClearableItems($item, $value[$item['type']]);
+                        }
+
+                        continue;
+                    }
+
+                    $this->applyClearableItems($item, $value);
+                }
+                unset($item);
+            } else {
+                $this->applyClearableItems($data[$key], $value);
+            }
+        }
+
+        // anything left over that's empty/null and isn't explicitly marked clearable should never
+        // reach the importer at all, so the existing value it maps to is left completely untouched
+        foreach ($data as $key => $value) {
+            if (array_key_exists($key, $clearableItems) && $clearableItems[$key] !== null) {
+                continue;
+            }
+
+            if (self::isEmptyValue($value)) {
+                unset($data[$key]);
+            }
+        }
+    }
+
+    /**
+     * Determines whether a value should be treated as "empty" for the purposes of clearableItems.
+     */
+    private static function isEmptyValue(mixed $value): bool
+    {
+        if ($value === null) {
+            return true;
+        }
+
+        if (is_string($value)) {
+            return trim($value) === '';
+        }
+
+        if (is_array($value)) {
+            return $value === [];
+        }
+
+        return false;
+    }
+
+    /**
+     * Reads and formats the importer's source file, then imports each item one by one,
+     * synchronously. Queued imports go through `dispatchImport()` instead.
+     *
+     * @param  BaseImporter  $importer  The importer to use.
+     */
+    public function import(BaseImporter $importer): void
+    {
+        $importer->validateSettings();
+
+        $filePath = BaseImporter::resolvedFilePath($importer->file);
+        $matchCriteria = ImportHelper::normalizeMatchCriteriaFromImporterConfig($importer);
+
+        foreach ($this->getFormattedData($filePath) as $item) {
+            $this->importItem($importer, $item, $matchCriteria);
+        }
+    }
+
+    // //////////// data //////////////
+    /**
+     * Returns a file's raw contents, throwing if the read fails or the file is empty.
+     *
+     * @param  string  $filePath  The path to the file to read.
+     */
+    public function getRawData(string $filePath): string
+    {
+        error_clear_last();
+        $rawData = @file_get_contents($filePath);
+        $error = error_get_last();
+        if ($error) {
+            throw new Exception($error['message']);
+        }
+
+        if (! $rawData) {
+            throw new Exception('Unable to parse data.');
+        }
+
+        return $rawData;
+    }
+
+    /**
+     * Reads raw file data and formats it via the appropriate data type.
+     * Return the formatted data, throws on failure.
+     *
+     * @param  string  $filePath  The path to the file to read and format.
+     */
+    public function getFormattedData(string $filePath): array
+    {
+        $rawData = $this->getRawData($filePath);
+
+        // process raw data based on the file type it came from
+        $data = $this->formatData($filePath, $rawData);
+
+        if ($data === null || $data['success'] === false) {
+            throw new Exception($data['error'] ?? 'Unable to parse data.');
+        }
+
+        return $data['data'];
+    }
+
+    /**
+     * Determines the data type from the file extension and delegates formatting to that type's `format()`, logging and returning null on error.
+     */
+    private function formatData(string $filePath, string $rawData): ?array
+    {
+        $extension = File::extension($filePath);
+        $dataTypes = $this->getAllDataTypes();
+
+        if (! isset($dataTypes[$extension])) {
+            throw new Exception('Unsupported data type: '.$extension);
+        }
+
+        try {
+            $data = $dataTypes[$extension]::format($rawData);
+        } catch (Throwable $e) {
+            ImportLog::error($e->getMessage());
+
+            return null;
+        }
+
+        return $data;
+    }
+
+    /**
+     * Reads raw file data and returns the source column headings (prefixed with a "Please select" placeholder), logging and returning null on error.
+     *
+     * @param  string  $filePath  The path to the file to read.
+     */
+    public function getDataHeadings(string $filePath): ?array
+    {
+        $rawData = $this->getRawData($filePath);
+        $extension = File::extension($filePath);
+        $dataTypes = $this->getAllDataTypes();
+
+        if (! isset($dataTypes[$extension])) {
+            throw new Exception('Unsupported data type: '.$extension);
+        }
+
+        try {
+            $headings = $dataTypes[$extension]::getHeadings($rawData);
+        } catch (Throwable $e) {
+            ImportLog::error($e->getMessage());
+
+            return null;
+        }
+
+        return array_merge([['label' => 'Please select', 'value' => '']], $headings);
+    }
+
+    /**
+     * Runs a Fractal transformer over the raw item data (with config/element as meta) and returns the transformed array.
+     *
+     * @param  BaseImporter  $importer  The importer config providing the transformer.
+     * @param  array  $data  The raw item data to transform.
+     * @param  mixed  $element  The element associated with the item, if any.
+     */
+    final public function processData(BaseImporter $importer, array $data, mixed $element): array
+    {
+        // turn the data from the json/csv/xml file into a fractal collection
+        $resource = new Item($data, $importer->transformer);
+        $resource->setMeta(['config' => $importer, 'element' => $element]);
+
+        // Load Fractal
+        $fractalManager = new Manager;
+        $fractalManager->setSerializer(new DataArraySerializer);
+
+        //        // Parse includes/excludes
+        //        $fractalManager->parseIncludes($includes);
+        //        $fractalManager->parseExcludes($excludes);
+
+        $fractalData = $fractalManager->createData($resource);
+
+        // note: ->toArray() freaks out if the transformer is null; not sure if that's expected or not
+        if ($fractalData->getResource()->getTransformer() === null) {
+            return $fractalData->getResource()->getData();
+        }
+
+        $data = $fractalData->toArray();
+
+        return $data['data'];
+    }
+}
diff --git a/src/Import/ImportLog.php b/src/Import/ImportLog.php
new file mode 100644
index 00000000000..1e52b894116
--- /dev/null
+++ b/src/Import/ImportLog.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import;
+
+use Illuminate\Container\Attributes\Singleton;
+use Illuminate\Support\Facades\Log;
+
+#[Singleton]
+class ImportLog
+{
+    /**
+     * Logs an info-level message to the `import` log channel.
+     *
+     * @param  string  $message  The message to log.
+     * @param  array  $context  Additional context data for the log entry.
+     */
+    public function info(string $message, array $context = []): void
+    {
+        Log::channel('import')->info($message, $context);
+    }
+
+    /**
+     * Logs a warning-level message to the `import` log channel.
+     *
+     * @param  string  $message  The message to log.
+     * @param  array  $context  Additional context data for the log entry.
+     */
+    public function warning(string $message, array $context = []): void
+    {
+        Log::channel('import')->warning($message, $context);
+    }
+
+    /**
+     * Logs an error-level message to the `import` log channel.
+     *
+     * @param  string  $message  The message to log.
+     * @param  array  $context  Additional context data for the log entry.
+     */
+    public function error(string $message, array $context = []): void
+    {
+        Log::channel('import')->error($message, $context);
+    }
+}
diff --git a/src/Import/ImportServiceProvider.php b/src/Import/ImportServiceProvider.php
new file mode 100644
index 00000000000..9014f1b9220
--- /dev/null
+++ b/src/Import/ImportServiceProvider.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import;
+
+use CraftCms\Cms\Asset\Commands\ImportAsset;
+use CraftCms\Cms\Entry\Commands\ImportEntry;
+use CraftCms\Cms\SystemMessage\Commands\ImportSystemMessage;
+use CraftCms\Cms\User\Commands\ImportUser;
+use Illuminate\Support\ServiceProvider;
+use Override;
+
+class ImportServiceProvider extends ServiceProvider
+{
+    #[Override]
+    public function register(): void
+    {
+        $this->registerLogChannel();
+    }
+
+    /**
+     * Registers the import-related artisan command.
+     */
+    public function boot(): void
+    {
+        $this->commands([
+            ImportAsset::class,
+            ImportEntry::class,
+            ImportUser::class,
+            ImportSystemMessage::class,
+        ]);
+
+    }
+
+    /**
+     * Adds a daily `import` log channel to the logging config if not already defined.
+     */
+    private function registerLogChannel(): void
+    {
+        $channels = config('logging.channels', []);
+
+        if (! isset($channels['import'])) {
+            $channels['import'] = [
+                'driver' => 'daily',
+                'path' => storage_path('logs/import.log'),
+                'level' => 'debug',
+                'days' => 14,
+            ];
+
+            config()->set('logging.channels', $channels);
+        }
+    }
+}
diff --git a/src/Import/Importers/BaseImporter.php b/src/Import/Importers/BaseImporter.php
new file mode 100644
index 00000000000..6268e75f805
--- /dev/null
+++ b/src/Import/Importers/BaseImporter.php
@@ -0,0 +1,543 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Importers;
+
+use Closure;
+use CraftCms\Aliases\Aliases;
+use CraftCms\Cms\Element\Contracts\ElementInterface;
+use CraftCms\Cms\Element\Import\ElementImporter;
+use CraftCms\Cms\Form\Form;
+use CraftCms\Cms\Form\FormContext;
+use CraftCms\Cms\Import\Transformers\BaseTransformer;
+use CraftCms\Cms\Support\Arr;
+use CraftCms\Cms\Support\Facades\Import;
+use CraftCms\Cms\Support\ImportHelper;
+use CraftCms\Cms\Support\Json as JsonSupport;
+use CraftCms\Cms\Support\Str;
+use http\Exception\InvalidArgumentException;
+use Illuminate\Http\File;
+use Illuminate\Support\Facades\Validator as ValidatorFacade;
+use Illuminate\Validation\ValidationException;
+use Illuminate\Validation\Validator;
+
+use function CraftCms\Cms\t;
+
+abstract class BaseImporter
+{
+    public protected(set) ?string $file = null;
+
+    public protected(set) string|BaseTransformer|null $transformer = null;
+
+    public protected(set) ?int $batchSize = null;
+
+    public protected(set) array $map = [];
+
+    /**
+     * @var Closure|array|null
+     *
+     * array => key is what to import into (e.g. a field handle or attribute name)
+     *  value is the name/key/property from the incoming data;
+     *  by default, [id => id] is used, meaning elements are matched on their ID, and we expect an 'id' key in the provided data;
+     *  example: ['plainText' => 'myPlainText'] means that you have a plainText field in you field layout or column in your table
+     *    and you want to import the value of 'myPlainText' column/property from the incoming csv/json/xml;
+     *  the array can be multidimensional;
+     *  the value should be the name/key/property from the incoming data - it should not be adjusted for mapping at this stage;
+     *
+     *  null => don't match against existing elements; import all incoming data as new
+     */
+    public protected(set) ?array $matchCriteria = null;
+
+    /**
+     * @var array|null
+     *
+     * array => key is the field/attribute handle to clear when the incoming data doesn't provide a value for it
+     *  (or provides an empty one); value is truthy (1/true) to mark it as clearable;
+     *  the array can be multidimensional to reach into container fields, mirroring $matchCriteria's shape;
+     *  for convenience, file-based configs may instead provide a flat list of dot-notation handles
+     *  (e.g. ['heading', 'body']), which gets normalized into the nested truthy-leaf shape;
+     *
+     *  null => nothing is cleared; missing/empty incoming values are left untouched
+     */
+    public protected(set) ?array $clearableItems = null;
+
+    public ?string $uid = null;
+
+    /**
+     * Sets `$this->uid` from a config array if provided.
+     *
+     * @param  array|null  $config  Optional config array, potentially containing a `uid` key.
+     */
+    public function __construct(?array $config = null)
+    {
+        if (! empty($config)) {
+            $this->uid = $config['uid'] ?? null;
+            $this->file($config['file']);
+            $this->transformer($config['transformer'] ?? null);
+            $this->batchSize($config['batchSize'] ?? null);
+
+            $settings = $config['settings'] ?? [];
+            if (is_string($settings)) {
+                $settings = JsonSupport::decode($settings);
+            }
+
+            foreach ($settings as $setting => $value) {
+                if (method_exists($this, $setting)) {
+                    $reflection = new \ReflectionMethod($this, $setting);
+                    if ($reflection->isPublic()) {
+                        $this->{$setting}($value);
+                    }
+                }
+            }
+
+            // an element type whose layout isn't chosen through a setting resolves it here, so a
+            // step that has never been saved still knows what it's importing into
+            if ($this instanceof ElementImporter && $this->fieldLayout === null) {
+                $this->resolveDefaultFieldLayout();
+            }
+        }
+    }
+
+    /**
+     * Returns the fixed element type FQCN this importer subclass targets.
+     */
+    abstract public static function targetClass(): string;
+
+    abstract public static function create(): self;
+
+    /**
+     * Returns the display name for the importer.
+     */
+    abstract public static function displayName(): string;
+
+    /**
+     * Defines the type-specific settings nodes and context for this importer form.
+     */
+    abstract public function settingsForm(FormContext $context): array;
+
+    /**
+     * Renders the importer-specific part of the settings form.
+     */
+    abstract public function refreshSettingsForm(array $settings): void;
+
+    /**
+     * Gives importers a chance to store their specific settings.
+     */
+    abstract public function storeSettings(array $settings): void;
+
+    /**
+     * Returns an array of importer-specific settings.
+     */
+    abstract public function getSettings(): array;
+
+    /**
+     * Specifies a default transformer that the importer should use if none is provided.
+     */
+    abstract public static function getDefaultTransformer(): ?string;
+
+    /**
+     * Sets the path to the file that contains the data to be imported.
+     *
+     * @param  string  $file  The file name or path to set.
+     */
+    public function file(string $file): self
+    {
+        if (! static::isFileValid($file)) {
+            throw new InvalidArgumentException('Provided file either doesn’t exist or is not allowed for import.');
+        }
+
+        $this->file = $file;
+
+        return $this;
+    }
+
+    /**
+     * Sets and normalizes the transformer.
+     *
+     * @param  string|null|BaseTransformer  $transformer  The transformer instance, class name, or null value.
+     */
+    public function transformer(string|null|BaseTransformer $transformer): self
+    {
+        $transformer ??= static::getDefaultTransformer();
+        $this->transformer = self::normalizeTransformer($transformer);
+
+        return $this;
+    }
+
+    public function batchSize(?int $batchSize): self
+    {
+        $this->batchSize = $batchSize;
+
+        return $this;
+    }
+
+    /**
+     * Sets the mapping configuration for the importer.
+     *
+     * @param  array  $map  The mapping configuration array.
+     */
+    public function map(array $map): self
+    {
+        $this->map = ImportHelper::decodeRecursive($map);
+
+        return $this;
+    }
+
+    /**
+     * Sets the criteria to be used for matching the element we're importing into
+     * and returns the current instance.
+     *
+     * @param  array|null  $matchCriteria  The criteria to match against.
+     */
+    public function matchCriteria(?array $matchCriteria): self
+    {
+        if ($matchCriteria === null) {
+            $this->matchCriteria = null;
+
+            return $this;
+        }
+
+        $this->matchCriteria = ImportHelper::decodeRecursive($matchCriteria);
+
+        return $this;
+    }
+
+    /**
+     * Sets the field/attribute handles that should be cleared on import when no data is provided
+     * for them or the provided value is empty, and returns the current instance.
+     *
+     * @param  array|null  $clearableItems  The handles to mark as clearable, either as a nested map with truthy
+     *                                      leaves (matching $matchCriteria's shape) or a flat list of dot-notation handles.
+     */
+    public function clearableItems(?array $clearableItems = null): self
+    {
+        if ($clearableItems !== null) {
+            $clearableItems = ImportHelper::decodeRecursive($clearableItems);
+
+            if (array_is_list($clearableItems)) {
+                $clearableItems = Arr::undot(array_fill_keys($clearableItems, true));
+            }
+
+            $this->clearableItems = $clearableItems;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Defines the validation rules for an import step using this importer.
+     */
+    public static function getRules(): array
+    {
+        return array_merge([
+            'file' => [
+                'required',
+                'string',
+                'max:255',
+                fn ($attribute, $value, Closure $fail, Validator $validator) => self::validateFile($value, $attribute, $fail, $validator),
+            ],
+            'transformer' => [
+                'nullable',
+                'string',
+                'max:255',
+                fn ($attribute, $value, Closure $fail, Validator $validator) => self::validateTransformer($value, $attribute, $fail, $validator),
+            ],
+            'batchSize' => ['nullable', 'integer', 'min:0', 'max:1000'],
+        ], static::getSettingsRules());
+    }
+
+    /**
+     * Defines the validation rules for the importer's execution settings, independent of
+     * whether the importer is ever persisted/named (e.g. an ad-hoc CLI-built importer).
+     */
+    public static function getSettingsRules(): array
+    {
+        return [
+            'settings.map' => ['array'],
+            'settings.matchCriteria' => ['nullable', 'array'],
+            'settings.clearableItems' => ['nullable', 'array'],
+        ];
+    }
+
+    /**
+     * Builds the step data array validated by `getRules()`/`getSettingsRules()`, from the importer's current state.
+     */
+    public function toArrayData(): array
+    {
+        return [
+            'uid' => $this->uid,
+            'type' => static::class,
+            'file' => $this->file,
+            'transformer' => $this->transformer instanceof BaseTransformer ? $this->transformer::class : $this->transformer,
+            'settings' => [
+                'map' => $this->map,
+                'matchCriteria' => $this->matchCriteria,
+                'clearableItems' => $this->clearableItems,
+            ],
+        ];
+    }
+
+    /**
+     * Validates the importer's full state.
+     *
+     * @throws ValidationException
+     */
+    public function validate(): void
+    {
+        ValidatorFacade::make($this->toArrayData(), static::getRules())->validate();
+    }
+
+    /**
+     * Validates only the importer's execution settings.
+     *
+     * @throws ValidationException
+     */
+    public function validateSettings(): void
+    {
+        ValidatorFacade::make($this->toArrayData(), static::getSettingsRules())->validate();
+    }
+
+    /**
+     * Validates a provided file based on its existence, MIME type, and compatibility with
+     * the application's expected data types.
+     *
+     * @param  mixed  $value  The file to validate, typically a path or identifier.
+     * @param  string  $attribute  The name of the attribute being validated.
+     * @param  Closure  $fail  A callback function to report validation failures.
+     * @param  Validator  $validator  The validator instance performing the validation.
+     * @param  string|null  $attributeForMessage  Optional. An alternate attribute name for error messages.
+     */
+    public static function validateFile(mixed $value, string $attribute, Closure $fail, Validator $validator, ?string $attributeForMessage = null): bool
+    {
+        if (empty($value)) {
+            $fail(/* $attributeForMessage ?? */ $attribute, t('File must be provided.'));
+            // $validator->errors()->add($attributeForMessage ?? $attribute, t('File must be provided.'));
+
+            return false;
+        }
+
+        $filePath = self::resolvedFilePath($value);
+        if (! file_exists($filePath)) {
+            $fail($attribute, t('File “{filePath}” does not exist.', [
+                'filePath' => $filePath,
+            ]));
+
+            return false;
+        }
+
+        $file = new File($filePath);
+        $dataTypes = array_unique(array_filter(array_keys(Import::getAllDataTypes())));
+
+        // validate file type (e.g. csv, json, xml)
+        $newValidator = ValidatorFacade::make(
+            ['file' => $file],
+            ['file' => ['mimes:'.implode(',', $dataTypes)]]
+        );
+
+        if ($newValidator->fails()) {
+            $fail($attribute, t('Only files with these MIME types are allowed: {mimeTypes}.', [
+                'mimeTypes' => implode(', ', $dataTypes),
+            ]));
+
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Validates the transformer value to ensure it is either empty, a closure, or a valid class compatible with `BaseTransformer`.
+     *
+     * @param  mixed  $value  The value of the transformer being validated.
+     * @param  string  $attribute  The name of the attribute being validated.
+     * @param  Closure  $fail  The callback function to invoke when validation fails.
+     * @param  Validator  $validator  The validator instance performing the validation.
+     */
+    public static function validateTransformer(mixed $value, string $attribute, Closure $fail, Validator $validator): bool
+    {
+        // if it's empty - that's fine (we'll probably use the default ElementTransformer)
+        if (empty($value)) {
+            return true;
+        }
+
+        if (self::normalizeTransformer($value) === null) {
+            $fail($attribute, t('Transformer has to be empty, a valid class or a closure.'));
+
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * No-op base validator for the map setting; always returns true (subclasses override).
+     *
+     * @param  mixed  $value  The value of the map being validated.
+     * @param  string  $attribute  The name of the attribute being validated.
+     * @param  Closure  $fail  The callback function to invoke when validation fails.
+     * @param  Validator  $validator  The validator instance performing the validation.
+     * @param  array  $params  Additional context params for the validation.
+     */
+    public static function validateMap(mixed $value, string $attribute, Closure $fail, Validator $validator, array $params = []): bool
+    {
+        // by default this does nothing
+        return true;
+    }
+
+    /**
+     * Returns the names of the columns/properties/fields that we're importing into.
+     */
+    public function getDestinationCols(): array
+    {
+        return [];
+    }
+
+    /**
+     * Returns the names of the columns/properties that we're importing from (the ones from the data source).
+     */
+    public function getSourceDataCols(): array
+    {
+        return [];
+    }
+
+    /**
+     * No-op base implementation; subclasses override to actually perform the import.
+     *
+     * @param  array  $data  The data for the item being imported.
+     */
+    public function importItem(array $data): void
+    {
+        // by default, this doesn't do anything
+    }
+
+    /**
+     * Returns whether a file is specified and points to an existing, importable file.
+     * It's used e.g. to determine whether an "Edit mapping" button can be shown.
+     *
+     * @param  string|null  $file  The file alias or relative path to check.
+     */
+    public static function isFileValid(?string $file): bool
+    {
+        if (empty($file)) {
+            return false;
+        }
+
+        $filePath = self::resolvedFilePath($file);
+        if (! file_exists($filePath)) {
+            return false;
+        }
+
+        $dataTypes = array_unique(array_filter(array_keys(Import::getAllDataTypes())));
+
+        return ValidatorFacade::make(
+            ['file' => new File($filePath)],
+            ['file' => ['mimes:'.implode(',', $dataTypes)]],
+        )->passes();
+    }
+
+    /**
+     * Resolves the full file path based on the provided file alias or relative path.
+     *
+     * If the provided file path starts with the '@root/' alias, it retrieves the absolute
+     * path using the Aliases service. Otherwise, it constructs the path by appending the
+     * file to the '@root/' alias.
+     *
+     * @param  string|null  $file  The file alias or relative path to be resolved.
+     */
+    public static function resolvedFilePath(?string $file): ?string
+    {
+        if (is_null($file)) {
+            return null;
+        }
+
+        return str_starts_with($file, '@root/') ? Aliases::get($file) : Aliases::get('@root/'.$file);
+    }
+
+    /**
+     * Normalizes a transformer input into a valid BaseTransformer instance, a Closure, or null.
+     *
+     * This method processes various forms of input for transformers, including:
+     * - Instances of BaseTransformer: These are returned as-is.
+     * - Strings: These are evaluated to determine if they refer to a callable function,
+     *   a PHP closure pattern, or a valid BaseTransformer class.
+     * - Null values: These are handled gracefully by returning null.
+     *
+     * If the input defines a callable closure pattern using the `fn` syntax, it generates a Closure
+     * that can evaluate the provided logic against an `ElementInterface` instance. Additionally,
+     * transformer class strings are validated to ensure they refer to a valid BaseTransformer class.
+     *
+     * @param  string|BaseTransformer|null  $transformer  Input transformer to normalize.
+     */
+    private static function normalizeTransformer(string|null|BaseTransformer $transformer): BaseTransformer|Closure|null
+    {
+        if ($transformer instanceof BaseTransformer) {
+            return $transformer;
+        }
+
+        if (empty($transformer)) {
+            return null;
+        }
+
+        if (preg_match('/^fn\s*\(\s*(?:\$(\w+)\s*)?\)\s*=>\s*(.+)/', $transformer, $match)) {
+            $var = $match[1];
+            $php = sprintf('return %s;', Str::chopStart(rtrim($match[2], ';'), 'return '));
+
+            return function (ElementInterface $element) use ($var, $php) {
+                if ($var) {
+                    ${$var} = $element;
+                }
+
+                return eval($php);
+            };
+        }
+
+        if (class_exists($transformer) && (new $transformer) instanceof BaseTransformer) {
+            return new $transformer;
+        }
+
+        return null;
+    }
+
+    /**
+     * Returns the transformer's class name if it's a BaseTransformer instance, otherwise null.
+     */
+    public function transformerAsString(): ?string
+    {
+        if ($this->transformer === null) {
+            return $this->transformer;
+        }
+
+        if ($this->transformer instanceof BaseTransformer) {
+            return $this->transformer::class;
+        }
+
+        return null;
+    }
+
+    public static function isElementImporter(): bool
+    {
+        return false;
+    }
+
+    /**
+     * Returns whether the current transformer is the default one for the element type.
+     */
+    public function usesDefaultTransformer(): bool
+    {
+        $currentTransformer = $this->transformer;
+        $defaultTransformer = static::getDefaultTransformer();
+
+        // if they're simply the same - they're the same
+        if ($currentTransformer === $defaultTransformer) {
+            return true;
+        }
+
+        // if the current transformer is an object and the class matches the default one - they're the same
+        if ($currentTransformer instanceof BaseTransformer && $currentTransformer::class === $defaultTransformer) {
+            return true;
+        }
+
+        return false;
+    }
+}
diff --git a/src/Import/Importers/ModelImporter.php b/src/Import/Importers/ModelImporter.php
new file mode 100644
index 00000000000..586550eabe2
--- /dev/null
+++ b/src/Import/Importers/ModelImporter.php
@@ -0,0 +1,187 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Importers;
+
+use CraftCms\Cms\Form\FormContext;
+use CraftCms\Cms\Shared\BaseModel;
+use CraftCms\Cms\Support\Arr;
+use CraftCms\Cms\Support\Facades\Import;
+use CraftCms\Cms\Support\Html;
+use CraftCms\Cms\Support\ImportHelper;
+use CraftCms\Cms\Support\Query;
+use Illuminate\Support\Facades\Schema;
+use Override;
+
+/**
+ * The ModelImporter should be used for importing data into an eloquent model.
+ * It's abstract - each importable model is represented by its own concrete subclass, which
+ * implements modelClass() to name its target model (see SystemMessageImporter).
+ * A model is importable if and only if a ModelImporter subclass is registered for it, via the
+ * RegisterImporterTypes event.
+ * Element types must use an ElementImporter subclass instead (see EntryImporter, AssetImporter, UserImporter).
+ */
+abstract class ModelImporter extends BaseImporter
+{
+    /**
+     * Maps driver-specific `type_name` values, as reported by `Schema::getColumns()` for
+     * MySQL and PostgreSQL connections, to their equivalent {@see Query::TYPE_*} constant.
+     */
+    private const array TYPE_ALIASES = [
+        // MySQL
+        'int' => Query::TYPE_INTEGER,
+        'mediumint' => Query::TYPE_INTEGER,
+
+        // PostgreSQL
+        'int2' => Query::TYPE_SMALLINT,
+        'int4' => Query::TYPE_INTEGER,
+        'int8' => Query::TYPE_BIGINT,
+        'bpchar' => Query::TYPE_CHAR,
+        'numeric' => Query::TYPE_DECIMAL,
+        'float4' => Query::TYPE_FLOAT,
+        'float8' => Query::TYPE_DOUBLE,
+        'bool' => Query::TYPE_BOOLEAN,
+        'timestamptz' => Query::TYPE_TIMESTAMP,
+        'timetz' => Query::TYPE_TIME,
+
+        // MySQL and PostgreSQL
+        'varchar' => Query::TYPE_STRING,
+    ];
+
+    #[Override]
+    public function settingsForm(FormContext $context = new FormContext): array
+    {
+        return [];
+    }
+
+    #[Override]
+    public function refreshSettingsForm(array $settings): void {}
+
+    #[Override]
+    public function storeSettings(array $settings): void {}
+
+    #[Override]
+    public function getSettings(): array
+    {
+        return [];
+    }
+
+    #[Override]
+    public static function getDefaultTransformer(): ?string
+    {
+        return null;
+    }
+
+    #[Override]
+    public function getDestinationCols(): array
+    {
+        $columns = Schema::getColumns((new (static::targetClass()))->getTable());
+
+        return array_map(fn ($col) => [
+            'handle' => $col['name'],
+            'label' => $col['name'],
+            'prefixedHandleForMap' => Html::namespaceInputName($col['name'], 'map'),
+            'prefixedHandleForMatchCriteria' => Html::namespaceInputName($col['name'], 'matchCriteria'),
+            'prefixedHandleForClear' => Html::namespaceInputName($col['name'], 'clearableItems'),
+            'prefixedHandle' => $col['name'],
+            'prefixedHandleAsArray' => Arr::bracketsToArray($col['name']),
+            'isContainer' => false,
+            'canBeMatchCriteria' => $this->isTypeMatchable($col['type_name']),
+            'canBeCleared' => $col['nullable'],
+            // 'isProperty' => true,
+        ], $columns);
+    }
+
+    #[Override]
+    public function getSourceDataCols(): array
+    {
+        $filePath = BaseImporter::resolvedFilePath($this->file);
+
+        // a config can be saved before its file is chosen, and the map screen still renders
+        if ($filePath === null) {
+            return [];
+        }
+
+        return Import::getDataHeadings($filePath);
+    }
+
+    #[Override]
+    public function importItem(array $data): void
+    {
+        $model = $this->getModel($data);
+        $isNew = ! $model->exists;
+
+        $item = Import::processData($this, $data, $model);
+
+        // at this stage the $item contains the keys that have been run through the remapData() helper,
+        // so all the UI-based mapping is taken into consideration;
+        // we now want to compose an array of key-value pairs where the keys are the properties that are available on the element
+        // and the values are the raw values from the incoming data;
+        $incomingKeys = array_combine(array_keys($item), array_keys($item));
+        $incomingKeys = array_map(fn ($key) => ImportHelper::prepKeyForAutoMatching((string) $key), $incomingKeys);
+
+        $attributeHandles = Schema::getColumnListing($model->getTable());
+        $attributes = [];
+
+        // and this is where auto-magical mapping happens between what's in the incoming data and in the field layout element handles
+        foreach ($attributeHandles as $attributeHandle) {
+            // if it exists, then it was either mapped like this or the "correct" key already existed in the incoming data
+            // use it and remove it from a list of keys we can mess with in the next step
+            if (array_key_exists((string) $attributeHandle, $item)) {
+                $attributes[$attributeHandle] = $item[$attributeHandle];
+                unset($incomingKeys[$attributeHandle]);
+                // otherwise attempt to match auto-magically
+            } elseif ($key = array_search(ImportHelper::prepKeyForAutoMatching((string) $attributeHandle), $incomingKeys)) {
+                $attributes[$attributeHandle] = $item[$key];
+            }
+        }
+        // $attributes = array_filter(array_filter($item, fn ($value, $key) => in_array($key, $attributeHandles), ARRAY_FILTER_USE_BOTH));
+
+        $model->fill($attributes);
+
+        if ($isNew || $model->isDirty()) {
+            $model->save();
+        }
+    }
+
+    /**
+     * Returns whether a given DB column type can be used to value being imported against the value in the database.
+     * You can match on text, numeric, boolean, and date/time values.
+     */
+    private function isTypeMatchable(string $type): bool
+    {
+        $type = self::TYPE_ALIASES[$type] ?? $type;
+
+        return in_array(Query::getSimplifiedColumnType($type), [Query::SIMPLE_TYPE_NUMERIC, Query::SIMPLE_TYPE_TEXTUAL]) ||
+            in_array($type, [Query::TYPE_BOOLEAN, Query::TYPE_DATETIME, Query::TYPE_DATE, Query::TYPE_TIME, Query::TYPE_TIMESTAMP], true);
+    }
+
+    /**
+     * Creates a new model or looks up an existing one via a match-criteria `where()` query.
+     */
+    private function getModel(array $data): BaseModel
+    {
+        $model = new (static::targetClass());
+
+        // if null then return a brand new model
+        if (! isset($data['matchCriteria'])) {
+            return $model;
+        }
+
+        if (is_array($data['matchCriteria'])) {
+            $criteria = $data['matchCriteria'];
+
+            if (empty($criteria)) {
+                return $model;
+            }
+
+            $query = $model::query()
+                ->where($criteria);
+
+            return $query->first() ?? $model;
+        }
+
+        return $model;
+    }
+}
diff --git a/src/Import/Imports.php b/src/Import/Imports.php
new file mode 100644
index 00000000000..b11c697a762
--- /dev/null
+++ b/src/Import/Imports.php
@@ -0,0 +1,300 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import;
+
+use CraftCms\Cms\Database\Table;
+use CraftCms\Cms\Import\Data\Import as ImportData;
+use CraftCms\Cms\Import\Events\ImportSaved;
+use CraftCms\Cms\Import\Events\ImportSaving;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use CraftCms\Cms\Import\Models\Import as ImportModel;
+use CraftCms\Cms\Support\Facades\ImportLog;
+use CraftCms\Cms\Support\Str;
+use Illuminate\Container\Attributes\Singleton;
+use Illuminate\Database\Query\Builder;
+use Illuminate\Support\Collection as LaravelCollection;
+use Illuminate\Support\Facades\Config;
+use Illuminate\Support\Facades\DB;
+use Throwable;
+
+#[Singleton]
+class Imports
+{
+    /**
+     * @param  LaravelCollection|null  $imports  The cached collection of imports.
+     */
+    public function __construct(
+        private ?LaravelCollection $imports = null,
+    ) {}
+
+    /**
+     * Instantiates an importer from an import step, applying its properties and decoded
+     * settings via setter methods.
+     *
+     * @param  array  $step  The step array, shaped `{uid, type, file, transformer, settings}`.
+     */
+    public static function createImporter(array $step): ?BaseImporter
+    {
+        try {
+            return new $step['type']($step);
+        } catch (Throwable) {
+            return null;
+        }
+    }
+
+    /**
+     * Lazily loads/caches all imports, merging DB-stored imports with the file-based
+     * `craft.import` config, keyed by handle and sorted by name.
+     */
+    public function getAllImports(): LaravelCollection
+    {
+        if ($this->imports === null) {
+            $dbImports = array_map(
+                fn ($row) => new ImportData((array) $row + ['editable' => true]),
+                $this->_importQuery()->get()->all(),
+            );
+
+            $fileImports = array_filter(array_map(function ($fileImport) {
+                $fileImport = $fileImport();
+
+                if (! $fileImport->validate()) {
+                    ImportLog::warning("Skipping invalid file-based import \"{$fileImport->handle}\": ".implode(' ', $fileImport->errors()->all()));
+
+                    return null;
+                }
+
+                return $fileImport;
+            }, Config::get('craft.import', [])));
+
+            $this->imports = new LaravelCollection($dbImports + $fileImports)
+                ->keyBy(fn (ImportData $item, $key) => $item->handle ?? $key)
+                ->sortBy('name');
+        }
+
+        return $this->imports;
+    }
+
+    /**
+     * Filters all imports down to editable (DB-backed) ones.
+     */
+    public function getEditableImports(): LaravelCollection
+    {
+        return $this->getAllImports()->filter(fn (ImportData $import) => $import->isEditable());
+    }
+
+    /**
+     * Filters all imports down to non-editable (file-based) ones.
+     */
+    public function getNonEditableImports(): LaravelCollection
+    {
+        return $this->getAllImports()->reject(fn (ImportData $import) => $import->isEditable());
+    }
+
+    /**
+     * Looks up an import by handle, optionally restricted to editable imports.
+     *
+     * Falls back to querying the DB directly while the cache is still being built, so that
+     * validating a file-based import — which checks its handle against the saved ones —
+     * doesn't re-enter `getAllImports()`.
+     *
+     * @param  string|null  $handle  The import handle to look up.
+     * @param  bool  $editableOnly  Whether to restrict the lookup to editable imports.
+     */
+    public function getImportByHandle(?string $handle, bool $editableOnly = false): ?ImportData
+    {
+        if (is_null($handle)) {
+            return null;
+        }
+
+        if ($this->imports !== null) {
+            /** @var ImportData|null */
+            return ($editableOnly ? $this->getEditableImports() : $this->getAllImports())
+                ->where('handle', $handle)
+                ->first();
+        }
+
+        $row = $this->_importQuery()->where('handle', $handle)->first();
+        if ($row !== null) {
+            return new ImportData((array) $row + ['editable' => true]);
+        }
+
+        if ($editableOnly) {
+            return null;
+        }
+
+        /** @var ImportData|null */
+        return $this->getNonEditableImports()->where('handle', $handle)->first();
+    }
+
+    /**
+     * Looks up an import by UID, optionally restricted to editable imports.
+     *
+     * @param  string  $uid  The UID of the import to look up.
+     * @param  bool  $editableOnly  Whether to restrict the lookup to editable imports.
+     */
+    public function getImportByUid(string $uid, bool $editableOnly = false): ?ImportData
+    {
+        if ($this->imports !== null) {
+            /** @var ImportData|null */
+            return ($editableOnly ? $this->getEditableImports() : $this->getAllImports())
+                ->where('uid', $uid)
+                ->first();
+        }
+
+        $row = $this->_importQuery()->where('uid', $uid)->first();
+        if ($row !== null) {
+            return new ImportData((array) $row + ['editable' => true]);
+        }
+
+        if ($editableOnly) {
+            return null;
+        }
+
+        /** @var ImportData|null */
+        return $this->getAllImports()->where('uid', $uid)->first();
+    }
+
+    /**
+     * Fires a saving event, validates the import, persists it to the imports table inside a
+     * transaction, invalidates the imports cache, then fires a saved event.
+     *
+     * @param  ImportData  $import  The import to save.
+     */
+    public function saveImport(ImportData $import): bool
+    {
+        $isNewImport = ! $import->uid;
+
+        event($event = new ImportSaving($import, $isNewImport));
+
+        if (! $event->isValid) {
+            return false;
+        }
+
+        $import = $event->import;
+
+        if (! $import->validate()) {
+            return false;
+        }
+
+        if ($isNewImport) {
+            $import->uid = Str::uuid7()->toString();
+        }
+
+        $importRecord = $this->_getImportModel($import->uid);
+
+        DB::beginTransaction();
+
+        try {
+            $importRecord->uid = $import->uid;
+            $importRecord->name = $import->name;
+            $importRecord->handle = $import->handle;
+            $importRecord->description = $import->description;
+            $importRecord->steps = $import->serializeSteps();
+
+            $importRecord->save();
+
+            DB::commit();
+        } catch (Throwable $e) {
+            DB::rollBack();
+
+            throw $e;
+        }
+
+        // invalidate caches
+        $this->imports = null;
+
+        event(new ImportSaved($import, $isNewImport));
+
+        return true;
+    }
+
+    /**
+     * Duplicates an editable import, giving the copy a fresh handle and step UIDs.
+     */
+    public function duplicateImport(ImportData $import): void
+    {
+        $importRecord = $this->_getImportModel($import->uid);
+
+        // if we couldn't find it - return
+        if (! $importRecord->exists) {
+            return;
+        }
+
+        $newImport = $importRecord->replicate();
+        $newImport->uid = Str::uuid7()->toString();
+        $newImport->steps = array_map(function (array $step): array {
+            $step['uid'] = Str::uuid7()->toString();
+
+            return $step;
+        }, $importRecord->steps ?? []);
+
+        if (preg_match('/^(.*?)(\d+)$/', (string) $newImport->handle, $match)) {
+            $baseHandle = $match[1];
+            $i = (int) $match[2];
+        } else {
+            $baseHandle = $newImport->handle;
+            $i = 1;
+        }
+        do {
+            $testHandle = sprintf('%s%s', $baseHandle, ++$i);
+            if (! $this->getImportByHandle($testHandle)) {
+                $newImport->handle = $testHandle;
+                break;
+            }
+        } while (true);
+
+        $newImport->save();
+
+        // invalidate caches
+        $this->imports = null;
+    }
+
+    /**
+     * Soft-deletes the DB record for an import and invalidates the imports cache.
+     *
+     * @param  ImportData  $import  The import to delete.
+     */
+    public function deleteImport(ImportData $import): void
+    {
+        $importRecord = $this->_getImportModel($import->uid);
+
+        if (! $importRecord->exists) {
+            return;
+        }
+
+        $importRecord->delete();
+
+        // invalidate caches
+        $this->imports = null;
+    }
+
+    /**
+     * Returns an import model for a given UID
+     */
+    private function _getImportModel(string $uid, bool $withTrashed = false): ImportModel
+    {
+        return ImportModel::withTrashed($withTrashed)
+            ->where('uid', $uid)
+            ->first() ?? new ImportModel;
+    }
+
+    /**
+     * Builds the base query for selecting non-deleted rows from the imports table.
+     */
+    private function _importQuery(): Builder
+    {
+        return DB::table(Table::IMPORTS)
+            ->select([
+                'name',
+                'handle',
+                'description',
+                'steps',
+                'imports.uid',
+            ])
+            ->orderBy('name')
+            ->orderBy('handle')
+            ->whereNull('dateDeleted');
+    }
+}
diff --git a/src/Import/Jobs/Import.php b/src/Import/Jobs/Import.php
new file mode 100644
index 00000000000..3e2f10dd0ed
--- /dev/null
+++ b/src/Import/Jobs/Import.php
@@ -0,0 +1,137 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Jobs;
+
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use CraftCms\Cms\Queue\Job;
+use CraftCms\Cms\Support\Facades\Import as ImportFacade;
+use CraftCms\Cms\Support\Facades\ImportLog;
+use CraftCms\Cms\Support\Facades\Imports;
+use CraftCms\Cms\Support\ImportHelper;
+use Illuminate\Bus\Batchable;
+use Illuminate\Validation\ValidationException;
+use Override;
+
+use function CraftCms\Cms\t;
+
+class Import extends Job
+{
+    use Batchable;
+
+    private int $defaultBatchSize = 5;
+
+    /**
+     * Promotes the owning import's UID/handle, the step's UID, the file path and the starting
+     * offset, then calls the parent constructor.
+     *
+     * @param  string  $importId  The UID (or, for file-based imports, the handle) of the import.
+     * @param  string  $stepUid  The UID of the step being run.
+     * @param  string  $filePath  The path to the file being imported.
+     * @param  int  $start  The offset to start processing from.
+     */
+    public function __construct(
+        private readonly string $importId,
+        private readonly string $stepUid,
+        private readonly string $filePath,
+        private readonly int $start = 0,
+    ) {
+        parent::__construct();
+    }
+
+    #[Override]
+    protected function defaultDescription(): string
+    {
+        return t('Importing data (import job)');
+    }
+
+    /**
+     * Execute the job.
+     */
+    public function handle(): void
+    {
+        if ($this->batch()->cancelled()) {
+            return;
+        }
+
+        $import = Imports::getImportByUid($this->importId) ?? Imports::getImportByHandle($this->importId);
+
+        if ($import === null) {
+            ImportLog::warning("Skipping import job for missing import \"{$this->importId}\".");
+
+            return;
+        }
+
+        $step = collect($import->steps ?? [])->firstWhere('uid', $this->stepUid);
+
+        if ($step === null) {
+            ImportLog::warning("Skipping import job for missing step \"{$this->stepUid}\" of import \"{$import->name}\".");
+
+            return;
+        }
+
+        $stepLabel = ImportFacade::stepLabel($import, $step);
+
+        try {
+            $step->validateSettings();
+        } catch (ValidationException $e) {
+            ImportLog::warning("Skipping import job for invalid step \"$stepLabel\": ".implode(' ', $e->validator->errors()->all()));
+
+            return;
+        }
+
+        // get all the data
+        $allData = ImportFacade::getFormattedData($this->filePath);
+        // discard the part at the start that was already processed
+        $data = array_slice($allData, $this->start);
+        // count how many items we have to process
+        $dataCount = count($data);
+        // figure out our batch limit
+        $batchLimit = $this->getBatchSize($step);
+
+        // normalizing the UI/config-based matchCriteria only depends on the importer, so it
+        // could be done once per step rather than for each root item that is being imported
+        $matchCriteria = ImportHelper::normalizeMatchCriteriaFromImporterConfig($step);
+
+        // if batch limit is 0, it means this step's batch size was set to zero to disable batching of this step
+        // so we want to go through all the data in one go
+        if ($batchLimit === 0) {
+            $batchLimit = $dataCount;
+        }
+
+        for ($i = 0; $i < $batchLimit; $i++) {
+            // if we have less data than the limit, break
+            if (! isset($data[$i])) {
+                break;
+            }
+
+            // import data
+            try {
+                ImportFacade::importItem($step, $data[$i], $matchCriteria);
+            } catch (\Exception $e) {
+                // log and proceed further
+                ImportLog::warning('Couldn’t import a data item because of the following error: '.$e->getMessage(), ['step' => $stepLabel, 'data' => $data[$i]]);
+            }
+        }
+
+        // if there's any data items left - add another job to the batch
+        if ($dataCount - $batchLimit > 0) {
+            $this->batch()->add(new Import($this->importId, $this->stepUid, $this->filePath, ($this->start + $batchLimit)));
+        }
+    }
+
+    /**
+     * Returns the step's configured batch size, or the default batch size if null.
+     */
+    private function getBatchSize(BaseImporter $step): int
+    {
+        // if batch size was left empty, it was cast to a null, and we should use the default batch size
+        if (($step->batchSize ?? null) === null) {
+            return $this->defaultBatchSize;
+        }
+
+        // otherwise, return the number specified in the step
+        return $step->batchSize;
+    }
+}
diff --git a/src/Import/Jobs/ImportPipeline.php b/src/Import/Jobs/ImportPipeline.php
new file mode 100644
index 00000000000..4c66555806b
--- /dev/null
+++ b/src/Import/Jobs/ImportPipeline.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Jobs;
+
+use CraftCms\Cms\Import\Data\Import as ImportData;
+use CraftCms\Cms\Queue\Job;
+use Illuminate\Support\Facades\Bus;
+use Override;
+
+use function CraftCms\Cms\t;
+
+class ImportPipeline extends Job
+{
+    /**
+     * Promotes steps and import, then calls the parent constructor.
+     *
+     * @param  array  $steps  The steps to run in this pipeline.
+     * @param  ImportData  $import  The import this pipeline belongs to.
+     */
+    public function __construct(
+        public array $steps,
+        public ImportData $import,
+    ) {
+        parent::__construct();
+    }
+
+    /**
+     * Execute the job.
+     */
+    public function handle(): void
+    {
+        // each batch should `allowFailures()`
+        // so that we don't cancel the batch when one job failed
+        // maybe this should be customisable?
+        // https://laravel.com/docs/13.x/queues#allowing-failures
+        $steps = [];
+        foreach ($this->steps as $step) {
+            $steps[] = Bus::batch([$step['job']])->name($step['name'] ?? 'Importing step data')->allowFailures();
+        }
+
+        if (! empty($steps)) {
+            Bus::chain($steps)->dispatch();
+        }
+    }
+
+    #[Override]
+    protected function defaultDescription(): string
+    {
+        return t("Importing “{$this->import->name}” data");
+    }
+}
diff --git a/src/Import/Models/Import.php b/src/Import/Models/Import.php
new file mode 100644
index 00000000000..c22f16fa99c
--- /dev/null
+++ b/src/Import/Models/Import.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Models;
+
+use CraftCms\Cms\Database\Table;
+use CraftCms\Cms\Shared\BaseModel;
+use CraftCms\Cms\Shared\Concerns\HasUid;
+use Illuminate\Database\Eloquent\SoftDeletes;
+use Override;
+
+class Import extends BaseModel
+{
+    use HasUid;
+    use SoftDeletes;
+
+    #[Override]
+    protected $table = Table::IMPORTS;
+
+    #[Override]
+    protected function casts(): array
+    {
+        return [
+            'steps' => 'json',
+        ];
+    }
+}
diff --git a/src/Import/Transformers/BaseTransformer.php b/src/Import/Transformers/BaseTransformer.php
new file mode 100644
index 00000000000..f95ba72bc3f
--- /dev/null
+++ b/src/Import/Transformers/BaseTransformer.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Import\Transformers;
+
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use League\Fractal\TransformerAbstract;
+
+abstract class BaseTransformer extends TransformerAbstract
+{
+    /**
+     * No-op base hook for subclasses to supply extra match criteria to complement/override
+     * the ones coming from the UI/config file and the data.
+     *
+     * Returns already resolved additional match criteria.
+     *
+     * Meaning it needs to contain the key-value pairs where
+     * the key is the property, field handle or column name in the system,
+     * and the value is the actual value to use when matching
+     * (NOT the handle used to locate the data in the incoming dataset).
+     *
+     * It can be used to do any sort of computations before deciding on what to return,
+     * or, if needed for any reason, it could be a simple pass-through,
+     * like: return ['myFieldHandle' => $data['myIncomingKey']];
+     *
+     * @param  BaseImporter  $importer  The importer configuration.
+     * @param  array  $data  The data being imported.
+     */
+    public function additionalMatchCriteria(BaseImporter $importer, array $data): array
+    {
+        // you can set your match criteria here, instead of using the UI;
+        // by default, this doesn't do anything
+        return [];
+    }
+}
diff --git a/src/Providers/CraftServiceProvider.php b/src/Providers/CraftServiceProvider.php
index 31264ab1e10..574fd84600c 100644
--- a/src/Providers/CraftServiceProvider.php
+++ b/src/Providers/CraftServiceProvider.php
@@ -17,6 +17,7 @@
 use CraftCms\Cms\Field\FieldsServiceProvider;
 use CraftCms\Cms\FieldLayout\FieldLayoutServiceProvider;
 use CraftCms\Cms\Gql\GqlServiceProvider;
+use CraftCms\Cms\Import\ImportServiceProvider;
 use CraftCms\Cms\License\LicenseServiceProvider;
 use CraftCms\Cms\Plugin\PluginServiceProvider;
 use CraftCms\Cms\ProjectConfig\ProjectConfigServiceProvider;
@@ -63,5 +64,6 @@ class CraftServiceProvider extends AggregateServiceProvider
         EntryServiceProvider::class,
         StructureServiceProvider::class,
         QueueServiceProvider::class,
+        ImportServiceProvider::class,
     ];
 }
diff --git a/src/Support/Arr.php b/src/Support/Arr.php
index 637c4b8f771..2cce03e4290 100644
--- a/src/Support/Arr.php
+++ b/src/Support/Arr.php
@@ -271,6 +271,11 @@ public static function containsRecursive(iterable $array, callable|string $key,
         return false;
     }
 
+    /**
+     * Normalizes the key from bracket notation into dot notation.
+     * `foo[bar][baz]` => `foo.bar.baz`
+     * The opposite of `undotifyKey`.
+     */
     public static function dotifyKey(int|string $key): string|int
     {
         // Normalize the key into dot notation
@@ -280,4 +285,92 @@ public static function dotifyKey(int|string $key): string|int
 
         return $key;
     }
+
+    /**
+     * Normalizes the key from dot notation into bracket notation.
+     * `foo.bar.baz` => `foo[bar][baz]`
+     * The opposite of `dotifyKey`.
+     */
+    public static function undotifyKey(int|string $key): string|int
+    {
+        if (is_string($key) && str_contains($key, '.')) {
+            $parts = explode('.', $key);
+            $first = array_shift($parts);
+
+            return $first.'['.implode('][', $parts).']';
+        }
+
+        return $key;
+    }
+
+    /**
+     * Normalizes the string from bracket notation into an array.
+     * `foo[bar][baz]` => `['foo', 'bar', 'baz']`
+     */
+    public static function bracketsToArray(string $string): array
+    {
+        return $string
+                |> (fn ($v) => str_replace(']', '', $v))
+                |> (fn ($v) => explode('[', (string) $v));
+    }
+
+    /**
+     * Returns an array of unique dot-notated keys from a given multidimensional array.
+     */
+    public static function uniqueDotifiedKeys(array $array, string $prepend = ''): array
+    {
+        $keys = [];
+
+        foreach ($array as $key => $value) {
+            $isListItem = is_int($key);
+            $path = $isListItem
+                ? $prepend
+                : ($prepend === '' ? (string) $key : $prepend.'.'.$key);
+
+            if (! $isListItem && $path !== '') {
+                $keys[] = $path;
+            }
+
+            if (is_array($value)) {
+                $keys = array_merge($keys, self::uniqueDotifiedKeys($value, $path));
+            }
+        }
+
+        return array_values(array_unique($keys));
+    }
+
+    /**
+     * Returns the value at a dot-notated key produced by `uniqueDotifiedKeys()`, descending into
+     * the first element of any list encountered (mirroring that method's own list transparency).
+     *
+     * @param  array<array-key, mixed>  $array
+     */
+    public static function sampleValueAtDotifiedKey(array $array, string $key): mixed
+    {
+        $value = $array;
+
+        foreach (explode('.', $key) as $segment) {
+            $value = self::firstListElement($value);
+
+            if (! is_array($value) || ! array_key_exists($segment, $value)) {
+                return null;
+            }
+
+            $value = $value[$segment];
+        }
+
+        return self::firstListElement($value);
+    }
+
+    /**
+     * Descends into the first element of a list, repeating until the value isn't a list.
+     */
+    private static function firstListElement(mixed $value): mixed
+    {
+        while (is_array($value) && self::isList($value)) {
+            $value = $value[0] ?? null;
+        }
+
+        return $value;
+    }
 }
diff --git a/src/Support/Attributes/Importable.php b/src/Support/Attributes/Importable.php
new file mode 100644
index 00000000000..8105d648cb7
--- /dev/null
+++ b/src/Support/Attributes/Importable.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Support\Attributes;
+
+use Attribute;
+
+#[Attribute]
+final readonly class Importable
+{
+    public function __construct(
+        public string $name,
+        public string $label,
+        public bool $excludeFromUiMapping = false,
+        public bool $isContainer = false,
+        public bool $canBeMatchCriteria = true,
+        public bool $canBeCleared = true,
+        public bool $canBeSet = true,
+    ) {}
+}
diff --git a/src/Support/Facades/Import.php b/src/Support/Facades/Import.php
new file mode 100644
index 00000000000..3ae70a5d0e2
--- /dev/null
+++ b/src/Support/Facades/Import.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Support\Facades;
+
+use CraftCms\Cms\Import\Data\Import as ImportData;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use Illuminate\Support\Facades\Facade;
+
+/**
+ * @method static array getAllDataTypes()
+ * @method static array getAllImporterTypes()
+ * @method static ?string getElementImporterTypeFor(string $elementClass)
+ * @method static bool dispatchImport(ImportData $import)
+ * @method static void import(BaseImporter $importer)
+ * @method static void importItem(BaseImporter $importer, array $data, array $matchCriteria)
+ * @method static string getRawData(string $filePath)
+ * @method static array getFormattedData(string $filePath)
+ * @method static ?array getDataHeadings(string $filePath)
+ * @method static array processData(BaseImporter $importer, array $data, mixed $element)
+ *
+ * @see \CraftCms\Cms\Import\Import
+ */
+class Import extends Facade
+{
+    protected static function getFacadeAccessor(): string
+    {
+        return \CraftCms\Cms\Import\Import::class;
+    }
+}
diff --git a/src/Support/Facades/ImportLog.php b/src/Support/Facades/ImportLog.php
new file mode 100644
index 00000000000..b0c0e5833f5
--- /dev/null
+++ b/src/Support/Facades/ImportLog.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Support\Facades;
+
+use Illuminate\Support\Facades\Facade;
+use Override;
+
+/**
+ * @method static void info(string $message, array $context = [])
+ * @method static void warning(string $message, array $context = [])
+ * @method static void error(string $message, array $context = [])
+ *
+ * @see \CraftCms\Cms\Import\ImportLog
+ */
+class ImportLog extends Facade
+{
+    #[Override]
+    protected static function getFacadeAccessor(): string
+    {
+        return \CraftCms\Cms\Import\ImportLog::class;
+    }
+}
diff --git a/src/Support/Facades/Imports.php b/src/Support/Facades/Imports.php
new file mode 100644
index 00000000000..01e520e8fa8
--- /dev/null
+++ b/src/Support/Facades/Imports.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Support\Facades;
+
+use CraftCms\Cms\Import\Data\Import as ImportData;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use Illuminate\Support\Collection as LaravelCollection;
+use Illuminate\Support\Facades\Facade;
+
+/**
+ * @method static BaseImporter createImporter(array $step)
+ * @method static LaravelCollection getAllImports()
+ * @method static LaravelCollection getEditableImports()
+ * @method static LaravelCollection getNonEditableImports()
+ * @method static ?ImportData getImportByHandle(?string $handle, bool $editableOnly = false)
+ * @method static ?ImportData getImportByUid(string $uid, bool $editableOnly = false)
+ * @method static bool saveImport(ImportData $import)
+ * @method static void duplicateImport(ImportData $import)
+ * @method static void deleteImport(ImportData $import)
+ *
+ * @see \CraftCms\Cms\Import\Imports
+ */
+class Imports extends Facade
+{
+    protected static function getFacadeAccessor(): string
+    {
+        return \CraftCms\Cms\Import\Imports::class;
+    }
+}
diff --git a/src/Support/ImportHelper.php b/src/Support/ImportHelper.php
new file mode 100644
index 00000000000..72cc41d7d40
--- /dev/null
+++ b/src/Support/ImportHelper.php
@@ -0,0 +1,786 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Support;
+
+use CraftCms\Cms\Address\Elements\Address;
+use CraftCms\Cms\Field\Contracts\FieldInterface;
+use CraftCms\Cms\Field\Contracts\ImportableElementContainerFieldInterface;
+use CraftCms\Cms\FieldLayout\Contracts\ImportableFieldLayoutElementInterface;
+use CraftCms\Cms\FieldLayout\FieldLayout;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use CraftCms\Cms\Support\Attributes\Importable;
+use CraftCms\Cms\Support\Facades\Fields;
+
+class ImportHelper
+{
+    public static function prepKeyForAutoMatching(string $key): string
+    {
+        $fragments = explode('.', $key);
+        foreach ($fragments as $i => $fragment) {
+            $fragments[$i] = Str::toHandle(implode(' ', Str::toWords($fragment)));
+        }
+
+        return Arr::join($fragments, '.');
+    }
+
+    public static function flattenLabelValueArray(array $array): array
+    {
+        return collect($array)
+            ->filter(fn ($item) => $item['value'] !== '')
+            ->mapWithKeys(fn ($item) => [$item['value'] => $item['label']])
+            ->all();
+    }
+
+    /**
+     * Normalizes match criteria coming from an importer config (UI or file-based)
+     * into an array where keys are the fields/attributes/properties to update,
+     * and values containing the incoming data keys.
+     */
+    public static function normalizeMatchCriteriaFromImporterConfig(BaseImporter $importer): array
+    {
+        // the order of importance is:
+        // matchCriteria coming from the UI or file-based config (those two never exist together), are merged with and overwritten by
+        // matchCriteria coming from the incoming data, are merged with and overwritten by
+        // the BaseTransformer::additionalMatchCriteria() values (if custom transformer is specified)
+
+        // get the map
+        $map = $importer->map ?? [];
+
+        // get the matchCriteria that are coming from the UI or from a file-based config
+        $matchCriteria = $importer->matchCriteria ?? [];
+
+        // ones coming from the UI will have a value of 1
+        // ones coming from the file-based config should be strings that point to the original data keys
+
+        // for the ones coming from the UI - we need to resolve those to the mapped column names
+        $dottedMap = Arr::dot($map);
+        $dottedMatchCriteria = Arr::dot($matchCriteria);
+
+        foreach ($dottedMatchCriteria as $key => $value) {
+            if (is_numeric($value) && $value == 1) {
+                $dottedMatchCriteria[$key] = $dottedMap[$key];
+            }
+        }
+
+        return Arr::undot($dottedMatchCriteria);
+    }
+
+    public static function getImportableProperties(BaseImporter $importer): array
+    {
+        // automatically include all Importable properties (e.g. sectionId, typeId for Entry);
+        $class = new \ReflectionClass($importer::targetClass());
+        $properties = $class->getProperties();
+
+        // now walk up and getParentClass() so that we can get all the props for classes that this one extends (e.g. Element class for Entry)
+        // todo (iwona): review again once entry parent works
+        //        while ($class = $class->getParentClass()) {
+        //            $properties = array_merge($properties, $class->getProperties());
+        //        }
+
+        $properties = array_values(array_filter($properties, fn ($property) => ! empty($property->getAttributes(Importable::class))));
+
+        return array_map(function ($property) {
+            $attribute = $property->getAttributes(Importable::class)[0];
+            $arguments = $attribute->getArguments();
+
+            return [
+                'property' => $property->getName(),
+                'name' => $arguments[0] ?? $arguments['name'],
+                'label' => $arguments[1] ?? $arguments[0] ?? $arguments['label'],
+                'excludeFromUiMapping' => $arguments[2] ?? $arguments['excludeFromUiMapping'] ?? false,
+                'isContainer' => $arguments[3] ?? $arguments['isContainer'] ?? false,
+                'canBeMatchCriteria' => $arguments[4] ?? $arguments['canBeMatchCriteria'] ?? true,
+                'canBeCleared' => $arguments[5] ?? $arguments['canBeCleared'] ?? true,
+                'canBeSet' => $arguments[6] ?? $arguments['canBeSet'] ?? true,
+                'defaultValue' => $property->getDefaultValue(),
+            ];
+        }, $properties);
+    }
+
+    public static function getImportableContainerProperties(BaseImporter $importer): array
+    {
+        $importableProperties = self::getImportableProperties($importer);
+        $importableContainerProperties = [];
+
+        foreach ($importableProperties as $property) {
+            if ($property['isContainer']) {
+                $importableContainerProperties[] = $property;
+            }
+        }
+
+        return $importableContainerProperties;
+    }
+
+    public static function getDestinationColsForFieldLayout(
+        ?FieldLayout $fieldLayout,
+        ?FieldInterface $ownerField = null,
+        mixed $provider = null,
+        ?string $prefix = null
+    ): array {
+        $cols = [];
+        if ($fieldLayout) {
+            $allElements = $fieldLayout->getAllElements();
+
+            foreach ($allElements as $fieldLayoutElement) {
+                if ($fieldLayoutElement instanceof ImportableFieldLayoutElementInterface) {
+                    // get element's fields for mapping; for example,
+                    // lat/long has two fields;
+                    // addresses field has (by default) label, country code and address field which then contains a bunch of other fields;
+                    // and custom fields have yet another way of getting this
+                    $cols[] = $fieldLayoutElement->getFieldsForMapping($fieldLayout, $ownerField, $provider, $prefix);
+                }
+            }
+        }
+
+        return $cols;
+    }
+
+    public static function getDestinationColsForProperty(
+        BaseImporter $importer,
+        string $property,
+        ?FieldLayout $fieldLayout,
+        ?string $prefix = null
+    ): array {
+        $cols = [];
+        // $fieldLayout = Fields::getLayoutByType(Address::class);
+        if ($fieldLayout) {
+            $allElements = $fieldLayout->getAllElements();
+
+            foreach ($allElements as $fieldLayoutElement) {
+                if ($fieldLayoutElement instanceof ImportableFieldLayoutElementInterface) {
+                    // get element's fields for mapping; for example,
+                    // lat/long has two fields;
+                    // addresses field has (by default) label, country code and address field which then contains a bunch of other fields;
+                    // and custom fields have yet another way of getting this
+                    $cols[] = $fieldLayoutElement->getFieldsForMapping($fieldLayout, null, null, $prefix);
+                }
+            }
+        }
+
+        return $cols;
+    }
+
+    /**
+     * Recursively decodes any JSON-encoded strings found inside the given value, leaving
+     * already-decoded values (and strings that aren't valid JSON) untouched.
+     */
+    public static function decodeRecursive(mixed $value): mixed
+    {
+        if (is_array($value)) {
+            return array_map(self::decodeRecursive(...), $value);
+        }
+
+        if (! is_string($value)) {
+            return $value;
+        }
+
+        $decoded = json_decode($value, true);
+
+        return json_last_error() === JSON_ERROR_NONE ? $decoded : $value;
+    }
+
+    /**
+     * Recursively checks whether every value in the given array is empty (null or an empty string),
+     * treating a nested array as empty only if all of its own values are empty too.
+     */
+    public static function isEmptyImportEntryData(array $data): bool
+    {
+        foreach ($data as $value) {
+            if (is_array($value)) {
+                if (! self::isEmptyImportEntryData($value)) {
+                    return false;
+                }
+
+                continue;
+            }
+
+            if ($value !== null && $value !== '') {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public static function getPrefixedHandlesForMapping(
+        string $attribute,
+        ?FieldInterface $ownerField,
+        mixed $field,
+        ?FieldLayout $fieldLayout,
+        mixed $provider,
+        ?string $prefix = null,
+    ): array {
+        if ($ownerField instanceof ImportableElementContainerFieldInterface) {
+            $namePrefix = $ownerField->getMappingUiPrefix($fieldLayout, $provider, $prefix);
+            if ($field instanceof FieldInterface) {
+                $prefixedHandle = $namePrefix."[fields][$attribute]";
+            } else {
+                $prefixedHandle = $namePrefix."[$attribute]";
+            }
+        } else {
+            $prefixedHandle = ! empty($prefix) ? $prefix."[$attribute]" : $attribute;
+        }
+
+        $prefixedHandleForMap = Html::namespaceInputName($prefixedHandle, 'map');
+        $prefixedHandleForMatchCriteria = Html::namespaceInputName($prefixedHandle, 'matchCriteria');
+        $prefixedHandleForClear = Html::namespaceInputName($prefixedHandle, 'clearableItems');
+        $prefixedHandleAsArray = Arr::bracketsToArray($prefixedHandle);
+        $prefixedHandleForKeep = Html::namespaceInputName($prefixedHandle, 'keepMissingNestedElements');
+        $prefixedHandleForKeepFlag = Html::namespaceInputName($prefixedHandle.'[__keep__]', 'keepMissingNestedElements');
+
+        return [$prefixedHandleForMap, $prefixedHandleForMatchCriteria, $prefixedHandleForClear, $prefixedHandle, $prefixedHandleAsArray, $prefixedHandleForKeep, $prefixedHandleForKeepFlag];
+    }
+
+    /**
+     * Rebuilds raw import data into the shape described by the map.
+     */
+    public static function remapData(array $map, array $data): array
+    {
+        return self::mapNode($map, $data, $data, null, true)['data'];
+    }
+
+    /**
+     * Maps one level of `$map` against `$currentData`, following each rule and recursing into
+     * nested maps or lists.
+     */
+    protected static function mapNode(
+        array $map,
+        array $rootData,
+        mixed $currentData,
+        ?string $currentBasePath,
+        bool $keepUnused
+    ): array {
+        $result = [];
+        $consumedKeys = [];
+
+        foreach ($map as $targetKey => $rule) {
+            // The rule is itself a nested map, so work out what part of the data it should read from.
+            if (is_array($rule)) {
+                $source = self::findSourceForRule((string) $targetKey, $rule, $rootData, $currentData, $currentBasePath);
+
+                if ($source === null) {
+                    // No direct source found, so recurse into the map as a plain nested object instead.
+                    $nested = self::mapNode($rule, $rootData, $currentData, $currentBasePath, false);
+                    $result[$targetKey] = $nested['data'];
+                    array_push($consumedKeys, ...$nested['consumed']);
+
+                    continue;
+                }
+
+                array_push($consumedKeys, ...$source['consumed']);
+
+                if (self::blockLooksGroupedByType($rule, $source['value'])) {
+                    // The source groups rows by block type, e.g. {typeA: [...], typeB: [...]}.
+                    $mapped = self::mapGroupedBlocksByType($rule, $rootData, $source['value'], $source['basePath']);
+                    $result[$targetKey] = $mapped['data'];
+                    array_push($consumedKeys, ...$mapped['consumed']);
+                } elseif (array_is_list($source['value'])) {
+                    // The source is a flat list, so map each row on its own.
+                    $result[$targetKey] = array_map(
+                        fn ($row) => is_array($row)
+                            ? self::mapRowByOwnType($rule, $rootData, $row, $source['basePath'])
+                            : $row,
+                        $source['value']
+                    );
+                } else {
+                    // The source is a single nested object, so map it directly.
+                    $result[$targetKey] = self::mapNode($rule, $rootData, $source['value'], $source['basePath'], true)['data'];
+                }
+
+                continue;
+            }
+
+            if ($rule === null) {
+                // A null rule means: don't set this field at all.
+
+                continue;
+            }
+
+            if ($rule === '""') {
+                // '""' is a special marker meaning: set this field to an empty string.
+                $result[$targetKey] = '';
+
+                continue;
+            }
+
+            $mapped = self::mapScalarValue((string) $rule, $rootData, $currentData, $currentBasePath);
+            $result[$targetKey] = $mapped['value'];
+
+            if ($mapped['consumed'] !== null) {
+                $consumedKeys[] = $mapped['consumed'];
+            }
+        }
+
+        if ($keepUnused && is_array($currentData)) {
+            foreach ($currentData as $key => $value) {
+                if (! in_array($key, $consumedKeys, true) && ! array_key_exists($key, $result)) {
+                    $result[$key] = $value;
+                }
+            }
+        }
+
+        return [
+            'data' => $result,
+            'consumed' => array_values(array_unique($consumedKeys)),
+        ];
+    }
+
+    /**
+     * Works out what raw data a nested rule should read from, and whether it's a list of rows,
+     * a type-grouped set, or a single group.
+     */
+    protected static function findSourceForRule(
+        string $targetKey,
+        array $rule,
+        array $rootData,
+        mixed $currentData,
+        ?string $currentBasePath
+    ): ?array {
+        // If the current data already has a key with this exact name, use it directly.
+        if (is_array($currentData) && array_key_exists($targetKey, $currentData) && is_array($currentData[$targetKey])) {
+            return [
+                'value' => $currentData[$targetKey],
+                'basePath' => self::pathJoin($currentBasePath, $targetKey),
+                'consumed' => [$targetKey],
+            ];
+        }
+
+        // Otherwise, work out the shared path implied by the rule's own values.
+        $sourceRelativePath = self::sharedSourcePath($rule, $currentBasePath);
+
+        if ($sourceRelativePath === null || $sourceRelativePath === '') {
+            return null;
+        }
+
+        $sourceKey = explode('.', $sourceRelativePath)[0];
+
+        // If any direct scalar rule points exactly to the resolved source path, that scalar is
+        // consuming the source container as its whole value — not iterating over its items.
+        // Return null so mapNode processes this rule as a flat dict instead.
+        $sourceAbsPath = self::pathJoin($currentBasePath, $sourceRelativePath);
+        foreach ($rule as $ruleValue) {
+            if (is_string($ruleValue) && $ruleValue === $sourceAbsPath) {
+                return null;
+            }
+        }
+
+        // Try the current data first, then fall back to the root data.
+        if (is_array($currentData) && $source = self::getArrayAtPath($currentData, $sourceRelativePath, self::pathJoin($currentBasePath, $sourceRelativePath), $sourceKey)) {
+            return $source;
+        }
+
+        $absolutePath = self::pathJoin($currentBasePath, $sourceRelativePath);
+
+        if ($source = self::getArrayAtPath($rootData, $absolutePath, $absolutePath, $sourceKey)) {
+            return $source;
+        }
+
+        return null;
+    }
+
+    /**
+     * Resolves a dotted `$path` inside `$data` to an array value, or `null` if the path is
+     * missing or doesn't resolve to an array.
+     */
+    protected static function getArrayAtPath(array $data, string $path, string $basePath, string $sourceKey): ?array
+    {
+        $found = self::findPath($data, $path);
+
+        if (! $found['found'] || ! is_array($found['value'])) {
+            return null;
+        }
+
+        return [
+            'value' => $found['value'],
+            'basePath' => $basePath,
+            'consumed' => [$sourceKey],
+        ];
+    }
+
+    /**
+     * Maps a single row of an inline-typed (flat, `type`-per-row) block list, dispatching
+     * to only the rule's submap matching the row's own `type` when the rule declares one.
+     */
+    protected static function mapRowByOwnType(array $rule, array $rootData, array $row, ?string $basePath): array
+    {
+        if (array_key_exists('type', $row) && is_string($row['type']) && array_key_exists($row['type'], $rule) && is_array($rule[$row['type']])) {
+            return self::mapRowForType($row['type'], $rule[$row['type']], $rootData, $row, $basePath);
+        }
+
+        return self::mapNode($rule, $rootData, $row, $basePath, true)['data'];
+    }
+
+    /**
+     * Maps a raw value that's grouped by block type (each type holding its own list of rows)
+     * into one flat list of mapped rows.
+     */
+    protected static function mapGroupedBlocksByType(array $blockTypeMap, array $rootData, array $sourceValue, string $basePath): array
+    {
+        $items = [];
+        $consumedKeys = [];
+
+        foreach ($blockTypeMap as $type => $typeMap) {
+            // Skip a type if the source doesn't have a matching list of rows for it.
+            if (! isset($sourceValue[$type])) {
+                continue;
+            }
+            if (! is_array($sourceValue[$type])) {
+                continue;
+            }
+            if (! array_is_list($sourceValue[$type])) {
+                continue;
+            }
+            $consumedKeys[] = $type;
+            $typeBasePath = self::pathJoin($basePath, (string) $type);
+
+            foreach ($sourceValue[$type] as $row) {
+                if (is_array($row)) {
+                    $items[] = self::mapRowForType((string) $type, $typeMap, $rootData, $row, $typeBasePath);
+                }
+            }
+        }
+
+        return [
+            'data' => $items,
+            'consumed' => array_values(array_unique($consumedKeys)),
+        ];
+    }
+
+    /**
+     * Maps `$row` against `$typeMap`, tagging the result with its block `$type`.
+     */
+    protected static function mapRowForType(string $type, array $typeMap, array $rootData, array $row, ?string $basePath): array
+    {
+        return ['type' => $type] + self::mapNode($typeMap, $rootData, $row, $basePath, true)['data'];
+    }
+
+    /**
+     * Reads a single value out of the data for a plain (non-array) rule.
+     */
+    protected static function mapScalarValue(string $path, array $rootData, mixed $currentData, ?string $currentBasePath): array
+    {
+        // The rule path is relative to where we are, so strip the shared prefix off first.
+        if ($currentBasePath !== null && str_starts_with($path, $currentBasePath.'.')) {
+            $relativePath = substr($path, strlen($currentBasePath) + 1);
+
+            return [
+                'value' => is_array($currentData) ? self::findPath($currentData, $relativePath)['value'] : null,
+                'consumed' => explode('.', $relativePath)[0],
+            ];
+        }
+
+        // The rule path didn't match our position, so read it straight from the root.
+        return [
+            'value' => self::findPath($rootData, $path)['value'],
+            'consumed' => $currentBasePath === null ? explode('.', $path)[0] : null,
+        ];
+    }
+
+    /**
+     * Finds the path that all of a rule's leaf values share, so a nested map can be resolved
+     * to one source.
+     */
+    protected static function sharedSourcePath(array $map, ?string $currentBasePath): ?string
+    {
+        $paths = self::collectLeafPaths($map, $currentBasePath);
+
+        if ($paths === []) {
+            return null;
+        }
+
+        $common = explode('.', (string) array_shift($paths));
+
+        // Narrow the shared path down to what every leaf path has in common.
+        foreach ($paths as $path) {
+            $parts = explode('.', (string) $path);
+            $next = [];
+
+            for ($i = 0, $max = min(count($common), count($parts)); $i < $max; $i++) {
+                if ($common[$i] !== $parts[$i]) {
+                    break;
+                }
+
+                $next[] = $common[$i];
+            }
+
+            $common = $next;
+        }
+
+        // If part of the shared path is itself a key in the map, stop there — that key needs its own resolution.
+        foreach ($common as $index => $part) {
+            if (array_key_exists($part, $map)) {
+                return $index === 0 ? null : implode('.', array_slice($common, 0, $index));
+            }
+        }
+
+        return implode('.', $common);
+    }
+
+    /**
+     * Collects every leaf (string) rule path inside a map, relative to the current base path.
+     */
+    protected static function collectLeafPaths(array $map, ?string $currentBasePath): array
+    {
+        $paths = [];
+
+        foreach ($map as $rule) {
+            if (is_array($rule)) {
+                array_push($paths, ...self::collectLeafPaths($rule, $currentBasePath));
+            } elseif (is_string($rule)) {
+                // Only keep leaf paths that fall under the current base path (or all of them, if we're at the root).
+                if ($currentBasePath !== null && str_starts_with($rule, $currentBasePath.'.')) {
+                    $paths[] = substr($rule, strlen($currentBasePath) + 1);
+                } elseif ($currentBasePath === null) {
+                    $paths[] = $rule;
+                }
+            }
+        }
+
+        return $paths;
+    }
+
+    /**
+     * Checks whether a raw value looks like it's grouped by block type, rather than being a
+     * block's own set of fields.
+     */
+    protected static function blockLooksGroupedByType(array $rule, mixed $sourceValue): bool
+    {
+        // A flat list of rows (each with its own type) isn't grouped by type.
+        if (! is_array($sourceValue) || array_is_list($sourceValue)) {
+            return false;
+        }
+
+        // A genuine block-type map only ever declares type submaps at its top level; a mix of
+        // scalar/null field rules alongside a submap means this is a block's own fields map
+        // (one of which happens to be a nested container field), not a type-dispatch map.
+        if (array_any($rule, fn ($childRule) => ! is_array($childRule))) {
+            return false;
+        }
+
+        return array_any($rule, fn ($_, $childKey) => self::sourceIsRowListForType((string) $childKey, $sourceValue[$childKey] ?? null));
+    }
+
+    /**
+     * Checks whether a source value is a list of rows belonging to the given block type,
+     * rather than a nested container field's own list of inline-typed rows.
+     */
+    protected static function sourceIsRowListForType(string $type, mixed $sourceValue): bool
+    {
+        if (! is_array($sourceValue) || ! array_is_list($sourceValue)) {
+            return false;
+        }
+
+        // Rows in a genuine type group either carry no type of their own or repeat the group's;
+        // a row declaring a different type means the key is a nested container field handle.
+        return ! array_any($sourceValue, fn ($row) => is_array($row) && is_string($row['type'] ?? null) && $row['type'] !== $type);
+    }
+
+    /**
+     * Walks a dotted `$path` inside `$data`, returning whether it was found and its value.
+     *
+     * @return array{found: bool, value: mixed}
+     */
+    protected static function findPath(array $data, string $path): array
+    {
+        $current = $data;
+
+        foreach (explode('.', $path) as $part) {
+            if (! is_array($current) || ! array_key_exists($part, $current)) {
+                return ['found' => false, 'value' => null];
+            }
+
+            $current = $current[$part];
+        }
+
+        return ['found' => true, 'value' => $current];
+    }
+
+    /**
+     * Joins a base path and a key into one dotted path.
+     */
+    protected static function pathJoin(?string $basePath, string $key): string
+    {
+        return $basePath === null || $basePath === '' ? $key : $basePath.'.'.$key;
+    }
+
+    // ------------- best guess UI mapping ----------------- //
+    /**
+     * Returns a best-guess incoming column for each of `$map`'s unmapped leaves, as a tree keyed
+     * the same way as the map itself. It uses the same normalized-handle matching as the
+     * auto-magic mapping done at import time.
+     *
+     * Matching is done on a column's full path rather than just its leaf handle, so the most
+     * specific incoming column wins: given both `title` and `matrixOuter.title` headings, the
+     * former fills the top-level Title and the latter the Title inside the matrix. A column can
+     * still fall back to a heading that names less of its path, but a heading claimed by a
+     * full-path match is never offered as a fallback.
+     *
+     * @param  array  $destinationCols  Same shape sent to the mapping screen: a list of column
+     *                                  arrays, `MappingColSet` arrays (`subfields`), or gaps.
+     * @param  array  $sourceDataCols  List of `{label, value}` arrays.
+     * @param  array  $map  The current (possibly partially saved) map tree.
+     */
+    public static function suggestMapValues(array $destinationCols, array $sourceDataCols, array $map): array
+    {
+        $incomingCols = [];
+        foreach ($sourceDataCols as $sourceCol) {
+            if (($sourceCol['value'] ?? '') === '') {
+                continue;
+            }
+
+            $segments = self::matchSegments((string) $sourceCol['value']);
+
+            if ($segments === []) {
+                continue;
+            }
+
+            $incomingCols[implode('.', $segments)] = ['segments' => $segments, 'value' => $sourceCol['value']];
+        }
+
+        $leaves = [];
+        self::collectMappableLeaves($destinationCols, $map, $leaves);
+
+        $suggestions = [];
+        self::assignSuggestions($leaves, array_values($incomingCols), $suggestions);
+
+        return $suggestions;
+    }
+
+    /**
+     * Normalizes a key into the segments it should be auto-matched on. They're lowercased so a
+     * heading can be spelled however its author liked — `matrixouter`, `matrix-inner` and
+     * `plain-text` all line up with the handles they name.
+     */
+    private static function matchSegments(string|array $key): array
+    {
+        $segments = is_array($key) ? $key : explode('.', $key);
+
+        foreach ($segments as $i => $segment) {
+            $segments[$i] = Str::lower(Str::toHandle(implode(' ', Str::toWords((string) $segment))));
+        }
+
+        return array_values(array_filter($segments, fn (string $segment) => $segment !== ''));
+    }
+
+    /**
+     * Returns how many of an incoming column's segments line up with a destination's, or `null`
+     * if the column doesn't describe that destination at all.
+     *
+     * The column has to name the destination's own handle, and everything in front of that has
+     * to appear in order — but not necessarily back to back, because a destination path also
+     * carries segments the data never does, such as a nested entry's entry type handle.
+     */
+    private static function matchScore(array $destinationSegments, array $sourceSegments): ?int
+    {
+        $score = count($sourceSegments);
+
+        if ($score === 0 || $score > count($destinationSegments)) {
+            return null;
+        }
+
+        if (array_pop($sourceSegments) !== array_pop($destinationSegments)) {
+            return null;
+        }
+
+        foreach ($sourceSegments as $segment) {
+            $at = array_search($segment, $destinationSegments, true);
+
+            if ($at === false) {
+                return null;
+            }
+
+            $destinationSegments = array_slice($destinationSegments, $at + 1);
+        }
+
+        return $score;
+    }
+
+    /**
+     * Collects every destination leaf that still needs a value, keeping each one's map path
+     * alongside the normalized segments it should be matched on.
+     */
+    private static function collectMappableLeaves(array $destinationCols, array $map, array &$leaves): void
+    {
+        foreach ($destinationCols as $col) {
+            if (isset($col['subfields']) && is_array($col['subfields'])) {
+                self::collectMappableLeaves($col['subfields'], $map, $leaves);
+
+                continue;
+            }
+
+            if (empty($col['prefixedHandleAsArray']) || ! empty($col['isContainer'])) {
+                continue;
+            }
+
+            $path = implode('.', $col['prefixedHandleAsArray']);
+
+            if (Arr::get($map, $path, '') !== '') {
+                continue;
+            }
+
+            $leaves[] = [
+                'path' => $path,
+                'segments' => self::matchSegments($col['prefixedHandleAsArray']),
+            ];
+        }
+    }
+
+    /**
+     * Scores each leaf against every incoming column that describes it, then assigns the most
+     * specific matches first.
+     */
+    private static function assignSuggestions(array $leaves, array $incomingCols, array &$suggestions): void
+    {
+        $candidates = [];
+
+        foreach ($leaves as $i => $leaf) {
+            $segmentCount = count($leaf['segments']);
+
+            foreach ($incomingCols as $incomingCol) {
+                $score = self::matchScore($leaf['segments'], $incomingCol['segments']);
+
+                if ($score === null) {
+                    continue;
+                }
+
+                $candidates[] = [
+                    'leaf' => $i,
+                    'value' => $incomingCol['value'],
+                    'full' => $score === $segmentCount,
+                    'length' => $score,
+                ];
+            }
+        }
+
+        // most specific first: full-path matches, then the longest tail match, then
+        // destination order so the result doesn't depend on sort stability
+        usort(
+            $candidates,
+            fn (array $a, array $b) => [$b['full'], $b['length'], $a['leaf']] <=> [$a['full'], $a['length'], $b['leaf']],
+        );
+
+        $assigned = [];
+        $claimed = [];
+
+        foreach ($candidates as $candidate) {
+            if (isset($assigned[$candidate['leaf']])) {
+                continue;
+            }
+
+            // a heading that exactly matches some other column's whole path belongs to it
+            if (! $candidate['full'] && isset($claimed[$candidate['value']])) {
+                continue;
+            }
+
+            $assigned[$candidate['leaf']] = true;
+
+            if ($candidate['full']) {
+                $claimed[$candidate['value']] = true;
+            }
+
+            Arr::set($suggestions, $leaves[$candidate['leaf']]['path'], $candidate['value']);
+        }
+    }
+}
diff --git a/src/Support/Path.php b/src/Support/Path.php
index b36cac86000..0087459a79c 100644
--- a/src/Support/Path.php
+++ b/src/Support/Path.php
@@ -250,6 +250,44 @@ public static function ensurePathIsContained(string $path): bool
         return true;
     }
 
+    /**
+     * Returns a normalized path or false, if realpath fails.
+     */
+    public static function normalizePath(string|false $path): string|false
+    {
+        if (! $path || ! ($path = realpath($path))) {
+            return false;
+        }
+
+        return File::normalizePath($path).DIRECTORY_SEPARATOR;
+    }
+
+    public static function isPathWithinRoots(string $path, array $allowedRoots): bool
+    {
+        $inAllowedRoot = false;
+        foreach ($allowedRoots as [$root, $isTempDir]) {
+            $root = self::normalizePath($root);
+            if ($root !== false && str_starts_with($path, $root)) {
+                // If this is a known temp dir, we’re good here
+                if ($isTempDir) {
+                    return true;
+                }
+                $inAllowedRoot = true;
+                break;
+            }
+        }
+        if (! $inAllowedRoot) {
+            return false;
+        }
+
+        // Make sure it's *not* within a system directory though
+        $systemDirs = app(self::class)->system();
+        $systemDirs = array_map(self::normalizePath(...), $systemDirs);
+        $systemDirs = array_filter($systemDirs, fn ($value) => $value !== false);
+
+        return array_all($systemDirs, fn ($dir) => ! str_starts_with($path, (string) $dir));
+    }
+
     private function aliasOrDefault(string $alias, string $path): string
     {
         return File::normalizePath(Aliases::get($alias, false) ?: $path);
diff --git a/src/SystemMessage/Commands/ImportSystemMessage.php b/src/SystemMessage/Commands/ImportSystemMessage.php
new file mode 100644
index 00000000000..6005408d600
--- /dev/null
+++ b/src/SystemMessage/Commands/ImportSystemMessage.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\SystemMessage\Commands;
+
+use CraftCms\Cms\Import\Commands\Import;
+use CraftCms\Cms\SystemMessage\Import\SystemMessageImporter;
+use Override;
+
+class ImportSystemMessage extends Import
+{
+    #[Override]
+    protected $name = 'craft:import:system-message';
+
+    #[Override]
+    protected $description = 'Imports Craft CMS System Messages';
+
+    #[Override]
+    protected $aliases = ['import/system-message'];
+
+    #[Override]
+    public static function importerClass(): string
+    {
+        return SystemMessageImporter::class;
+    }
+}
diff --git a/src/SystemMessage/Import/SystemMessageImporter.php b/src/SystemMessage/Import/SystemMessageImporter.php
new file mode 100644
index 00000000000..1882f619d09
--- /dev/null
+++ b/src/SystemMessage/Import/SystemMessageImporter.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\SystemMessage\Import;
+
+use CraftCms\Cms\Import\Importers\ModelImporter;
+use CraftCms\Cms\SystemMessage\Models\SystemMessage;
+use Override;
+
+use function CraftCms\Cms\t;
+
+/**
+ * Imports data into SystemMessage models.
+ */
+class SystemMessageImporter extends ModelImporter
+{
+    public function __construct(?array $config = null)
+    {
+        parent::__construct($config);
+
+        // match incoming data on key and language combination
+        $this->matchCriteria = ['key' => 'key', 'language' => 'language'];
+    }
+
+    #[Override]
+    public static function targetClass(): string
+    {
+        return SystemMessage::class;
+    }
+
+    #[Override]
+    public static function displayName(): string
+    {
+        return t('System Messages');
+    }
+
+    /**
+     * Convenience factory returning a new instance.
+     */
+    public static function create(): self
+    {
+        return new self;
+    }
+}
diff --git a/src/User/Commands/ImportUser.php b/src/User/Commands/ImportUser.php
new file mode 100644
index 00000000000..91d10388ad9
--- /dev/null
+++ b/src/User/Commands/ImportUser.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\User\Commands;
+
+use CraftCms\Cms\Import\Commands\Import;
+use CraftCms\Cms\User\Import\UserImporter;
+use Override;
+
+class ImportUser extends Import
+{
+    #[Override]
+    protected $name = 'craft:import:user';
+
+    #[Override]
+    protected $description = 'Imports Craft CMS Users';
+
+    #[Override]
+    protected $aliases = ['import/user'];
+
+    #[Override]
+    public static function importerClass(): string
+    {
+        return UserImporter::class;
+    }
+}
diff --git a/src/User/Elements/User.php b/src/User/Elements/User.php
index 5619d9a22ee..c36eef7b3cc 100644
--- a/src/User/Elements/User.php
+++ b/src/User/Elements/User.php
@@ -26,18 +26,22 @@
 use CraftCms\Cms\Element\Enums\ElementActionContext;
 use CraftCms\Cms\Element\Enums\MenuItemType;
 use CraftCms\Cms\Element\Enums\PropagationMethod;
+use CraftCms\Cms\Element\Events\ElementSaved;
 use CraftCms\Cms\Element\NestedElementManager;
 use CraftCms\Cms\Element\Queries\AddressQuery;
 use CraftCms\Cms\Element\Queries\Contracts\ElementQueryInterface;
 use CraftCms\Cms\Element\Queries\UserQuery;
+use CraftCms\Cms\Field\Addresses;
 use CraftCms\Cms\Field\Fields;
 use CraftCms\Cms\FieldLayout\FieldLayout;
 use CraftCms\Cms\Http\ViewModels\UserEditViewModel;
 use CraftCms\Cms\Image\Enums\ImageTransformMode;
+use CraftCms\Cms\Import\Importers\BaseImporter;
 use CraftCms\Cms\Shared\Concerns\HasNames;
 use CraftCms\Cms\Shared\Enums\Color;
 use CraftCms\Cms\Site\Data\Site;
 use CraftCms\Cms\Support\Arr;
+use CraftCms\Cms\Support\Attributes\Importable;
 use CraftCms\Cms\Support\Facades\Assets as AssetsService;
 use CraftCms\Cms\Support\Facades\Elements;
 use CraftCms\Cms\Support\Facades\HtmlStack;
@@ -48,6 +52,7 @@
 use CraftCms\Cms\Support\Facades\UserGroups;
 use CraftCms\Cms\Support\Facades\Users;
 use CraftCms\Cms\Support\Html;
+use CraftCms\Cms\Support\ImportHelper;
 use CraftCms\Cms\Support\Str;
 use CraftCms\Cms\Support\Template;
 use CraftCms\Cms\Support\Url;
@@ -82,6 +87,7 @@
 use Illuminate\Notifications\Notifiable;
 use Illuminate\Support\Facades\Date;
 use Illuminate\Support\Facades\DB as DbFacade;
+use Illuminate\Support\Facades\Event;
 use Illuminate\Support\Facades\Gate;
 use Illuminate\Support\Facades\Hash;
 use Illuminate\Support\Traits\Macroable;
@@ -192,6 +198,7 @@ class User extends Element implements AuthenticatableContract, AuthorizableContr
      * @var int|null Photo asset ID
      */
     #[AllowedInSandbox]
+    #[Importable('photoId', 'Photo ID')]
     public ?int $photoId = null;
 
     /**
@@ -222,29 +229,32 @@ class User extends Element implements AuthenticatableContract, AuthorizableContr
      * @var bool Admin
      */
     #[AllowedInSandbox]
+    #[Importable('admin', 'Is Admin?', canBeMatchCriteria: false)]
     public bool $admin = false;
 
     /**
      * @var string|null Username
      */
     #[AllowedInSandbox]
-    public ?string $username = null;
+    public ?string $username = null; // imported via Field Layout Element
 
     /**
      * @var string|null Email
      */
     #[AllowedInSandbox]
-    public ?string $email = null;
+    public ?string $email = null; // imported via Field Layout Element
 
     /**
      * @var string|null Password
      */
+    #[Importable('password', 'Password', canBeMatchCriteria: false)]
     public ?string $password = null;
 
     /**
      * @var int|null Affiliated site ID
      */
     #[AllowedInSandbox]
+    #[Importable('affiliatedSiteId', 'Affiliated Site ID', canBeMatchCriteria: false)]
     public ?int $affiliatedSiteId = null;
 
     /**
@@ -276,6 +286,7 @@ class User extends Element implements AuthenticatableContract, AuthorizableContr
     /**
      * @var bool Password reset required
      */
+    #[Importable('passwordResetRequired', 'Password Reset Required?', canBeMatchCriteria: false)]
     public bool $passwordResetRequired = false;
 
     /**
@@ -313,6 +324,7 @@ class User extends Element implements AuthenticatableContract, AuthorizableContr
      *
      * @see getAddresses()
      */
+    #[Importable('addresses', 'Addresses', false, true, false)]
     private ElementCollection $_addresses;
 
     /**
@@ -2341,4 +2353,40 @@ public function beforeDelete(): bool
 
         return true;
     }
+
+    public static function getDestinationColsForProperty(BaseImporter $importer, string $property): ?array
+    {
+        return match ($property) {
+            'addresses' => ImportHelper::getDestinationColsForFieldLayout(
+                app(Fields::class)->getLayoutByType(Address::class), null, null, $property
+            ),
+            default => null
+        };
+    }
+
+    /**
+     * Special method that can be used to import data into a container-type attribute.
+     * It handles normalizing value for import and saving the data.
+     * It returns indication of whether it changed any pre-existing data.
+     */
+    public function importIntoContainerAttribute(array $attribute, array $item, BaseImporter $importer): void
+    {
+        // user addresses are super-special; they're kind of the same as Addresses field and technically they are nested elements,
+        // but when added to User element, they're not "taken care of" by `NestedElementManager->maintainNestedElements()`;
+        // that's why we have to prep them and then save them once we're sure that the User they belong to actually exists;
+        if ($attribute['name'] === 'addresses' && isset($item['addresses'])) {
+            $addressesField = new Addresses;
+            $addresses = ElementCollection::make($addressesField->normalizeValueForImport($item['addresses'], $importer, $this));
+            $this->_addresses = $addresses;
+
+            Event::listen(function (ElementSaved $event) use ($addressesField) {
+                if ($event->element === $this && $this->_addresses->isNotEmpty()) {
+                    $addresses = $addressesField->createAddressesFromSerializedData($this->_addresses->all(), $event->element, true);
+                    foreach ($addresses as $address) {
+                        Elements::saveElement($address);
+                    }
+                }
+            });
+        }
+    }
 }
diff --git a/src/User/Import/UserImporter.php b/src/User/Import/UserImporter.php
new file mode 100644
index 00000000000..e9edb76dde7
--- /dev/null
+++ b/src/User/Import/UserImporter.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\User\Import;
+
+use CraftCms\Cms\Element\Import\ElementImporter;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\User\Elements\User;
+use Override;
+
+use function CraftCms\Cms\t;
+
+/**
+ * Imports data into User elements.
+ */
+class UserImporter extends ElementImporter
+{
+    #[Override]
+    public static function targetClass(): string
+    {
+        return User::class;
+    }
+
+    /**
+     * Convenience factory returning a new instance.
+     */
+    public static function create(): self
+    {
+        return new self;
+    }
+
+    #[Override]
+    public static function displayName(): string
+    {
+        return t('Users');
+    }
+
+    #[Override]
+    public function storeSettings(array $settings): void
+    {
+        parent::storeSettings($settings);
+
+        $this->resolveDefaultFieldLayout();
+    }
+
+    /**
+     * Users have one field layout for the element type, so there's nothing for the step to
+     * choose — resolve it as soon as the importer is built.
+     */
+    #[Override]
+    public function resolveDefaultFieldLayout(): void
+    {
+        $fieldLayout = Fields::getLayoutByType(User::class, false);
+        $this->fieldLayout($fieldLayout ? $fieldLayout->uid : User::class);
+    }
+}
diff --git a/src/User/UserPermissions.php b/src/User/UserPermissions.php
index 4eb4f3ab45f..3a546b00ad6 100644
--- a/src/User/UserPermissions.php
+++ b/src/User/UserPermissions.php
@@ -114,6 +114,7 @@ public function getAllPermissions(): Collection
         $this->entryPermissions($permissions);
         $this->volumePermissions($permissions);
         $this->utilityPermissions($permissions);
+        $this->importPermissions($permissions);
 
         return $this->permissionGroupCatalog->apply($permissions);
     }
@@ -757,6 +758,39 @@ private function utilityPermissions(Collection $permissions): void
         ));
     }
 
+    /** @param Collection<int, PermissionGroup> $permissions */
+    private function importPermissions(Collection $permissions): void
+    {
+        $permissions->add(new PermissionGroup(
+            handle: 'import',
+            heading: t('Import'),
+            permissions: collect([
+                new Permission(
+                    key: 'viewImports',
+                    label: t('View imports'),
+                    info: t('Allows viewing existing imports.'),
+                    nested: collect([
+                        new Permission(
+                            key: 'saveImports',
+                            label: t('Save imports'),
+                            info: t('Allows creating and saving imports.'),
+                        ),
+                        new Permission(
+                            key: 'deleteImports',
+                            label: t('Delete imports'),
+                            info: t('Allows deleting imports.'),
+                        ),
+                        new Permission(
+                            key: 'triggerImports',
+                            label: t('Run imports'),
+                            info: t('Allows user to run an import.'),
+                        ),
+                    ])->filter(),
+                ),
+            ]),
+        ));
+    }
+
     /**
      * Filters out any permissions that aren't assignable by the current user.
      *
diff --git a/tests/Feature/Http/Controllers/ImportControllerTest.php b/tests/Feature/Http/Controllers/ImportControllerTest.php
new file mode 100644
index 00000000000..7c28492c68f
--- /dev/null
+++ b/tests/Feature/Http/Controllers/ImportControllerTest.php
@@ -0,0 +1,366 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Aliases\Aliases;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Entry\Models\EntryType;
+use CraftCms\Cms\Field\Matrix;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\Field\PlainText;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\FieldLayout\LayoutElements\Entries\EntryTitleField;
+use CraftCms\Cms\FieldLayout\Models\FieldLayout;
+use CraftCms\Cms\Http\Controllers\Import\ImportController;
+use CraftCms\Cms\Import\Imports;
+use CraftCms\Cms\Section\Models\Section;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Support\Str;
+use CraftCms\Cms\SystemMessage\Import\SystemMessageImporter;
+use CraftCms\Cms\User\Elements\User;
+use CraftCms\Cms\User\Import\UserImporter;
+
+use function Pest\Laravel\actingAs;
+
+beforeEach(function () {
+    actingAs(User::find()->one());
+
+    // BaseImporter::resolvedFilePath() resolves everything against @root, which points at the
+    // Testbench skeleton during tests - point it at the package so the fixtures are reachable
+    $this->originalRoot = Aliases::get('@root');
+    Aliases::set('@root', dirname(__DIR__, 4));
+    $this->file = 'tests/Fixtures/Import/entries-plain-text.json';
+
+    $innerPlainTextField = Field::factory()->create([
+        'name' => 'Inner Plain Text',
+        'handle' => 'innerPlainText',
+        'type' => PlainText::class,
+    ]);
+
+    $innerEntryType = EntryType::factory()
+        ->withField($innerPlainTextField)
+        ->create(['name' => 'Inner ET', 'handle' => 'innerEt', 'hasTitleField' => true]);
+
+    $innerMatrixField = Field::factory()->create([
+        'name' => 'Inner Matrix',
+        'handle' => 'innerMatrix',
+        'type' => Matrix::class,
+        'settings' => ['entryTypes' => [$innerEntryType->id]],
+    ]);
+
+    Fields::refreshFields();
+
+    $outerEntryType = EntryType::factory()
+        ->withFieldLayout(
+            FieldLayout::factory()
+                ->withContentTab([
+                    new EntryTitleField(['uid' => Str::uuid()->toString(), 'required' => true]),
+                    CustomField::make($innerMatrixField->handle),
+                ])
+                ->create()
+        )
+        ->create(['name' => 'Outer ET', 'handle' => 'outerEt', 'hasTitleField' => true]);
+
+    $this->outerMatrixField = Field::factory()->create([
+        'name' => 'Outer Matrix',
+        'handle' => 'outerMatrix',
+        'type' => Matrix::class,
+        'settings' => ['entryTypes' => [$outerEntryType->id]],
+    ]);
+
+    Fields::refreshFields();
+
+    $this->entryType = EntryType::factory()
+        ->withFieldLayout(
+            FieldLayout::factory()
+                ->withContentTab([
+                    new EntryTitleField(['uid' => Str::uuid()->toString(), 'required' => true]),
+                    CustomField::make($this->outerMatrixField->handle),
+                ])
+                ->create()
+        )
+        ->create(['name' => 'Fixture Type', 'handle' => 'fixtureType', 'hasTitleField' => true]);
+
+    $this->section = Section::factory()
+        ->withEntryTypes($this->entryType)
+        ->create(['handle' => 'fixtureSection', 'minAuthors' => 0]);
+
+    EntryTypes::refreshEntryTypes();
+    Fields::refreshFields();
+
+    $this->entryStep = fn (array $settings = [], array $overrides = []) => array_merge([
+        'uid' => Str::uuid7()->toString(),
+        'type' => EntryImporter::class,
+        'file' => $this->file,
+        'transformer' => null,
+        'batchSize' => null,
+        'settings' => array_merge([
+            'site' => Sites::getPrimarySite()->handle,
+            'section' => $this->section->handle,
+            'entryType' => $this->entryType->handle,
+        ], $settings),
+    ], $overrides);
+
+    $this->saveImport = fn (array $steps, array $overrides = []) => $this->postJson(
+        action([ImportController::class, 'store']),
+        array_merge([
+            'name' => 'Fixture Import',
+            'handle' => 'fixtureImport',
+            'steps' => $steps,
+        ], $overrides),
+    );
+});
+
+afterEach(function () {
+    Aliases::set('@root', $this->originalRoot);
+});
+
+it('saves an import with several steps of different types in one request', function () {
+    ($this->saveImport)([
+        ($this->entryStep)(),
+        [
+            'uid' => Str::uuid7()->toString(),
+            'type' => SystemMessageImporter::class,
+            'file' => $this->file,
+            'transformer' => null,
+            'batchSize' => 25,
+            'settings' => [],
+        ],
+    ])->assertOk();
+
+    $saved = app(Imports::class)->getImportByHandle('fixtureImport');
+
+    expect($saved)->not->toBeNull()
+        ->and($saved->steps)->toHaveCount(2)
+        ->and($saved->steps[0]['type'])->toBe(EntryImporter::class)
+        ->and($saved->steps[1]['type'])->toBe(SystemMessageImporter::class)
+        ->and($saved->steps[1]['batchSize'])->toBe(25)
+        ->and($saved->getImporters())->toHaveCount(2);
+});
+
+it('rejects an import with no steps', function () {
+    ($this->saveImport)([])
+        ->assertStatus(400)
+        ->assertJsonPath('errors.steps.0', 'An import needs at least one step.');
+
+    expect(app(Imports::class)->getImportByHandle('fixtureImport'))->toBeNull();
+});
+
+it('reports a step’s own validation errors against that step', function () {
+    $step = ($this->entryStep)([], ['file' => 'tests/Fixtures/Import/does-not-exist.json']);
+
+    $response = ($this->saveImport)([$step])->assertStatus(400);
+
+    // the key is a flat dotted string, which is how the step list on the edit screen
+    // matches an error back to the row that caused it
+    expect(array_keys($response->json('errors')))->toContain("steps.{$step['uid']}.file");
+
+    expect(app(Imports::class)->getImportByHandle('fixtureImport'))->toBeNull();
+});
+
+it('validates a draft step without saving the import', function () {
+    $response = $this->postJson(action([ImportController::class, 'validateStep']), [
+        'step' => ($this->entryStep)(),
+    ]);
+
+    $response->assertOk();
+    expect(app(Imports::class)->getImportByHandle('fixtureImport'))->toBeNull();
+});
+
+it('reports a draft step’s validation errors before the import is ever saved', function () {
+    $step = ($this->entryStep)([], ['file' => 'tests/Fixtures/Import/does-not-exist.json']);
+
+    $response = $this->postJson(action([ImportController::class, 'validateStep']), [
+        'step' => $step,
+    ]);
+
+    $response->assertStatus(422);
+    expect(array_keys($response->json('errors')))->toContain('file');
+});
+
+it('returns a container field’s destination columns for an unsaved step', function () {
+    $response = $this->postJson(action([ImportController::class, 'nestedMappingCols']), [
+        'step' => ($this->entryStep)(),
+        'fieldUid' => $this->outerMatrixField->uid,
+        'fieldHandle' => 'outerMatrix',
+    ]);
+
+    $response->assertOk();
+    expect($response->json('fieldName'))->toBe('Outer Matrix');
+    expect($response->json('groups.0.providerName'))->toBe('Outer ET');
+
+    // The columns are addressed from the root of the mapping trees, prefixed with the
+    // container's own handle — that's what lets the panel edit the step's state in place.
+    $handles = array_column($response->json('groups.0.destinationCols'), 'prefixedHandle');
+    expect($handles)->toContain('outerMatrix[outerEt][fields][innerMatrix]');
+});
+
+it('returns a step’s mapping structure without the import being saved', function () {
+    $response = $this->postJson(action([ImportController::class, 'stepMapping']), [
+        'step' => ($this->entryStep)(),
+    ]);
+
+    $response->assertOk();
+    expect($response->json('available'))->toBeTrue()
+        ->and($response->json('destinationCols'))->not->toBeEmpty()
+        ->and($response->json('sourceDataCols'))->not->toBeEmpty()
+        ->and($response->json('values.map'))->toBe([])
+        // the guesses the mapping panel fills in and highlights as best guesses
+        ->and($response->json('suggestions'))->not->toBeEmpty()
+        ->and($response->json('suggestions.title'))->toBe('title');
+
+    expect(app(Imports::class)->getImportByHandle('fixtureImport'))->toBeNull();
+});
+
+it('builds a step’s settings form from the posted draft step', function () {
+    $response = $this->postJson(action([ImportController::class, 'stepSettings']), [
+        'step' => ($this->entryStep)(),
+    ]);
+
+    $response->assertOk();
+    expect($response->json('form.nodes'))->not->toBeEmpty()
+        ->and($response->json('form.values.type'))->toBe(EntryImporter::class);
+});
+
+it('reports a step with a resolved field layout as mappable', function () {
+    $response = $this->postJson(action([ImportController::class, 'stepSettings']), [
+        'step' => ($this->entryStep)(),
+    ]);
+
+    expect($response->json('canMap'))->toBeTrue();
+});
+
+it('reports a step whose field layout hasn’t resolved as not mappable', function () {
+    // An element importer's destination columns come from the field layout its entry type
+    // resolves, so there is nothing to map onto until one is chosen.
+    $response = $this->postJson(action([ImportController::class, 'stepSettings']), [
+        'step' => ($this->entryStep)(['entryType' => null]),
+    ]);
+
+    expect($response->json('canMap'))->toBeFalse();
+});
+
+it('reports a step with no file as not mappable', function () {
+    $response = $this->postJson(action([ImportController::class, 'stepSettings']), [
+        'step' => ($this->entryStep)([], ['file' => null]),
+    ]);
+
+    expect($response->json('canMap'))->toBeFalse();
+});
+
+it('reports an unsaved users step as mappable', function () {
+    // Users have one layout for the element type rather than one per setting, so it has to
+    // resolve while the step is being built — not only when the import is saved.
+    $response = $this->postJson(action([ImportController::class, 'stepSettings']), [
+        'step' => [
+            'uid' => Str::uuid7()->toString(),
+            'type' => UserImporter::class,
+            'file' => $this->file,
+            'transformer' => null,
+            'batchSize' => null,
+            'settings' => ['site' => Sites::getPrimarySite()->handle],
+        ],
+    ]);
+
+    expect($response->json('canMap'))->toBeTrue();
+});
+
+it('refuses to build the mapping for a step whose layout hasn’t resolved', function () {
+    $response = $this->postJson(action([ImportController::class, 'stepMapping']), [
+        'step' => ($this->entryStep)(['entryType' => null]),
+    ]);
+
+    $response->assertOk();
+    expect($response->json('available'))->toBeFalse()
+        ->and($response->json('message'))->not->toBeEmpty();
+});
+
+it('persists both levels’ keepMissingNestedElements decisions with the step', function () {
+    // The mapping panel writes into the step client-side, so the whole nested shape
+    // arrives in the one save — there's no per-container round trip.
+    ($this->saveImport)([
+        ($this->entryStep)([
+            'map' => ['outerMatrix' => ['outerEt' => []]],
+            'keepMissingNestedElements' => [
+                'outerMatrix' => [
+                    '__keep__' => '1',
+                    'outerEt' => [
+                        'fields' => [
+                            'innerMatrix' => ['__keep__' => '1'],
+                        ],
+                    ],
+                ],
+            ],
+        ]),
+    ])->assertOk();
+
+    $importer = app(Imports::class)->getImportByHandle('fixtureImport')->getImporters()->first();
+
+    expect($importer->keepMissingNestedElements)->toBe([
+        'outerMatrix' => [
+            '__keep__' => 1,
+            'outerEt' => [
+                'fields' => [
+                    'innerMatrix' => ['__keep__' => 1],
+                ],
+            ],
+        ],
+    ]);
+});
+
+it('persists match criteria and clearable items alongside the map', function () {
+    ($this->saveImport)([
+        ($this->entryStep)([
+            'map' => ['title' => 'Name'],
+            'matchCriteria' => ['title' => '1'],
+            'clearableItems' => ['title' => '1'],
+        ]),
+    ])->assertOk();
+
+    $importer = app(Imports::class)->getImportByHandle('fixtureImport')->getImporters()->first();
+
+    expect($importer->matchCriteria)->toBe(['title' => 1])
+        ->and($importer->clearableItems)->toBe(['title' => 1]);
+});
+
+it('still decodes JSON-encoded container branches on save', function () {
+    // File-based configs and plugins can still post the shape the Twig screen's hidden
+    // inputs produced.
+    ($this->saveImport)([
+        ($this->entryStep)([
+            'map' => ['outerMatrix' => json_encode(['outerEt' => ['title' => 'Title']])],
+        ]),
+    ])->assertOk();
+
+    $importer = app(Imports::class)->getImportByHandle('fixtureImport')->getImporters()->first();
+
+    expect($importer->map)->toBe([
+        'outerMatrix' => ['outerEt' => ['title' => 'Title']],
+    ]);
+});
+
+it('saves and maps a model importer step', function () {
+    // ModelImporter has no site, fieldLayout or keepMissingNestedElements, so this is the
+    // path that has to stay clear of the ElementImporter-only properties
+    ($this->saveImport)([
+        [
+            'uid' => Str::uuid7()->toString(),
+            'type' => SystemMessageImporter::class,
+            'file' => $this->file,
+            'transformer' => null,
+            'batchSize' => null,
+            'settings' => [
+                'map' => ['subject' => 'incomingSubject'],
+                'matchCriteria' => ['key' => 'key'],
+            ],
+        ],
+    ])->assertOk();
+
+    $importer = app(Imports::class)->getImportByHandle('fixtureImport')->getImporters()->first();
+
+    expect($importer)->toBeInstanceOf(SystemMessageImporter::class)
+        ->and($importer->map)->toBe(['subject' => 'incomingSubject'])
+        ->and($importer->matchCriteria)->toBe(['key' => 'key']);
+});
diff --git a/tests/Feature/Import/Commands/ImportEntryCommandTest.php b/tests/Feature/Import/Commands/ImportEntryCommandTest.php
new file mode 100644
index 00000000000..4ba1999e97c
--- /dev/null
+++ b/tests/Feature/Import/Commands/ImportEntryCommandTest.php
@@ -0,0 +1,121 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Aliases\Aliases;
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryTransformer;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Section\Models\Section;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+const TRANSFORMER_QUESTION = 'The transformer you want to use to manipulate the data on import (fully qualified class name for the transformer)';
+
+const MATCH_CRITERIA_QUESTION = 'A JSON-encoded array of match criteria you’d like to use to match against existing elements. If none provided, ID will be used for matching.';
+
+beforeEach(function () {
+    // resolvedFilePath() resolves against @root, which points at the Testbench skeleton in tests
+    $this->originalRoot = Aliases::get('@root');
+    Aliases::set('@root', dirname(__DIR__, 4));
+
+    $plainTextField = ImportFixtures::plainTextField('plainText', 'Plain Text');
+    Fields::refreshFields();
+
+    // the fixture files reference these handles, so they're pinned rather than generated
+    $this->entryType = ImportFixtures::entryTypeWithTitle(
+        [CustomField::make($plainTextField->handle)],
+        ['name' => 'Fixture Type', 'handle' => 'fixtureType'],
+    );
+    $this->otherEntryType = ImportFixtures::entryTypeWithTitle(
+        [CustomField::make($plainTextField->handle)],
+        ['name' => 'Other Type', 'handle' => 'otherType'],
+    );
+    $this->section = Section::factory()
+        ->withEntryTypes($this->entryType, $this->otherEntryType)
+        ->create(['handle' => 'fixtureSection', 'minAuthors' => 0]);
+
+    EntryTypes::refreshEntryTypes();
+    Fields::refreshFields();
+
+    $this->command = fn (string $file, array $options = []) => $this->artisan('craft:import:entry', [
+        'file' => 'tests/Fixtures/Import/'.$file,
+        '--site' => Sites::getPrimarySite()->handle,
+        '--transformer' => EntryTransformer::class,
+        '--section' => $this->section->uid,
+        '--entryType' => $this->entryType->uid,
+        ...$options,
+    ]);
+});
+
+afterEach(function () {
+    Aliases::set('@root', $this->originalRoot);
+});
+
+it('imports every row of a JSON file', function () {
+    ($this->command)('entries-plain-text.json', ['--matchCriteria' => '={"title":"title"}'])
+        ->assertSuccessful();
+
+    expect(EntryElement::find()->section($this->section->handle)->count())->toBe(3)
+        ->and(EntryElement::find()->title('first file entry')->one()->getFieldValue('plainText'))->toBe('text from the file');
+});
+
+it('updates the same entries on a second run instead of duplicating them', function () {
+    ($this->command)('entries-plain-text.json', ['--matchCriteria' => '={"title":"title"}'])
+        ->assertSuccessful();
+
+    $entryId = EntryElement::find()->title('first file entry')->one()->id;
+
+    ($this->command)('entries-plain-text-updated.json', ['--matchCriteria' => '={"title":"title"}'])
+        ->assertSuccessful();
+
+    $entry = EntryElement::find()->title('first file entry')->one();
+
+    expect(EntryElement::find()->section($this->section->handle)->count())->toBe(3)
+        ->and($entry->id)->toBe($entryId)
+        ->and($entry->getFieldValue('plainText'))->toBe('UPDATED text from the file');
+});
+
+it('fails with a validation error when the file does not exist', function () {
+    ($this->command)('does-not-exist.json', ['--transformer' => 'null', '--matchCriteria' => '={"title":"title"}'])
+        ->assertFailed();
+
+    expect(EntryElement::find()->section($this->section->handle)->count())->toBe(0);
+});
+
+it('accepts match criteria entered through the prompt with a leading "="', function () {
+    ($this->command)('entries-plain-text.json', ['--transformer' => EntryTransformer::class])
+        ->expectsQuestion(MATCH_CRITERIA_QUESTION, '={"title":"title"}')
+        ->assertSuccessful();
+
+    ($this->command)('entries-plain-text-updated.json', ['--transformer' => EntryTransformer::class])
+        ->expectsQuestion(MATCH_CRITERIA_QUESTION, '={"title":"title"}')
+        ->assertSuccessful();
+
+    expect(EntryElement::find()->section($this->section->handle)->count())->toBe(3)
+        ->and(EntryElement::find()->title('first file entry')->one()->getFieldValue('plainText'))
+        ->toBe('UPDATED text from the file');
+});
+
+it('prompts for the transformer when the option is omitted, defaulting it when left empty', function () {
+    $this->artisan('craft:import:entry', [
+        'file' => 'tests/Fixtures/Import/entries-plain-text.json',
+        '--site' => Sites::getPrimarySite()->handle,
+        '--matchCriteria' => '={"title":"title"}',
+        '--section' => $this->section->uid,
+        '--entryType' => $this->entryType->uid,
+    ])
+        ->expectsQuestion(TRANSFORMER_QUESTION, '')
+        ->assertSuccessful();
+
+    expect(EntryElement::find()->section($this->section->handle)->count())->toBe(3)
+        // the defaulted transformer still has to map the rows' values, not just create entries
+        ->and(EntryElement::find()->title('first file entry')->one()->getFieldValue('plainText'))->toBe('text from the file');
+});
+
+it('throws for an unknown site handle', function () {
+    ($this->command)('entries-plain-text.json', ['--site' => 'no-such-site', '--matchCriteria' => '={"title":"title"}'])
+        ->assertFailed();
+});
diff --git a/tests/Feature/Import/ElementImporterTest.php b/tests/Feature/Import/ElementImporterTest.php
new file mode 100644
index 00000000000..3176432b76e
--- /dev/null
+++ b/tests/Feature/Import/ElementImporterTest.php
@@ -0,0 +1,118 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Address\Elements\Address;
+use CraftCms\Cms\Asset\Elements\Asset as AssetElement;
+use CraftCms\Cms\Asset\Import\AssetImporter;
+use CraftCms\Cms\Element\Import\ElementImporter;
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Field\Elements\ContentBlock;
+use CraftCms\Cms\FieldLayout\Models\FieldLayout;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Site\Models\Site as SiteModel;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\User\Elements\User as UserElement;
+use CraftCms\Cms\User\Import\UserImporter;
+
+it('resolves site() from a numeric ID', function () {
+    $site = SiteModel::factory()->create();
+
+    $importer = EntryImporter::create()->site(Sites::getSiteById($site->id)->id);
+
+    expect($importer->site->id)->toBe($site->id);
+});
+
+it('resolves site() from a UID', function () {
+    $site = SiteModel::factory()->create();
+
+    $importer = EntryImporter::create()->site(Sites::getSiteById($site->id)->uid);
+
+    expect($importer->site->id)->toBe($site->id);
+});
+
+it('resolves site(null) to the primary site', function () {
+    $importer = EntryImporter::create()->site(null);
+
+    expect($importer->site->id)->toBe(Sites::getPrimarySite()->id);
+});
+
+it('throws when site() is given a nonexistent numeric ID', function () {
+    EntryImporter::create()->site(999999);
+})->throws(InvalidArgumentException::class, 'No site found with ID: 999999');
+
+it('throws when site() is given a nonexistent handle or UID', function () {
+    EntryImporter::create()->site('nonexistent-handle');
+})->throws(InvalidArgumentException::class, 'No site found with handle or UID: "nonexistent-handle".');
+
+it('resolves fieldLayout() from a numeric ID', function () {
+    $fieldLayout = FieldLayout::factory()->create(['type' => EntryElement::class]);
+    Fields::refreshFields();
+
+    $importer = EntryImporter::create()->fieldLayout($fieldLayout->id);
+
+    expect($importer->fieldLayout)->toBe($fieldLayout->uid);
+});
+
+it('resolves fieldLayout() from a UID', function () {
+    $fieldLayout = FieldLayout::factory()->create(['type' => EntryElement::class]);
+    Fields::refreshFields();
+
+    $importer = EntryImporter::create()->fieldLayout($fieldLayout->uid);
+
+    expect($importer->fieldLayout)->toBe($fieldLayout->uid);
+});
+
+it('resolves fieldLayout() from an existing type without creating a new layout', function () {
+    $fieldLayout = FieldLayout::factory()->create(['type' => Address::class]);
+    Fields::refreshFields();
+
+    $importer = EntryImporter::create()->fieldLayout(Address::class);
+
+    expect($importer->fieldLayout)->toBe($fieldLayout->uid);
+});
+
+it('throws when fieldLayout() is given a nonexistent numeric ID', function () {
+    EntryImporter::create()->fieldLayout(999999);
+})->throws(InvalidArgumentException::class, 'No field layout found with ID: 999999');
+
+it('resolves fieldLayout() with an arbitrary string to a new unsaved layout for that type', function () {
+    // `Fields::getLayoutByType()` defaults to creating an in-memory (unsaved) layout for
+    // any type string that doesn't already have one — a string can never be "not found"
+    // via this path, only a numeric ID can throw.
+    $importer = EntryImporter::create()->fieldLayout('not-a-real-uid-and-not-a-class-string');
+
+    expect($importer->fieldLayout)->toBe('not-a-real-uid-and-not-a-class-string');
+});
+
+it('registers a concrete ElementImporter subclass per core importable element type', function (string $importerClass, string $elementClass) {
+    expect(is_subclass_of($importerClass, ElementImporter::class))->toBeTrue()
+        ->and($importerClass::targetClass())->toBe($elementClass)
+        ->and($importerClass::displayName())->toBeString()->not->toBe('');
+
+    $importer = $importerClass::create();
+
+    expect($importer::targetClass())->toBe($elementClass);
+})->with([
+    'Entry' => [EntryImporter::class, EntryElement::class],
+    'Asset' => [AssetImporter::class, AssetElement::class],
+    'User' => [UserImporter::class, UserElement::class],
+]);
+
+it('lists the concrete element importer subclasses, not a bare ElementImporter, in the registry', function () {
+    $types = app(Import::class)->getAllImporterTypes();
+
+    expect($types)->not->toContain(ElementImporter::class)
+        ->and($types)->toContain(EntryImporter::class)
+        ->and($types)->toContain(AssetImporter::class)
+        ->and($types)->toContain(UserImporter::class);
+});
+
+it('has no registered importer for element types that never exist standalone', function () {
+    $import = app(Import::class);
+
+    expect($import->getElementImporterTypeFor(Address::class))->toBeNull()
+        ->and($import->getElementImporterTypeFor(ContentBlock::class))->toBeNull();
+});
diff --git a/tests/Feature/Import/ImportAddressFieldTest.php b/tests/Feature/Import/ImportAddressFieldTest.php
new file mode 100644
index 00000000000..b1a560a88a3
--- /dev/null
+++ b/tests/Feature/Import/ImportAddressFieldTest.php
@@ -0,0 +1,275 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Address\Elements\Address;
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Field\Addresses as AddressesField;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $addressesField = Field::factory()->create([
+        'name' => 'My Addresses',
+        'handle' => 'myAddresses',
+        'type' => AddressesField::class,
+    ]);
+
+    Fields::refreshFields();
+
+    $seed = ImportFixtures::seedEntry(
+        [CustomField::make($addressesField->handle)],
+        ['name' => 'With Addresses Field', 'handle' => 'withAddressesField'],
+        entryAttrs: ['title' => 'some entry', 'slug' => 'some-entry'],
+    );
+
+    $this->section = $seed->section;
+    $this->entryType = $seed->entryType;
+
+    $this->importer = EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null);
+
+    $this->entryData = fn (array $addresses) => [
+        'title' => 'imported entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $this->entryType->handle,
+        'myAddresses' => $addresses,
+        'matchCriteria' => ['title' => 'title'],
+    ];
+
+    $this->address = [
+        'title' => 'address 1',
+        'countryCode' => 'US',
+        'addressLine1' => '123 Main St',
+        'addressLine2' => 'Apt 4',
+        'administrativeArea' => 'UT',
+        'postalCode' => '12345',
+        'locality' => 'My Town',
+    ];
+});
+
+it('imports an entry with an addresses field', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([$this->address]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry)->not()->toBeNull();
+    expect(Address::find()->ownerId($entry->id)->count())->toBe(1);
+});
+
+it('imports multiple addresses into the addresses field', function () {
+    $second = array_merge($this->address, ['title' => 'address 2', 'addressLine1' => '456 Elm St']);
+
+    $this->import->importItem($this->importer, ($this->entryData)([$this->address, $second]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect(Address::find()->ownerId($entry->id)->count())->toBe(2);
+});
+
+it('maps native address fields correctly', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([$this->address]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $address = Address::find()->ownerId($entry->id)->one();
+
+    expect($address->countryCode)->toBe($this->address['countryCode'])
+        ->and($address->addressLine1)->toBe($this->address['addressLine1'])
+        ->and($address->addressLine2)->toBe($this->address['addressLine2'])
+        ->and($address->administrativeArea)->toBe($this->address['administrativeArea'])
+        ->and($address->postalCode)->toBe($this->address['postalCode'])
+        ->and($address->locality)->toBe($this->address['locality'])
+        ->and($address->title)->toBe($this->address['title']);
+});
+
+it('updates an existing address when match criteria matches', function () {
+    $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+
+    $addressWithCriteria = array_merge($this->address, [
+        'matchCriteria' => ['title' => 'title'],
+    ]);
+
+    $this->import->importItem($importer, ($this->entryData)([$addressWithCriteria]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect(Address::find()->ownerId($entry->id)->count())->toBe(1);
+    $addressId = Address::find()->ownerId($entry->id)->one()->id;
+
+    $addressLine1Updated = '999 Updated Ave';
+
+    $updated = array_merge($addressWithCriteria, ['addressLine1' => $addressLine1Updated]);
+    $this->import->importItem($importer, ($this->entryData)([$updated]));
+
+    $address = Address::find()->ownerId($entry->id)->one();
+
+    expect(Address::find()->ownerId($entry->id)->count())->toBe(1)
+        // without the id check this passes whether the address is matched or recreated
+        ->and($address->id)->toBe($addressId)
+        ->and($address->addressLine1)->toBe($addressLine1Updated);
+});
+
+it('creates a new address when match criteria does not match any existing address', function () {
+    $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+
+    $firstAddress = array_merge($this->address, [
+        'matchCriteria' => ['title' => 'title'],
+    ]);
+
+    $this->import->importItem($importer, ($this->entryData)([$firstAddress]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect(Address::find()->ownerId($entry->id)->count())->toBe(1);
+
+    // second import: different address title, so matchCriteria finds no match → creates new address
+    $newAddress = array_merge($this->address, [
+        'title' => 'address 2',
+        'addressLine1' => '456 Elm St',
+        'matchCriteria' => ['title' => 'title'],
+    ]);
+    $this->import->importItem($importer, ($this->entryData)([$firstAddress, $newAddress]));
+
+    expect(Address::find()->ownerId($entry->id)->count())->toBe(2);
+});
+
+// the manual fixture supplies latitude/longitude as strings inside a nested latLong object
+it('imports latLong given as a nested object of strings', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        [...$this->address, 'latLong' => ['latitude' => '37.7749', 'longitude' => '-122.4194']],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $address = Address::find()->ownerId($entry->id)->one();
+
+    expect($address->latitude)->toEqual('37.7749')
+        ->and($address->longitude)->toEqual('-122.4194');
+});
+
+// the manual fixture sends "country", while the element exposes countryCode - this pins which one
+// the Import actually reads
+it('reads the country code from countryCode, not from a country key', function () {
+    $address = $this->address;
+    unset($address['countryCode']);
+
+    $this->import->importItem($this->importer, ($this->entryData)([[...$address, 'country' => 'GB']]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $imported = Address::find()->ownerId($entry->id)->one();
+
+    expect($imported)->not->toBeNull()
+        ->and($imported->countryCode)->not->toBe('GB');
+});
+
+// Nested criteria supplied by the importer config rather than inlined in each row: the config's
+// criteria for the container is what a type-less row resolves against.
+it('matches an address using nested match criteria from the importer config', function () {
+    $importer = (clone $this->importer)->matchCriteria([
+        'title' => 'title',
+        'myAddresses' => ['title' => 'title'],
+    ]);
+
+    ImportFixtures::importWithConfigCriteria($this->import, $importer, ($this->entryData)([$this->address]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $addressId = Address::find()->ownerId($entry->id)->one()->id;
+
+    ImportFixtures::importWithConfigCriteria($this->import, $importer, ($this->entryData)([
+        [...$this->address, 'addressLine1' => '999 Updated Ave'],
+    ]));
+
+    $address = Address::find()->ownerId($entry->id)->one();
+
+    expect(Address::find()->ownerId($entry->id)->count())->toBe(1)
+        ->and($address->id)->toBe($addressId)
+        ->and($address->addressLine1)->toBe('999 Updated Ave');
+});
+
+// clearableItems declared under an addresses field has to reach the type-less rows too
+it('clears a native address field marked clearable when it is missing from a later import', function () {
+    $importer = (clone $this->importer)
+        ->matchCriteria(['title' => 'title'])
+        ->clearableItems(['myAddresses' => ['addressLine2' => true]]);
+
+    $addressWithCriteria = [...$this->address, 'matchCriteria' => ['title' => 'title']];
+
+    $this->import->importItem($importer, ($this->entryData)([$addressWithCriteria]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $address = Address::find()->ownerId($entry->id)->one();
+    expect($address->addressLine2)->toBe($this->address['addressLine2']);
+    $addressId = $address->id;
+
+    $withoutLine2 = $addressWithCriteria;
+    unset($withoutLine2['addressLine2']);
+
+    $this->import->importItem($importer, ($this->entryData)([$withoutLine2]));
+
+    $address = Address::find()->ownerId($entry->id)->one();
+
+    expect($address->id)->toBe($addressId)
+        ->and($address->addressLine2)->toBeNull();
+});
+
+// a row that only says how to match, with no address content, isn't an address at all
+it('creates no address for a row that carries only match criteria', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        ['matchCriteria' => ['title' => 'title']],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry)->not->toBeNull()
+        ->and(Address::find()->ownerId($entry->id)->count())->toBe(0);
+});
+
+it('ignores a criteria-only row while importing the real ones', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        $this->address,
+        ['matchCriteria' => ['title' => 'title']],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $addresses = Address::find()->ownerId($entry->id)->all();
+
+    expect($addresses)->toHaveCount(1)
+        ->and($addresses[0]->title)->toBe($this->address['title'])
+        ->and($addresses[0]->addressLine1)->toBe($this->address['addressLine1']);
+});
+
+// the canonical shape: the CP control posts latitude & longitude as flat inputs, and the mapping UI
+// offers them as two separate columns
+it('imports flat latitude and longitude', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        [...$this->address, 'latitude' => '37.7749', 'longitude' => '-122.4194'],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $address = Address::find()->ownerId($entry->id)->one();
+
+    expect($address->latitude)->toEqual('37.7749')
+        ->and($address->longitude)->toEqual('-122.4194');
+});
+
+// $addressData += $addressData['latLong'] keeps keys that are already set, so a flat value wins
+it('prefers a flat latitude over a nested one', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        [
+            ...$this->address,
+            'latitude' => '1.1111',
+            'latLong' => ['latitude' => '9.9999', 'longitude' => '-122.4194'],
+        ],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $address = Address::find()->ownerId($entry->id)->one();
+
+    expect($address->latitude)->toEqual('1.1111')
+        ->and($address->longitude)->toEqual('-122.4194');
+});
diff --git a/tests/Feature/Import/ImportAssetTest.php b/tests/Feature/Import/ImportAssetTest.php
new file mode 100644
index 00000000000..847a7ab578c
--- /dev/null
+++ b/tests/Feature/Import/ImportAssetTest.php
@@ -0,0 +1,207 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Asset\AssetsHelper;
+use CraftCms\Cms\Asset\Elements\Asset;
+use CraftCms\Cms\Asset\Exceptions\AssetDisallowedExtensionException;
+use CraftCms\Cms\Asset\Exceptions\FileException;
+use CraftCms\Cms\Asset\Import\AssetImporter;
+use CraftCms\Cms\Asset\Models\Volume;
+use CraftCms\Cms\Asset\Models\VolumeFolder;
+use CraftCms\Cms\FieldLayout\Models\FieldLayout;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Support\Facades\Folders;
+use CraftCms\Cms\Support\Facades\Path;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Support\Facades\Volumes;
+use Illuminate\Support\Facades\File;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $this->diskRoot = storage_path('framework/testing/import-assets/'.bin2hex(random_bytes(4)));
+    config()->set('filesystems.disks.import-test-disk', [
+        'driver' => 'local',
+        'root' => $this->diskRoot,
+    ]);
+
+    // Volume::factory() doesn't assign a fieldLayoutId by default, which leaves getFieldLayout()
+    // returning an unsaved, id-less layout that ElementImporter::fieldLayout() can't resolve back
+    // to the volume via its uid — so a real, persisted FieldLayout has to be attached explicitly.
+    $this->volume = Volume::factory()->create([
+        'name' => 'Imports',
+        'handle' => 'imports',
+        'fs' => 'import-test-disk',
+        'fieldLayoutId' => FieldLayout::factory()->create(['type' => Asset::class])->id,
+    ]);
+
+    $this->otherVolume = Volume::factory()->create([
+        'name' => 'Other',
+        'handle' => 'other',
+        'fs' => 'import-test-disk',
+        'fieldLayoutId' => FieldLayout::factory()->create(['type' => Asset::class])->id,
+    ]);
+
+    $this->rootFolder = Folders::getRootFolderByVolumeId($this->volume->id);
+    $this->otherRootFolder = Folders::getRootFolderByVolumeId($this->otherVolume->id);
+
+    $volumeData = Volumes::getVolumeById($this->volume->id);
+
+    $this->importer = AssetImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->fieldLayout($volumeData->getFieldLayout())
+        ->transformer(null);
+
+    $this->tempFilePaths = [];
+    $this->makeTempFile = function (string $extension = 'txt', string $contents = 'hello world') {
+        $path = AssetsHelper::tempFilePath($extension);
+        file_put_contents($path, $contents);
+        $this->tempFilePaths[] = $path;
+
+        return $path;
+    };
+});
+
+afterEach(function () {
+    // a successful import moves the temp file into the volume, so only the leftovers need deleting
+    foreach ($this->tempFilePaths ?? [] as $path) {
+        if (File::exists($path)) {
+            File::delete($path);
+        }
+    }
+
+    if (isset($this->diskRoot)) {
+        File::deleteDirectory($this->diskRoot);
+    }
+});
+
+it('imports an asset from a local temp file, deducing the filename and defaulting the folder', function () {
+    $tempFilePath = ($this->makeTempFile)('txt');
+    $expectedFilename = pathinfo((string) $tempFilePath, PATHINFO_BASENAME);
+
+    $this->import->importItem($this->importer, ['tempFilePath' => $tempFilePath]);
+
+    $asset = Asset::find()->volumeId($this->volume->id)->one();
+
+    expect($asset)->not->toBeNull()
+        ->and($asset->filename)->toBe($expectedFilename)
+        ->and($asset->folderId)->toBe($this->rootFolder->id);
+});
+
+it('uses an explicitly provided filename instead of deriving it from the temp file path', function () {
+    $tempFilePath = ($this->makeTempFile)('txt');
+
+    $this->import->importItem($this->importer, [
+        'tempFilePath' => $tempFilePath,
+        'filename' => 'custom-name.txt',
+    ]);
+
+    $asset = Asset::find()->volumeId($this->volume->id)->filename('custom-name.txt')->one();
+
+    expect($asset)->not->toBeNull();
+});
+
+it('throws for a disallowed file extension', function () {
+    $tempFilePath = ($this->makeTempFile)('exe');
+
+    expect(fn () => $this->import->importItem($this->importer, ['tempFilePath' => $tempFilePath]))
+        ->toThrow(AssetDisallowedExtensionException::class);
+});
+
+it('uses an explicitly provided valid folder ID', function () {
+    $folder = VolumeFolder::factory()->create([
+        'volumeId' => $this->volume->id,
+        'parentId' => $this->rootFolder->id,
+        'name' => 'Sub',
+        'path' => 'sub/',
+    ]);
+    $tempFilePath = ($this->makeTempFile)('txt');
+
+    $this->import->importItem($this->importer, [
+        'tempFilePath' => $tempFilePath,
+        'folderId' => $folder->id,
+    ]);
+
+    $asset = Asset::find()->volumeId($this->volume->id)->one();
+
+    expect($asset->folderId)->toBe($folder->id);
+});
+
+it('resolves a folder provided by name', function () {
+    $folder = VolumeFolder::factory()->create([
+        'volumeId' => $this->volume->id,
+        'parentId' => $this->rootFolder->id,
+        'name' => 'ByName',
+        'path' => 'by-name/',
+    ]);
+    $tempFilePath = ($this->makeTempFile)('txt');
+
+    $this->import->importItem($this->importer, [
+        'tempFilePath' => $tempFilePath,
+        'folderId' => 'ByName',
+    ]);
+
+    $asset = Asset::find()->volumeId($this->volume->id)->one();
+
+    expect($asset->folderId)->toBe($folder->id);
+});
+
+it('falls back to the target volume root folder when the given folder belongs to a different volume', function () {
+    $foreignFolder = VolumeFolder::factory()->create([
+        'volumeId' => $this->otherVolume->id,
+        'parentId' => $this->otherRootFolder->id,
+        'name' => 'Foreign',
+        'path' => 'foreign/',
+    ]);
+    $tempFilePath = ($this->makeTempFile)('txt');
+
+    $this->import->importItem($this->importer, [
+        'tempFilePath' => $tempFilePath,
+        'folderId' => $foreignFolder->id,
+    ]);
+
+    $asset = Asset::find()->volumeId($this->volume->id)->one();
+
+    expect($asset->folderId)->toBe($this->rootFolder->id);
+});
+
+it('ignores an explicit volumeId in the incoming data in favor of the field layout provider volume', function () {
+    $tempFilePath = ($this->makeTempFile)('txt');
+
+    $this->import->importItem($this->importer, [
+        'tempFilePath' => $tempFilePath,
+        'volumeId' => $this->otherVolume->id,
+    ]);
+
+    $asset = Asset::find()->filename(pathinfo((string) $tempFilePath, PATHINFO_BASENAME))->one();
+
+    expect($asset)->not->toBeNull()
+        ->and($asset->volumeId)->toBe($this->volume->id);
+});
+
+it('throws for a local temp file path that resolves outside of all allowed roots', function () {
+    // A real, existing file outside every allowed temp root — e.g. one under tests/, which
+    // Path::system() excludes.
+    $outsidePath = base_path('tests/fixtures-import-asset-'.bin2hex(random_bytes(4)).'.txt');
+    file_put_contents($outsidePath, 'not allowed');
+
+    try {
+        $asset = new Asset;
+        $asset->setVolumeId($this->volume->id);
+
+        expect(fn () => $this->importer->setAttributesForImport($asset, ['tempFilePath' => $outsidePath]))
+            ->toThrow(FileException::class);
+    } finally {
+        @unlink($outsidePath);
+    }
+});
+
+it('throws for a local temp file path that does not exist on disk', function () {
+    $asset = new Asset;
+    $asset->setVolumeId($this->volume->id);
+
+    expect(fn () => $this->importer->setAttributesForImport($asset, [
+        'tempFilePath' => Path::temp('does-not-exist-'.bin2hex(random_bytes(4)).'.txt'),
+    ]))->toThrow(FileException::class);
+});
diff --git a/tests/Feature/Import/ImportClearableItemsTest.php b/tests/Feature/Import/ImportClearableItemsTest.php
new file mode 100644
index 00000000000..a6766e6d311
--- /dev/null
+++ b/tests/Feature/Import/ImportClearableItemsTest.php
@@ -0,0 +1,173 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\Field\PlainText;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $plainTextField = Field::factory()->create([
+        'name' => 'My Plain Text',
+        'handle' => 'myPlainText',
+        'type' => PlainText::class,
+    ]);
+
+    Fields::refreshFields();
+
+    $seed = ImportFixtures::seedEntry(
+        [CustomField::make($plainTextField->handle)],
+        ['name' => 'With Plain Text', 'handle' => 'withPlainText'],
+        entryAttrs: ['title' => 'imported entry', 'slug' => 'imported-entry'],
+    );
+
+    $this->section = $seed->section;
+    $this->entryType = $seed->entryType;
+
+    $this->importer = EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->matchCriteria(['title' => 'title'])
+        ->transformer(null);
+
+    $this->entryData = fn (array $fieldValues = []) => array_merge([
+        'title' => 'imported entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $this->entryType->handle,
+        'matchCriteria' => ['title' => 'title'],
+    ], $fieldValues);
+
+    // seed the field value through the same import pipeline, since the entry factory can't
+    // write directly to a custom field's content column
+    $this->import->importItem($this->importer, ($this->entryData)(['myPlainText' => 'original value']));
+});
+
+it('clears an existing field value when the field is not mapped/provided at all and is marked clearable', function () {
+    $importer = (clone $this->importer)->clearableItems(['myPlainText']);
+
+    $this->import->importItem($importer, ($this->entryData)());
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myPlainText'))->toBeNull();
+});
+
+it('clears an existing field value when the provided value is an empty string and the field is marked clearable', function () {
+    $importer = (clone $this->importer)->clearableItems(['myPlainText' => true]);
+
+    $this->import->importItem($importer, ($this->entryData)(['myPlainText' => '']));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myPlainText'))->toBeNull();
+});
+
+it('clears an existing field value when the provided value is whitespace only and the field is marked clearable', function () {
+    $importer = (clone $this->importer)->clearableItems(['myPlainText' => true]);
+
+    $this->import->importItem($importer, ($this->entryData)(['myPlainText' => '   ']));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myPlainText'))->toBeNull();
+});
+
+it('leaves an existing field value untouched when the field is not marked clearable, even if the value is missing/empty', function () {
+    $this->import->importItem($this->importer, ($this->entryData)());
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myPlainText'))->toBe('original value');
+});
+
+it('leaves an existing field value untouched when the field is not marked clearable and an empty value is explicitly provided', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myPlainText' => '']));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myPlainText'))->toBe('original value');
+});
+
+it('leaves a provided non-empty value alone even when the field is marked clearable', function () {
+    $importer = (clone $this->importer)->clearableItems(['myPlainText']);
+
+    $this->import->importItem($importer, ($this->entryData)(['myPlainText' => 'a new value']));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myPlainText'))->toBe('a new value');
+});
+
+it('normalizes a flat list of dot-notation handles into the nested truthy-leaf shape', function () {
+    $importer = EntryImporter::create()->clearableItems(['myPlainText', 'some.nested.handle']);
+
+    expect($importer->clearableItems)->toBe([
+        'myPlainText' => true,
+        'some' => ['nested' => ['handle' => true]],
+    ]);
+});
+
+it('accepts an already-nested truthy-leaf shape as-is', function () {
+    $importer = EntryImporter::create()->clearableItems(['myPlainText' => 1]);
+
+    expect($importer->clearableItems)->toBe(['myPlainText' => 1]);
+});
+
+describe('nested matrix clearing', function () {
+    beforeEach(function () {
+        $plainTextField = ImportFixtures::plainTextField('plainText', 'Plain Text');
+        $blockEntryType = ImportFixtures::blockEntryType('blockEt', [$plainTextField], 'Block ET');
+        $matrixField = ImportFixtures::matrixField('myMatrix', [$blockEntryType], 'My Matrix');
+
+        $seed = ImportFixtures::seedEntry(
+            [CustomField::make($matrixField->handle)],
+            ['name' => 'With Matrix', 'handle' => 'withMatrix'],
+            entryAttrs: ['title' => 'matrix entry', 'slug' => 'matrix-entry'],
+        );
+
+        $this->matrixSection = $seed->section;
+        $this->matrixEntryType = $seed->entryType;
+
+        $this->matrixImporter = EntryImporter::create()
+            ->site(Sites::getPrimarySite()->handle)
+            ->matchCriteria(['title' => 'title'])
+            ->clearableItems(['myMatrix' => ['blockEt' => ['fields' => ['plainText' => true]]]])
+            ->transformer(null);
+
+        $this->matrixEntryData = fn (array $blocks) => [
+            'title' => 'matrix entry',
+            'sectionId' => $this->matrixSection->handle,
+            'typeId' => $this->matrixEntryType->handle,
+            'myMatrix' => $blocks,
+        ];
+    });
+
+    it('clears an existing block field value when it is missing on a later import', function () {
+        $this->import->importItem($this->matrixImporter, ($this->matrixEntryData)([
+            [
+                'type' => 'blockEt',
+                'title' => 'block 1',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => ['plainText' => 'foo'],
+            ],
+        ]));
+
+        $entry = EntryElement::find()->title('matrix entry')->one();
+        $block = $entry->getFieldValue('myMatrix')->one();
+        expect($block->getFieldValue('plainText'))->toBe('foo');
+
+        $this->import->importItem($this->matrixImporter, ($this->matrixEntryData)([
+            [
+                'type' => 'blockEt',
+                'title' => 'block 1',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => [],
+            ],
+        ]));
+
+        $entry = EntryElement::find()->title('matrix entry')->one();
+        $block = $entry->getFieldValue('myMatrix')->one();
+        expect($block->getFieldValue('plainText'))->toBeNull();
+    });
+});
diff --git a/tests/Feature/Import/ImportContentBlockFieldTest.php b/tests/Feature/Import/ImportContentBlockFieldTest.php
new file mode 100644
index 00000000000..192a14762fc
--- /dev/null
+++ b/tests/Feature/Import/ImportContentBlockFieldTest.php
@@ -0,0 +1,316 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Field\Addresses as AddressesField;
+use CraftCms\Cms\Field\ContentBlock as ContentBlockField;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\Field\PlainText;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Support\Str;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $innerField = Field::factory()->create([
+        'name' => 'CB Text',
+        'handle' => 'cbText',
+        'type' => PlainText::class,
+    ]);
+
+    $blockTextField = ImportFixtures::plainTextField('blockText', 'Block Text');
+    $blockEntryType = ImportFixtures::blockEntryType('cbBlockEt', [$blockTextField], 'CB Block ET');
+
+    // one matrix inside the content block, one alongside it on the entry
+    $cbMatrixField = ImportFixtures::matrixField('cbMatrix', [$blockEntryType], 'CB Matrix');
+    $entryMatrixField = ImportFixtures::matrixField('myMatrix', [$blockEntryType], 'My Matrix');
+
+    $addressesField = Field::factory()->create([
+        'name' => 'My Addresses',
+        'handle' => 'myAddresses',
+        'type' => AddressesField::class,
+    ]);
+
+    Fields::refreshFields();
+
+    $layoutUid = Str::uuid()->toString();
+    $contentBlockField = Field::factory()->create([
+        'name' => 'My Content Block',
+        'handle' => 'myContentBlock',
+        'type' => ContentBlockField::class,
+        'settings' => [
+            'fieldLayouts' => [
+                $layoutUid => [
+                    'tabs' => [[
+                        'uid' => Str::uuid()->toString(),
+                        'name' => 'Content',
+                        'elements' => [
+                            [
+                                'uid' => Str::uuid()->toString(),
+                                'type' => CustomField::class,
+                                'fieldUid' => $innerField->uid,
+                                'required' => false,
+                            ],
+                            [
+                                'uid' => Str::uuid()->toString(),
+                                'type' => CustomField::class,
+                                'fieldUid' => $cbMatrixField->uid,
+                                'required' => false,
+                            ],
+                        ],
+                    ]],
+                ],
+            ],
+        ],
+    ]);
+
+    Fields::refreshFields();
+
+    $seed = ImportFixtures::seedEntry(
+        [
+            CustomField::make($contentBlockField->handle),
+            CustomField::make($entryMatrixField->handle),
+            CustomField::make($addressesField->handle),
+        ],
+        ['name' => 'With Content Block Field', 'handle' => 'withContentBlockField'],
+    );
+
+    $this->section = $seed->section;
+    $this->entryType = $seed->entryType;
+
+    EntryTypes::refreshEntryTypes();
+    Fields::refreshFields();
+
+    $this->importer = EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null);
+
+    $this->entryData = fn (?array $contentBlock) => [
+        'title' => 'imported entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $this->entryType->handle,
+        'myContentBlock' => $contentBlock,
+        'matchCriteria' => ['title' => 'title'],
+    ];
+
+    // for rows that set more than just the content block
+    $this->entryDataWith = fn (array $values) => array_merge([
+        'title' => 'imported entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $this->entryType->handle,
+        'matchCriteria' => ['title' => 'title'],
+    ], $values);
+
+    $this->address = [
+        'title' => 'address 1',
+        'countryCode' => 'US',
+        'addressLine1' => '123 Main St',
+        'administrativeArea' => 'UT',
+        'postalCode' => '12345',
+        'locality' => 'My Town',
+    ];
+});
+
+it('imports an entry with a content block field', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'fields' => ['cbText' => 'foo'],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry)->not()->toBeNull();
+    expect($entry->getFieldValue('myContentBlock'))->not()->toBeNull();
+});
+
+it('maps content block field values correctly', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'fields' => ['cbText' => 'foo'],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry->getFieldValue('myContentBlock')->getFieldValue('cbText'))->toBe('foo');
+});
+
+it('updates content block field values on re-import', function () {
+    $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+
+    $this->import->importItem($importer, ($this->entryData)([
+        'fields' => ['cbText' => 'foo'],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myContentBlock')->getFieldValue('cbText'))->toBe('foo');
+
+    $this->import->importItem($importer, ($this->entryData)([
+        'fields' => ['cbText' => 'updated text'],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myContentBlock')->getFieldValue('cbText'))->toBe('updated text');
+});
+
+// The manual fixtures nest a matrix inside a content block (myCb.fields.matrixInner); only the
+// reverse (a content block inside a matrix) was covered before.
+it('imports a matrix nested inside a content block', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'fields' => [
+            'cbText' => 'foo',
+            'cbMatrix' => [
+                ['type' => 'cbBlockEt', 'title' => 'cb block 1', 'fields' => ['blockText' => 'one']],
+                ['type' => 'cbBlockEt', 'title' => 'cb block 2', 'fields' => ['blockText' => 'two']],
+            ],
+        ],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $blocks = $entry->getFieldValue('myContentBlock')->getFieldValue('cbMatrix')->all();
+
+    expect($entry->getFieldValue('myContentBlock')->getFieldValue('cbText'))->toBe('foo')
+        ->and($blocks)->toHaveCount(2)
+        ->and(array_map(fn ($block) => $block->title, $blocks))->toBe(['cb block 1', 'cb block 2'])
+        ->and($blocks[0]->getFieldValue('blockText'))->toBe('one');
+});
+
+/** A block for the matrix inside the content block, matched on its own title. */
+function cbNestedBlock(string $text): array
+{
+    return [
+        'type' => 'cbBlockEt',
+        'title' => 'cb block 1',
+        'matchCriteria' => ['title' => 'title'],
+        'fields' => ['blockText' => $text],
+    ];
+}
+
+it('updates the value of a matrix block nested inside a content block on re-import', function () {
+    $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+    $block = cbNestedBlock(...);
+
+    $this->import->importItem($importer, ($this->entryData)([
+        'fields' => ['cbText' => 'foo', 'cbMatrix' => [$block('one')]],
+    ]));
+
+    $this->import->importItem($importer, ($this->entryData)([
+        'fields' => ['cbText' => 'foo', 'cbMatrix' => [$block('updated one')]],
+    ]));
+
+    $blocks = EntryElement::find()->title('imported entry')->one()
+        ->getFieldValue('myContentBlock')->getFieldValue('cbMatrix');
+
+    expect($blocks->count())->toBe(1)
+        ->and($blocks->one()->getFieldValue('blockText'))->toBe('updated one');
+});
+
+// The entry and the content block element both keep their ids across the re-import, but the block
+// inside the content block doesn't - the same inline matchCriteria one level up (on a matrix
+// directly on the entry) does match in place, see ImportMatrixFieldTest's "updates an existing
+// block when match criteria matches".
+it('updates the same matrix block nested inside a content block in place', function () {
+    $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+    $block = cbNestedBlock(...);
+
+    $this->import->importItem($importer, ($this->entryData)([
+        'fields' => ['cbText' => 'foo', 'cbMatrix' => [$block('one')]],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $blockId = $entry->getFieldValue('myContentBlock')->getFieldValue('cbMatrix')->one()->id;
+
+    $this->import->importItem($importer, ($this->entryData)([
+        'fields' => ['cbText' => 'foo', 'cbMatrix' => [$block('updated one')]],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry->getFieldValue('myContentBlock')->getFieldValue('cbMatrix')->one()->id)->toBe($blockId);
+});
+
+// fixture row 5: a matrix, a content block and an addresses field all set on the same entry
+it('imports a matrix, a content block and addresses on one entry', function () {
+    $this->import->importItem($this->importer, ($this->entryDataWith)([
+        'myMatrix' => [
+            ['type' => 'cbBlockEt', 'title' => 'entry block', 'fields' => ['blockText' => 'matrix value']],
+        ],
+        'myContentBlock' => [
+            'fields' => [
+                'cbText' => 'content block value',
+                'cbMatrix' => [
+                    ['type' => 'cbBlockEt', 'title' => 'cb block', 'fields' => ['blockText' => 'nested value']],
+                ],
+            ],
+        ],
+        'myAddresses' => [$this->address],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $contentBlock = $entry->getFieldValue('myContentBlock');
+
+    expect($entry->getFieldValue('myMatrix')->count())->toBe(1)
+        ->and($entry->getFieldValue('myMatrix')->one()->getFieldValue('blockText'))->toBe('matrix value')
+        ->and($contentBlock->getFieldValue('cbText'))->toBe('content block value')
+        ->and($contentBlock->getFieldValue('cbMatrix')->one()->getFieldValue('blockText'))->toBe('nested value')
+        ->and($entry->getFieldValue('myAddresses')->count())->toBe(1)
+        ->and($entry->getFieldValue('myAddresses')->one()->addressLine1)->toBe('123 Main St');
+});
+
+// the other shape normalizeValueForImport() documents: field values straight in the top-level array
+// rather than wrapped in `fields`
+it('imports a content block whose values are given without a fields wrapper', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'cbText' => 'foo',
+        'cbMatrix' => [
+            ['type' => 'cbBlockEt', 'title' => 'cb block 1', 'fields' => ['blockText' => 'one']],
+        ],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $contentBlock = $entry->getFieldValue('myContentBlock');
+
+    expect($contentBlock->getFieldValue('cbText'))->toBe('foo')
+        ->and($contentBlock->getFieldValue('cbMatrix')->one()->getFieldValue('blockText'))->toBe('one');
+});
+
+it('still honours a fields wrapper when one is given', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'fields' => ['cbText' => 'foo'],
+    ]));
+
+    expect(EntryElement::find()->title('imported entry')->one()->getFieldValue('myContentBlock')->getFieldValue('cbText'))
+        ->toBe('foo');
+});
+
+// A content block only comes into existence when its owner saves, so importing one into an element
+// that's already saved and has no block yet depends on change detection noticing it.
+it('creates a content block on an element that has none yet', function () {
+    $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+
+    // the seeded entry exists already and has no content block
+    $this->import->importItem($importer, [
+        'title' => 'seed entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $this->entryType->handle,
+        'matchCriteria' => ['title' => 'title'],
+        'myContentBlock' => [
+            'fields' => [
+                'cbText' => 'foo',
+                'cbMatrix' => [
+                    ['type' => 'cbBlockEt', 'title' => 'cb block 1', 'fields' => ['blockText' => 'one']],
+                ],
+            ],
+        ],
+    ]);
+
+    $contentBlock = EntryElement::find()->title('seed entry')->status(null)->one()->getFieldValue('myContentBlock');
+
+    expect($contentBlock?->id)->not->toBeNull()
+        ->and($contentBlock->getFieldValue('cbText'))->toBe('foo')
+        ->and($contentBlock->getFieldValue('cbMatrix')->one()?->getFieldValue('blockText'))->toBe('one');
+});
diff --git a/tests/Feature/Import/ImportCustomFieldsTest.php b/tests/Feature/Import/ImportCustomFieldsTest.php
new file mode 100644
index 00000000000..0f50f5f7afc
--- /dev/null
+++ b/tests/Feature/Import/ImportCustomFieldsTest.php
@@ -0,0 +1,221 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Field\Assets as AssetsField;
+use CraftCms\Cms\Field\ButtonGroup;
+use CraftCms\Cms\Field\Checkboxes;
+use CraftCms\Cms\Field\Color;
+use CraftCms\Cms\Field\Country as CountryField;
+use CraftCms\Cms\Field\Date as DateField;
+use CraftCms\Cms\Field\Dropdown;
+use CraftCms\Cms\Field\Email;
+use CraftCms\Cms\Field\Entries as EntriesField;
+use CraftCms\Cms\Field\Icon;
+use CraftCms\Cms\Field\Json as JsonField;
+use CraftCms\Cms\Field\Lightswitch;
+use CraftCms\Cms\Field\Link as LinkField;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\Field\Money as MoneyField;
+use CraftCms\Cms\Field\MultiSelect;
+use CraftCms\Cms\Field\Number;
+use CraftCms\Cms\Field\PlainText;
+use CraftCms\Cms\Field\RadioButtons;
+use CraftCms\Cms\Field\Range;
+use CraftCms\Cms\Field\Table as TableField;
+use CraftCms\Cms\Field\Time as TimeField;
+use CraftCms\Cms\Field\Users as UsersField;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $options = [
+        ['label' => 'Option A', 'value' => 'optionA', 'default' => false],
+        ['label' => 'Option B', 'value' => 'optionB', 'default' => false],
+        ['label' => 'Option C', 'value' => 'optionC', 'default' => false],
+    ];
+
+    $allFields = [
+        Field::factory()->create(['name' => 'My Plain Text', 'handle' => 'myPlainText', 'type' => PlainText::class]),
+        Field::factory()->create(['name' => 'My Email', 'handle' => 'myEmail', 'type' => Email::class]),
+        Field::factory()->create(['name' => 'My Number', 'handle' => 'myNumber', 'type' => Number::class]),
+        Field::factory()->create(['name' => 'My Color', 'handle' => 'myColor', 'type' => Color::class]),
+        Field::factory()->create(['name' => 'My Country', 'handle' => 'myCountry', 'type' => CountryField::class]),
+        Field::factory()->create(['name' => 'My Lightswitch', 'handle' => 'myLightswitch', 'type' => Lightswitch::class]),
+        Field::factory()->create(['name' => 'My Range', 'handle' => 'myRange', 'type' => Range::class]),
+        Field::factory()->create(['name' => 'My Json', 'handle' => 'myJson', 'type' => JsonField::class]),
+        Field::factory()->create(['name' => 'My Date', 'handle' => 'myDate', 'type' => DateField::class]),
+        Field::factory()->create(['name' => 'My Time', 'handle' => 'myTime', 'type' => TimeField::class]),
+        Field::factory()->create(['name' => 'My Money', 'handle' => 'myMoney', 'type' => MoneyField::class, 'settings' => ['currency' => 'USD']]),
+        Field::factory()->create(['name' => 'My Icon', 'handle' => 'myIcon', 'type' => Icon::class]),
+        Field::factory()->create(['name' => 'My Link', 'handle' => 'myLink', 'type' => LinkField::class]),
+        Field::factory()->create(['name' => 'My Dropdown', 'handle' => 'myDropdown', 'type' => Dropdown::class, 'settings' => ['options' => $options]]),
+        Field::factory()->create(['name' => 'My Radio Buttons', 'handle' => 'myRadioButtons', 'type' => RadioButtons::class, 'settings' => ['options' => $options]]),
+        Field::factory()->create(['name' => 'My Button Group', 'handle' => 'myButtonGroup', 'type' => ButtonGroup::class, 'settings' => ['options' => $options]]),
+        Field::factory()->create(['name' => 'My Checkboxes', 'handle' => 'myCheckboxes', 'type' => Checkboxes::class, 'settings' => ['options' => $options]]),
+        Field::factory()->create(['name' => 'My Multi-select', 'handle' => 'myMultiSelect', 'type' => MultiSelect::class, 'settings' => ['options' => $options]]),
+        Field::factory()->create([
+            'name' => 'My Table',
+            'handle' => 'myTable',
+            'type' => TableField::class,
+            'settings' => [
+                'columns' => [
+                    'col1' => ['heading' => 'Column 1', 'handle' => 'col1', 'type' => 'singleline'],
+                    'col2' => ['heading' => 'Column 2', 'handle' => 'col2', 'type' => 'number'],
+                ],
+            ],
+        ]),
+        Field::factory()->create(['name' => 'My Entries', 'handle' => 'myEntries', 'type' => EntriesField::class]),
+        Field::factory()->create(['name' => 'My Users', 'handle' => 'myUsers', 'type' => UsersField::class]),
+        Field::factory()->create(['name' => 'My Assets', 'handle' => 'myAssets', 'type' => AssetsField::class]),
+    ];
+
+    Fields::refreshFields();
+
+    $layoutElements = array_map(fn ($field) => CustomField::make($field->handle), $allFields);
+
+    $seed = ImportFixtures::seedEntry($layoutElements, ['name' => 'With All Fields', 'handle' => 'withAllFields']);
+
+    $this->section = $seed->section;
+    $this->entryType = $seed->entryType;
+
+    $this->importer = EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null);
+
+    $this->entryData = fn (array $fieldValues) => array_merge([
+        'title' => 'imported entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $this->entryType->handle,
+        'matchCriteria' => ['title' => 'title'],
+    ], $fieldValues);
+});
+
+it('imports a plain text field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myPlainText' => 'hello world']));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myPlainText'))->toBe('hello world');
+});
+
+it('imports an email field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myEmail' => 'test@example.com']));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myEmail'))->toBe('test@example.com');
+});
+
+it('imports a number field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myNumber' => 42]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myNumber'))->toEqual(42);
+});
+
+it('imports a color field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myColor' => '#ff0000']));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect((string) $entry->getFieldValue('myColor'))->toBe('#ff0000');
+});
+
+it('imports a country field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myCountry' => 'US']));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myCountry')->getCountryCode())->toBe('US');
+});
+
+it('imports a lightswitch field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myLightswitch' => true]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myLightswitch'))->toBeTrue();
+});
+
+it('imports a range field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myRange' => 50]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myRange'))->toEqual(50);
+});
+
+it('imports a json field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myJson' => ['foo' => 'bar']]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myJson')['foo'])->toBe('bar');
+});
+
+it('imports a date field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myDate' => '2025-06-15 12:00:00']));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myDate')->format('Y-m-d'))->toBe('2025-06-15');
+});
+
+it('imports a time field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myTime' => '14:30']));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myTime')->format('H:i'))->toBe('14:30');
+});
+
+it('imports a money field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myMoney' => ['value' => '10.00', 'currency' => 'USD']]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myMoney')->getAmount())->toBe('1000');
+});
+
+it('imports an icon field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myIcon' => 'anchor']));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myIcon')->name)->toBe('anchor');
+});
+
+it('imports a link field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myLink' => 'https://craftcms.com']));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myLink')->getUrl())->toBe('https://craftcms.com');
+});
+
+it('imports a dropdown field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myDropdown' => 'optionB']));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect((string) $entry->getFieldValue('myDropdown'))->toBe('optionB');
+});
+
+it('imports a radio buttons field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myRadioButtons' => 'optionB']));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect((string) $entry->getFieldValue('myRadioButtons'))->toBe('optionB');
+});
+
+it('imports a button group field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myButtonGroup' => 'optionB']));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect((string) $entry->getFieldValue('myButtonGroup'))->toBe('optionB');
+});
+
+it('imports checkboxes field values', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myCheckboxes' => ['optionA', 'optionC']]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $value = $entry->getFieldValue('myCheckboxes');
+    expect($value->contains('optionA'))->toBeTrue()
+        ->and($value->contains('optionC'))->toBeTrue();
+});
+
+it('imports a multi-select field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myMultiSelect' => ['optionA', 'optionC']]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $value = $entry->getFieldValue('myMultiSelect');
+    expect($value->contains('optionA'))->toBeTrue()
+        ->and($value->contains('optionC'))->toBeTrue();
+});
+
+it('imports a table field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'myTable' => [['col1' => 'text value', 'col2' => 42]],
+    ]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $rows = $entry->getFieldValue('myTable');
+    expect($rows[0]['col1'])->toBe('text value')
+        ->and($rows[0]['col2'])->toEqual(42);
+});
diff --git a/tests/Feature/Import/ImportDestinationColumnsTest.php b/tests/Feature/Import/ImportDestinationColumnsTest.php
new file mode 100644
index 00000000000..c5f36558d18
--- /dev/null
+++ b/tests/Feature/Import/ImportDestinationColumnsTest.php
@@ -0,0 +1,182 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Entry\Models\EntryType;
+use CraftCms\Cms\Field\ContentBlock as ContentBlockField;
+use CraftCms\Cms\Field\Entries as EntriesField;
+use CraftCms\Cms\Field\Fields as FieldsService;
+use CraftCms\Cms\Field\Matrix;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\Field\PlainText;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\FieldLayout\Models\FieldLayout;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\ImportHelper;
+use CraftCms\Cms\Support\Str;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+it('marks non-container fields as not a container', function () {
+    $plainTextField = Field::factory()->create([
+        'name' => 'Plain Text',
+        'handle' => 'plainText',
+        'type' => PlainText::class,
+    ]);
+    Fields::refreshFields();
+
+    $fieldLayoutModel = FieldLayout::factory()
+        ->withContentTab([
+            CustomField::make($plainTextField->handle),
+        ])
+        ->create();
+
+    $fieldLayout = app(FieldsService::class)->getLayoutByUid($fieldLayoutModel->uid);
+    $cols = ImportHelper::getDestinationColsForFieldLayout($fieldLayout);
+    $col = collect($cols)->firstWhere('handle', 'plainText');
+
+    expect($col)->not()->toBeNull();
+    expect($col['isContainer'])->toBeFalse();
+    expect($col)->not()->toHaveKey('fieldUid');
+});
+
+it('marks ImportableElementContainerFieldInterface fields as containers with a fieldUid', function () {
+    $entryType = EntryType::factory()->create(['name' => 'Block', 'handle' => 'block']);
+
+    $matrixFieldModel = Field::factory()->create([
+        'name' => 'My Matrix',
+        'handle' => 'myMatrix',
+        'type' => Matrix::class,
+        'settings' => ['entryTypes' => [$entryType->id]],
+    ]);
+
+    EntryTypes::refreshEntryTypes();
+    Fields::refreshFields();
+
+    $fieldLayoutModel = FieldLayout::factory()
+        ->withContentTab([
+            CustomField::make($matrixFieldModel->handle),
+        ])
+        ->create();
+
+    $fieldLayout = app(FieldsService::class)->getLayoutByUid($fieldLayoutModel->uid);
+    $cols = ImportHelper::getDestinationColsForFieldLayout($fieldLayout);
+    $col = collect($cols)->firstWhere('handle', 'myMatrix');
+
+    expect($col)->not()->toBeNull();
+    expect($col['isContainer'])->toBeTrue();
+    expect($col['fieldUid'])->toBe($matrixFieldModel->uid);
+
+    // a container holds nested elements rather than a value of its own, so neither
+    // option applies to it — each of its nested columns carries its own decision
+    expect($col['canBeMatchCriteria'])->toBeFalse();
+    expect($col['canBeCleared'])->toBeFalse();
+});
+
+it('offers match criteria and clearing on an ordinary field', function () {
+    $plainTextField = Field::factory()->create([
+        'name' => 'Plain Text',
+        'handle' => 'plainText',
+        'type' => PlainText::class,
+    ]);
+    Fields::refreshFields();
+
+    $fieldLayoutModel = FieldLayout::factory()
+        ->withContentTab([
+            CustomField::make($plainTextField->handle),
+        ])
+        ->create();
+
+    $fieldLayout = app(FieldsService::class)->getLayoutByUid($fieldLayoutModel->uid);
+    $cols = ImportHelper::getDestinationColsForFieldLayout($fieldLayout);
+    $col = collect($cols)->firstWhere('handle', 'plainText');
+
+    expect($col['canBeMatchCriteria'])->toBeTrue();
+    expect($col['canBeCleared'])->toBeTrue();
+});
+
+// a relation field holds a value of its own (a list of ids), so unlike a container field it can be
+// both matched on and cleared
+it('offers match criteria and clearing on a relation field', function () {
+    $entriesField = Field::factory()->create([
+        'name' => 'My Entries',
+        'handle' => 'myEntries',
+        'type' => EntriesField::class,
+    ]);
+    Fields::refreshFields();
+
+    $fieldLayoutModel = FieldLayout::factory()
+        ->withContentTab([
+            CustomField::make($entriesField->handle),
+        ])
+        ->create();
+
+    $fieldLayout = app(FieldsService::class)->getLayoutByUid($fieldLayoutModel->uid);
+    $cols = ImportHelper::getDestinationColsForFieldLayout($fieldLayout);
+    $col = collect($cols)->firstWhere('handle', 'myEntries');
+
+    expect($col['isContainer'])->toBeFalse()
+        ->and($col['canBeCleared'])->toBeTrue();
+});
+
+it('uses map[attr] as the prefixedHandleForMap for top-level fields without an owner field', function () {
+    $plainTextField = Field::factory()->create([
+        'name' => 'Plain Text',
+        'handle' => 'plainText',
+        'type' => PlainText::class,
+    ]);
+    Fields::refreshFields();
+
+    $fieldLayoutModel = FieldLayout::factory()
+        ->withContentTab([
+            CustomField::make($plainTextField->handle),
+        ])
+        ->create();
+
+    $fieldLayout = app(FieldsService::class)->getLayoutByUid($fieldLayoutModel->uid);
+    $cols = ImportHelper::getDestinationColsForFieldLayout($fieldLayout);
+    $col = collect($cols)->firstWhere('handle', 'plainText');
+
+    expect($col['prefixedHandleForMap'])->toBe('map[plainText]');
+    expect($col['prefixedHandleForMatchCriteria'])->toBe('matchCriteria[plainText]');
+    expect($col['prefixedHandle'])->toBe('plainText');
+    expect($col['prefixedHandleAsArray'])->toBe(['plainText']);
+});
+
+// The importer derives its keepMissingNestedElements lookups from these same handles
+// (ElementImporter::collectAndEnableKeepFields()), so the shape is a contract between the two.
+// A content block is its own layout provider, so its handle must appear once, not twice.
+it('names the keep flag for a container field inside a content block without repeating the block handle', function () {
+    $blockTextField = ImportFixtures::plainTextField('blockText', 'Block Text');
+    $blockEntryType = ImportFixtures::blockEntryType('cbBlockEt', [$blockTextField], 'CB Block ET');
+    $cbMatrixField = ImportFixtures::matrixField('cbMatrix', [$blockEntryType], 'CB Matrix');
+    Fields::refreshFields();
+
+    Field::factory()->create([
+        'name' => 'My Content Block',
+        'handle' => 'myContentBlock',
+        'type' => ContentBlockField::class,
+        'settings' => ['fieldLayouts' => [Str::uuid()->toString() => ['tabs' => [[
+            'uid' => Str::uuid()->toString(),
+            'name' => 'Content',
+            'elements' => [[
+                'uid' => Str::uuid()->toString(),
+                'type' => CustomField::class,
+                'fieldUid' => $cbMatrixField->uid,
+                'required' => false,
+            ]],
+        ]]]]],
+    ]);
+    Fields::refreshFields();
+
+    $field = app(FieldsService::class)->getFieldByHandle('myContentBlock');
+
+    // as ImportController::nestedMappingCols() does for a container column
+    $provider = $field->getFieldLayoutProviders()[0];
+    $cols = ImportHelper::getDestinationColsForFieldLayout($provider->getFieldLayout(), $field, $provider, 'myContentBlock');
+    $col = collect($cols)->firstWhere('handle', 'cbMatrix');
+
+    expect($col['prefixedHandle'])->toBe('myContentBlock[fields][cbMatrix]')
+        ->and($col['prefixedHandleForKeepFlag'])->toBe('keepMissingNestedElements[myContentBlock][fields][cbMatrix][__keep__]')
+        ->and($col['prefixedHandleAsArray'])->toBe(['myContentBlock', 'fields', 'cbMatrix']);
+});
diff --git a/tests/Feature/Import/ImportEntryAttributesTest.php b/tests/Feature/Import/ImportEntryAttributesTest.php
new file mode 100644
index 00000000000..129065850ed
--- /dev/null
+++ b/tests/Feature/Import/ImportEntryAttributesTest.php
@@ -0,0 +1,199 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Section\Models\Section;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+use CraftCms\Cms\User\Models\User;
+
+use function Pest\Laravel\actingAs;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $plainTextField = ImportFixtures::plainTextField('plainText', 'Plain Text');
+    Fields::refreshFields();
+
+    $this->entryType = ImportFixtures::entryTypeWithTitle(
+        [CustomField::make($plainTextField->handle)],
+        ['name' => 'With Plain Text', 'handle' => 'withPlainText'],
+    );
+
+    // maxAuthors 3 so the multi-author row is valid; minAuthors 0 so rows may omit authors
+    $this->section = Section::factory()
+        ->withEntryTypes($this->entryType)
+        ->create(['minAuthors' => 0, 'maxAuthors' => 3]);
+
+    // the author default only kicks in when exactly one author is required
+    $this->sectionRequiringAnAuthor = Section::factory()
+        ->withEntryTypes($this->entryType)
+        ->create(['minAuthors' => 1, 'maxAuthors' => 3]);
+
+    EntryTypes::refreshEntryTypes();
+    Fields::refreshFields();
+
+    $this->importer = EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null)
+        ->matchCriteria(['title' => 'title']);
+
+    $this->entryData = fn (array $attributes = []) => array_merge([
+        'title' => 'imported entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $this->entryType->handle,
+        'matchCriteria' => ['title' => 'title'],
+    ], $attributes);
+
+    $this->importedEntry = fn () => EntryElement::find()->title('imported entry')->status(null)->one();
+});
+
+// slugs
+
+it('imports a supplied slug', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['slug' => 'a-supplied-slug']));
+
+    expect(($this->importedEntry)()->slug)->toBe('a-supplied-slug');
+});
+
+it('generates a slug from the title when none is supplied', function () {
+    $this->import->importItem($this->importer, ($this->entryData)());
+
+    expect(($this->importedEntry)()->slug)->toBe('imported-entry');
+});
+
+// post/expiry dates and the statuses they produce
+
+it('imports postDate and expiryDate', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'postDate' => '2023-05-07 13:14:15',
+        'expiryDate' => '2030-05-07 13:14:15',
+    ]));
+
+    $entry = ($this->importedEntry)();
+
+    // a date string without an offset is read in the app timezone and handed back in the system's
+    // display timezone, so compare in the timezone it came in as
+    $inAppTimeZone = fn ($date) => $date->copy()->setTimezone(config('app.timezone'))->format('Y-m-d H:i:s');
+
+    expect($inAppTimeZone($entry->postDate))->toBe('2023-05-07 13:14:15')
+        ->and($inAppTimeZone($entry->expiryDate))->toBe('2030-05-07 13:14:15');
+});
+
+it('leaves an entry live when its post date has passed and its expiry date has not', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'postDate' => now()->subDay()->format('Y-m-d H:i:s'),
+        'expiryDate' => now()->addYear()->format('Y-m-d H:i:s'),
+    ]));
+
+    expect(($this->importedEntry)()->getStatus())->toBe(EntryElement::STATUS_LIVE);
+});
+
+it('makes an entry pending when its post date is in the future', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'postDate' => now()->addYear()->format('Y-m-d H:i:s'),
+    ]));
+
+    expect(($this->importedEntry)()->getStatus())->toBe(EntryElement::STATUS_PENDING);
+});
+
+it('makes an entry expired when its expiry date has passed', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'postDate' => now()->subYear()->format('Y-m-d H:i:s'),
+        'expiryDate' => now()->subDay()->format('Y-m-d H:i:s'),
+    ]));
+
+    expect(($this->importedEntry)()->getStatus())->toBe(EntryElement::STATUS_EXPIRED);
+});
+
+it('imports an entry as disabled when enabled is false', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['enabled' => false]));
+
+    $entry = ($this->importedEntry)();
+
+    expect($entry->enabled)->toBeFalse()
+        ->and($entry->getStatus())->toBe(EntryElement::STATUS_DISABLED);
+});
+
+// authors
+
+it('imports multiple authorIds in the order given', function () {
+    // once a section sets maxAuthors, EntryRules checks each author's 'author' permission
+    $first = User::factory()->admin()->create();
+    $second = User::factory()->admin()->create();
+
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'authorIds' => [$second->id, $first->id],
+    ]));
+
+    expect(($this->importedEntry)()->getAuthorIds())->toBe([$second->id, $first->id]);
+});
+
+// Entry::maybeSetDefaultAttributes() defaults the author to the current user when the section
+// requires exactly one author, so this only works with somebody logged in.
+it('defaults the author to the logged-in user when authorIds is absent', function () {
+    $user = User::factory()->admin()->create();
+    actingAs($user);
+
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'sectionId' => $this->sectionRequiringAnAuthor->handle,
+    ]));
+
+    expect(($this->importedEntry)()->getAuthorIds())->toBe([$user->id]);
+});
+
+// the CLI case: no authenticated user, so there's nothing to default from and the entry fails the
+// section's author requirement
+it('skips an entry that omits authorIds in a section requiring an author when nobody is logged in', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'sectionId' => $this->sectionRequiringAnAuthor->handle,
+    ]));
+
+    expect(($this->importedEntry)())->toBeNull();
+});
+
+// section/type references
+
+it('resolves sectionId and typeId given as numeric IDs', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'sectionId' => $this->section->id,
+        'typeId' => $this->entryType->id,
+    ]));
+
+    $entry = ($this->importedEntry)();
+
+    expect($entry->sectionId)->toBe($this->section->id)
+        ->and($entry->getTypeId())->toBe($this->entryType->id);
+});
+
+// the manual fixtures send IDs as strings ("typeId": "1"), so both forms have to resolve
+it('resolves sectionId and typeId given as numeric strings', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'sectionId' => (string) $this->section->id,
+        'typeId' => (string) $this->entryType->id,
+    ]));
+
+    $entry = ($this->importedEntry)();
+
+    expect($entry->sectionId)->toBe($this->section->id)
+        ->and($entry->getTypeId())->toBe($this->entryType->id);
+});
+
+it('resolves sectionId and typeId given as handles', function () {
+    $this->import->importItem($this->importer, ($this->entryData)());
+
+    $entry = ($this->importedEntry)();
+
+    expect($entry->sectionId)->toBe($this->section->id)
+        ->and($entry->getTypeId())->toBe($this->entryType->id);
+});
+
+it('imports an entry under a parent in a structure section', function () {
+    // pending entry parent support - see the todo in ImportHelper::getImportableProperties()
+})->todo();
diff --git a/tests/Feature/Import/ImportEntryTest.php b/tests/Feature/Import/ImportEntryTest.php
new file mode 100644
index 00000000000..9d449d66202
--- /dev/null
+++ b/tests/Feature/Import/ImportEntryTest.php
@@ -0,0 +1,124 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\Field\PlainText;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Section\Models\Section;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+use CraftCms\Cms\User\Models\User;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    // these entry types get their own sections below, so ImportFixtures::seedEntry() (which always
+    // creates a section and a seed entry) isn't a fit — only the entry type part is shared
+    $this->typeA = ImportFixtures::entryTypeWithTitle(attrs: ['name' => 'Type A', 'handle' => 'typeA']);
+    $this->typeB = ImportFixtures::entryTypeWithTitle(attrs: ['name' => 'Type B', 'handle' => 'typeB']);
+
+    $this->section = Section::factory()->withEntryTypes($this->typeA, $this->typeB)->create(['minAuthors' => 0]);
+
+    $this->sectionWithAuthors = Section::factory()->withEntryTypes($this->typeA)->create();
+
+    $requiredTextField = Field::factory()->create(['name' => 'My Required Text', 'handle' => 'myRequiredText', 'type' => PlainText::class]);
+
+    Fields::refreshFields();
+
+    $this->typeC = ImportFixtures::entryTypeWithTitle(
+        [CustomField::make($requiredTextField->handle)->required()],
+        ['name' => 'With Required Text', 'handle' => 'withRequiredText'],
+    );
+
+    $this->importer = EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null);
+});
+
+it('uses the entry type selected via the field layout provider, ignoring a typeId in the incoming data', function () {
+    // typeId passed as an already-resolved int, to avoid the separate bug documented below.
+    $importerWithUid = clone ($this->importer, [
+        'uid' => 'i-have-a-uid',
+    ]);
+    $importerWithUid->section($this->section->uid)
+        ->entryType($this->typeA->uid);
+    $this->import->importItem($importerWithUid, [
+        'title' => 'imported entry',
+    ]);
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry)->not->toBeNull()
+        ->and($entry->getTypeId())->toBe($this->typeA->id);
+});
+
+dataset('requiredValueScenarios', [
+    'section requires an author' => [[
+        'section' => fn ($test) => $test->sectionWithAuthors,
+        'entryType' => fn ($test) => $test->typeA,
+        'importer' => fn ($test) => $test->importer,
+        'mappedData' => function ($test) {
+            $test->requiredValueAuthor = User::factory()->create();
+
+            return ['authorIds' => [$test->requiredValueAuthor->id]];
+        },
+        'assertMapped' => fn ($test, EntryElement $entry) => expect($entry->getAuthorIds())->toBe([$test->requiredValueAuthor->id]),
+    ]],
+    'entry type has a required Plain Text field' => [[
+        'section' => fn ($test) => Section::factory()->withEntryTypes($test->typeC)->create(['minAuthors' => 0]),
+        'entryType' => fn ($test) => $test->typeC,
+        'importer' => fn ($test) => $test->importer,
+        'mappedData' => fn ($test) => ['myRequiredText' => 'some value'],
+        'assertMapped' => fn ($test, EntryElement $entry) => expect($entry->getFieldValue('myRequiredText'))->toBe('some value'),
+    ]],
+]);
+
+describe('required-value validation, skipping enabled entries and allowing disabled ones', function () {
+    it('fails and skips an entry imported enabled without the required value mapped', function (array $scenario) {
+        $importer = ($scenario['importer'])($this);
+        $importer->section(($scenario['section'])($this)->uid)->entryType(($scenario['entryType'])($this)->uid);
+
+        $this->import->importItem($importer, [
+            'title' => 'imported entry',
+        ]);
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+
+        expect($entry)->toBeNull();
+    })->with('requiredValueScenarios');
+
+    it('succeeds importing a disabled entry without the required value mapped', function (array $scenario) {
+        $importer = ($scenario['importer'])($this);
+        $section = ($scenario['section'])($this);
+        $importer->section($section->uid)->entryType(($scenario['entryType'])($this)->uid);
+
+        $this->import->importItem($importer, [
+            'title' => 'imported entry',
+            'enabled' => false,
+        ]);
+
+        $entry = EntryElement::find()->title('imported entry')->section($section->handle)->status(null)->one();
+
+        expect($entry)->not->toBeNull();
+    })->with('requiredValueScenarios');
+
+    it('succeeds importing an enabled entry with the required value mapped', function (array $scenario) {
+        $importer = ($scenario['importer'])($this);
+        $importer->section(($scenario['section'])($this)->uid)->entryType(($scenario['entryType'])($this)->uid);
+
+        $this->import->importItem($importer, [
+            'title' => 'imported entry',
+            ...($scenario['mappedData'])($this),
+        ]);
+
+        $entry = EntryElement::find()->title('imported entry')->status(null)->one();
+
+        expect($entry)->not->toBeNull();
+        ($scenario['assertMapped'])($this, $entry);
+    })->with('requiredValueScenarios');
+});
diff --git a/tests/Feature/Import/ImportFieldInstancesTest.php b/tests/Feature/Import/ImportFieldInstancesTest.php
new file mode 100644
index 00000000000..a1c38357af0
--- /dev/null
+++ b/tests/Feature/Import/ImportFieldInstancesTest.php
@@ -0,0 +1,130 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Section\Models\Section;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $plainTextField = ImportFixtures::plainTextField('plainText', 'Plain Text');
+    $unusedField = ImportFixtures::plainTextField('notInThisLayout', 'Not In This Layout');
+    $blockEntryType = ImportFixtures::blockEntryType('blockEt', [$plainTextField], 'Block ET');
+    $matrixField = ImportFixtures::matrixField('notInThisLayoutEither', [$blockEntryType], 'Not In This Layout Either');
+
+    // two instances of the same field in one layout, the second one re-handled - the shape the
+    // manual fixtures use for plainText/plainText2
+    $this->twoInstancesType = ImportFixtures::entryTypeWithTitle(
+        [
+            CustomField::make($plainTextField->handle),
+            CustomField::make($plainTextField->handle)->handle('plainText2')->label('Plain Text 2'),
+        ],
+        ['name' => 'Two Instances', 'handle' => 'twoInstances'],
+    );
+
+    // the same two instances in the opposite layout order
+    $this->reversedInstancesType = ImportFixtures::entryTypeWithTitle(
+        [
+            CustomField::make($plainTextField->handle)->handle('plainText2')->label('Plain Text 2'),
+            CustomField::make($plainTextField->handle),
+        ],
+        ['name' => 'Reversed Instances', 'handle' => 'reversedInstances'],
+    );
+
+    $this->section = Section::factory()
+        ->withEntryTypes($this->twoInstancesType, $this->reversedInstancesType)
+        ->create(['minAuthors' => 0]);
+
+    EntryTypes::refreshEntryTypes();
+    Fields::refreshFields();
+
+    $this->unusedFieldHandle = $unusedField->handle;
+    $this->unusedMatrixHandle = $matrixField->handle;
+
+    $this->importer = EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null)
+        ->matchCriteria(['title' => 'title']);
+
+    $this->entryData = fn (string $typeHandle, array $values = []) => array_merge([
+        'title' => 'imported entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $typeHandle,
+        'matchCriteria' => ['title' => 'title'],
+    ], $values);
+
+    $this->importedEntry = fn () => EntryElement::find()->title('imported entry')->status(null)->one();
+});
+
+it('imports both instances of the same field in one layout', function () {
+    $this->import->importItem($this->importer, ($this->entryData)('twoInstances', [
+        'plainText' => 'first instance',
+        'plainText2' => 'second instance',
+    ]));
+
+    $entry = ($this->importedEntry)();
+
+    expect($entry->getFieldValue('plainText'))->toBe('first instance')
+        ->and($entry->getFieldValue('plainText2'))->toBe('second instance');
+});
+
+it('imports both instances when their layout order is reversed', function () {
+    $this->import->importItem($this->importer, ($this->entryData)('reversedInstances', [
+        'plainText' => 'first instance',
+        'plainText2' => 'second instance',
+    ]));
+
+    $entry = ($this->importedEntry)();
+
+    expect($entry->getFieldValue('plainText'))->toBe('first instance')
+        ->and($entry->getFieldValue('plainText2'))->toBe('second instance');
+});
+
+it('imports one instance without touching the other', function () {
+    $this->import->importItem($this->importer, ($this->entryData)('twoInstances', [
+        'plainText2' => 'only the second instance',
+    ]));
+
+    $entry = ($this->importedEntry)();
+
+    expect($entry->getFieldValue('plainText2'))->toBe('only the second instance')
+        ->and($entry->getFieldValue('plainText'))->toBeNull();
+});
+
+// the manual fixtures rely on this: rows carry a plainText value for entry types whose layout has
+// no plain text field at all ("this value should be ignored")
+it('ignores a value for a field that is not in the entry type’s layout', function () {
+    $this->import->importItem($this->importer, ($this->entryData)('twoInstances', [
+        'plainText' => 'kept',
+        $this->unusedFieldHandle => 'dropped',
+    ]));
+
+    $entry = ($this->importedEntry)();
+
+    expect($entry)->not->toBeNull()
+        ->and($entry->getFieldValue('plainText'))->toBe('kept')
+        ->and($entry->getFieldLayout()->getFieldByHandle($this->unusedFieldHandle))->toBeNull();
+});
+
+it('ignores a container field’s value when the field is not in the layout, creating no nested elements', function () {
+    $this->import->importItem($this->importer, ($this->entryData)('twoInstances', [
+        'plainText' => 'kept',
+        $this->unusedMatrixHandle => [
+            ['type' => 'blockEt', 'title' => 'block 1', 'fields' => ['plainText' => 'nested']],
+        ],
+    ]));
+
+    $entry = ($this->importedEntry)();
+
+    expect($entry)->not->toBeNull()
+        ->and($entry->getFieldValue('plainText'))->toBe('kept')
+        ->and(EntryElement::find()->title('block 1')->status(null)->count())->toBe(0);
+});
diff --git a/tests/Feature/Import/ImportFromFileTest.php b/tests/Feature/Import/ImportFromFileTest.php
new file mode 100644
index 00000000000..1b6b11b708f
--- /dev/null
+++ b/tests/Feature/Import/ImportFromFileTest.php
@@ -0,0 +1,196 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Aliases\Aliases;
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Section\Models\Section;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    // BaseImporter::resolvedFilePath() resolves everything against @root, which points at the
+    // Testbench skeleton during tests - point it at the package so the fixtures are reachable
+    $this->originalRoot = Aliases::get('@root');
+    Aliases::set('@root', dirname(__DIR__, 3));
+
+    $plainTextField = ImportFixtures::plainTextField('plainText', 'Plain Text');
+    $blockEntryType = ImportFixtures::blockEntryType('blockEt', [$plainTextField], 'Block ET');
+    $nestedMatrixField = ImportFixtures::matrixField('myNestedMatrix', [$blockEntryType], 'My Nested Matrix');
+    $outerEntryType = ImportFixtures::entryTypeWithTitle(
+        [CustomField::make($nestedMatrixField->handle)],
+        ['name' => 'Outer ET', 'handle' => 'outerEt'],
+    );
+    $matrixField = ImportFixtures::matrixField('myMatrix', [$blockEntryType, $outerEntryType], 'My Matrix');
+
+    // the fixture files reference these handles, so they have to be pinned rather than generated
+    $this->entryType = ImportFixtures::entryTypeWithTitle(
+        [CustomField::make($plainTextField->handle), CustomField::make($matrixField->handle)],
+        ['name' => 'Fixture Type', 'handle' => 'fixtureType'],
+    );
+    $this->section = Section::factory()
+        ->withEntryTypes($this->entryType)
+        ->create(['handle' => 'fixtureSection', 'minAuthors' => 0]);
+
+    // the entry types above were created after the last refresh inside matrixField(), so the
+    // caches have to be primed again before the Import can resolve them by handle
+    EntryTypes::refreshEntryTypes();
+    Fields::refreshFields();
+
+    $this->fixturePath = fn (string $name) => dirname(__DIR__, 2).'/Fixtures/Import/'.$name;
+
+    $this->importerFor = fn (string $name) => EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null)
+        ->file('tests/Fixtures/Import/'.$name)
+        ->section($this->section->handle)
+        ->entryType($this->entryType->handle);
+});
+
+afterEach(function () {
+    Aliases::set('@root', $this->originalRoot);
+});
+
+it('creates duplicates on re-import when no match criteria is configured', function () {
+    $importer = ($this->importerFor)('entries-plain-text.json');
+
+    $this->import->import($importer);
+    $this->import->import($importer);
+
+    expect(EntryElement::find()->section($this->section->handle)->count())->toBe(6);
+});
+
+// reading and formatting
+
+it('reads and formats a JSON file into rows', function () {
+    $data = $this->import->getFormattedData(($this->fixturePath)('entries-plain-text.json'));
+
+    expect($data)->toHaveCount(3)
+        ->and($data[0]['title'])->toBe('first file entry')
+        ->and($data[0]['plainText'])->toBe('text from the file')
+        ->and($data[1]['slug'])->toBe('second-file-entry-slug');
+});
+
+it('reads and formats a CSV file into rows keyed by the heading row', function () {
+    $data = $this->import->getFormattedData(($this->fixturePath)('entries.csv'));
+
+    expect($data)->toHaveCount(2)
+        ->and($data[0])->toBe([
+            'sectionId' => 'fixtureSection',
+            'typeId' => 'fixtureType',
+            'title' => 'first csv entry',
+            'plainText' => 'csv text one',
+        ]);
+});
+
+it('reads and formats an XML file into rows, unwrapping the root element', function () {
+    $data = $this->import->getFormattedData(($this->fixturePath)('entries.xml'));
+
+    expect($data)->toHaveCount(2)
+        ->and($data[0]['title'])->toBe('first xml entry')
+        ->and($data[1]['plainText'])->toBe('xml text two');
+});
+
+it('throws when the file cannot be read', function () {
+    expect(fn () => $this->import->getRawData(($this->fixturePath)('does-not-exist.json')))
+        ->toThrow(Exception::class);
+});
+
+it('throws for an empty file', function () {
+    expect(fn () => $this->import->getFormattedData(($this->fixturePath)('empty.json')))
+        ->toThrow(Exception::class, 'Unable to parse data.');
+});
+
+it('throws the data type’s own error for malformed JSON', function () {
+    expect(fn () => $this->import->getFormattedData(($this->fixturePath)('broken.json')))
+        ->toThrow(Exception::class);
+});
+
+it('reports an unsupported file extension as an unsupported data type', function () {
+    expect(fn () => $this->import->getFormattedData(($this->fixturePath)('unsupported.txt')))
+        ->toThrow(Exception::class, 'Unsupported data type: txt');
+});
+
+it('reports an unsupported file extension when reading headings too', function () {
+    expect(fn () => $this->import->getDataHeadings(($this->fixturePath)('unsupported.txt')))
+        ->toThrow(Exception::class, 'Unsupported data type: txt');
+});
+
+// A data file is expected to hold a list of rows; Import::Import() foreaches whatever comes back,
+// so a single top-level object hands importItem() each of its values instead of one row.
+it('fails with a type error when a JSON file holds a single object instead of a list of rows', function () {
+    expect(fn () => $this->import->import(($this->importerFor)('single-object.json')))
+        ->toThrow(TypeError::class);
+});
+
+it('returns the source headings with a "Please select" option prepended', function () {
+    $headings = $this->import->getDataHeadings(($this->fixturePath)('entries-plain-text.json'));
+
+    expect($headings[0])->toBe(['label' => 'Please select', 'value' => ''])
+        ->and(array_column($headings, 'value'))->toContain('title', 'plainText', 'slug');
+});
+
+// importing whole files
+
+it('imports every row of a JSON file', function () {
+    $this->import->import(($this->importerFor)('entries-plain-text.json')->matchCriteria(['title' => 'title']));
+
+    expect(EntryElement::find()->section($this->section->handle)->count())->toBe(3)
+        ->and(EntryElement::find()->title('first file entry')->one()->getFieldValue('plainText'))->toBe('text from the file')
+        ->and(EntryElement::find()->title('second file entry')->one()->slug)->toBe('second-file-entry-slug');
+});
+
+it('imports a file’s nested matrix blocks', function () {
+    $this->import->import(($this->importerFor)('entries-matrix.json'));
+
+    $entry = EntryElement::find()->title('file entry with matrix')->one();
+    $blocks = $entry->getFieldValue('myMatrix')->all();
+
+    expect($blocks)->toHaveCount(2)
+        ->and(array_map(fn ($block) => $block->title, $blocks))->toBe(['file block 1', 'file block 2'])
+        ->and($blocks[0]->getFieldValue('plainText'))->toBe('block one');
+});
+
+it('imports a file’s matrix-in-matrix blocks', function () {
+    $this->import->import(($this->importerFor)('entries-matrix-in-matrix.json'));
+
+    $entry = EntryElement::find()->title('file entry with matrix in matrix')->one();
+    $outerBlock = $entry->getFieldValue('myMatrix')->one();
+    $innerBlocks = $outerBlock->getFieldValue('myNestedMatrix')->all();
+
+    expect($outerBlock->title)->toBe('file outer block')
+        ->and($innerBlocks)->toHaveCount(2)
+        ->and(array_map(fn ($block) => $block->getFieldValue('plainText'), $innerBlocks))->toBe(['inner one', 'inner two']);
+});
+
+// Import::Import() resolves the importer's own matchCriteria before handing each row to
+// importItem() - the wiring that importItem()-level tests can't cover.
+it('matches rows and nested blocks on re-import using the importer config’s match criteria alone', function () {
+    $importer = ($this->importerFor)('entries-matrix.json')->matchCriteria([
+        'title' => 'title',
+        'myMatrix' => [
+            'blockEt' => ['title' => 'title'],
+        ],
+    ]);
+
+    $this->import->import($importer);
+
+    $entry = EntryElement::find()->title('file entry with matrix')->one();
+    $entryId = $entry->id;
+    $blockIds = $entry->getFieldValue('myMatrix')->ids();
+
+    $this->import->import($importer);
+
+    $entry = EntryElement::find()->title('file entry with matrix')->one();
+
+    expect(EntryElement::find()->section($this->section->handle)->count())->toBe(1)
+        ->and($entry->id)->toBe($entryId)
+        ->and($entry->getFieldValue('myMatrix')->ids())->toBe($blockIds);
+});
diff --git a/tests/Feature/Import/ImportKeepMissingNestedElementsTest.php b/tests/Feature/Import/ImportKeepMissingNestedElementsTest.php
new file mode 100644
index 00000000000..6d65d645f12
--- /dev/null
+++ b/tests/Feature/Import/ImportKeepMissingNestedElementsTest.php
@@ -0,0 +1,472 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Address\Elements\Address;
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Field\Addresses as AddressesField;
+use CraftCms\Cms\Field\ContentBlock as ContentBlockField;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\ImportLog;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Support\Str;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+describe('nested matrix pruning', function () {
+    beforeEach(function () {
+        $this->import = app(Import::class);
+
+        $plainTextField = ImportFixtures::plainTextField('plainText', 'Plain Text');
+        $blockEntryType = ImportFixtures::blockEntryType('blockEt', [$plainTextField], 'Block ET');
+        $matrixField = ImportFixtures::matrixField('myMatrix', [$blockEntryType], 'My Matrix');
+
+        $seed = ImportFixtures::seedEntry(
+            [CustomField::make($matrixField->handle)],
+            ['name' => 'With Matrix', 'handle' => 'withMatrix'],
+            entryAttrs: ['title' => 'matrix entry', 'slug' => 'matrix-entry'],
+        );
+
+        $this->matrixSection = $seed->section;
+        $this->matrixEntryType = $seed->entryType;
+
+        $this->matrixImporter = EntryImporter::create()
+            ->site(Sites::getPrimarySite()->handle)
+            ->transformer(null);
+
+        $this->matrixEntryData = fn (array $blocks) => [
+            'title' => 'matrix entry',
+            'sectionId' => $this->matrixSection->handle,
+            'typeId' => $this->matrixEntryType->handle,
+            'matchCriteria' => ['title' => 'title'],
+            'myMatrix' => $blocks,
+        ];
+
+        // seed two blocks
+        $this->import->importItem($this->matrixImporter, ($this->matrixEntryData)([
+            [
+                'type' => 'blockEt',
+                'title' => 'block 1',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => ['plainText' => 'one'],
+            ],
+            [
+                'type' => 'blockEt',
+                'title' => 'block 2',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => ['plainText' => 'two'],
+            ],
+        ]));
+
+        $entry = EntryElement::find()->title('matrix entry')->one();
+        $this->seededBlockIds = $entry->getFieldValue('myMatrix')->ids();
+
+        expect($this->seededBlockIds)->toHaveCount(2);
+    });
+
+    it('deletes an existing block missing from a later import by default', function () {
+        $this->import->importItem($this->matrixImporter, ($this->matrixEntryData)([
+            [
+                'type' => 'blockEt',
+                'title' => 'block 1',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => ['plainText' => 'one'],
+            ],
+        ]));
+
+        $entry = EntryElement::find()->title('matrix entry')->one();
+        $blocks = $entry->getFieldValue('myMatrix')->all();
+        expect($blocks)->toHaveCount(1);
+        expect($blocks[0]->title)->toBe('block 1');
+        // the surviving block is matched and updated in place, not recreated
+        expect($blocks[0]->id)->toBe($this->seededBlockIds[0]);
+    });
+
+    it('logs pruned nested elements via ImportLog when pruning happens', function () {
+        ImportLog::shouldReceive('info')
+            ->once()
+            ->withArgs(fn (string $message, array $context) => ! empty($context['prunedElementIds']) && count($context['prunedElementIds']) === 1);
+
+        $this->import->importItem($this->matrixImporter, ($this->matrixEntryData)([
+            [
+                'type' => 'blockEt',
+                'title' => 'block 1',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => ['plainText' => 'one'],
+            ],
+        ]));
+    });
+
+    it('keeps an existing block missing from a later import when the field opts in to keeping missing elements', function () {
+        $importer = (clone $this->matrixImporter)->keepMissingNestedElements(['myMatrix' => ['__keep__' => true]]);
+
+        $this->import->importItem($importer, ($this->matrixEntryData)([
+            [
+                'type' => 'blockEt',
+                'title' => 'block 1',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => ['plainText' => 'one'],
+            ],
+        ]));
+
+        $entry = EntryElement::find()->title('matrix entry')->one();
+        $blocks = $entry->getFieldValue('myMatrix')->all();
+        expect($blocks)->toHaveCount(2);
+    });
+
+    it('does not log anything when the field opts in to keeping missing elements', function () {
+        ImportLog::shouldReceive('info')->never();
+
+        $importer = (clone $this->matrixImporter)->keepMissingNestedElements(['myMatrix' => ['__keep__' => true]]);
+
+        $this->import->importItem($importer, ($this->matrixEntryData)([
+            [
+                'type' => 'blockEt',
+                'title' => 'block 1',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => ['plainText' => 'one'],
+            ],
+        ]));
+    });
+});
+
+describe('matrix in matrix pruning', function () {
+    beforeEach(function () {
+        $this->import = app(Import::class);
+
+        $innerPlainTextField = ImportFixtures::plainTextField('innerPlainText', 'Inner Plain Text');
+        $innerEntryType = ImportFixtures::blockEntryType('innerEt', [$innerPlainTextField], 'Inner ET');
+        $innerMatrixField = ImportFixtures::matrixField('innerMatrix', [$innerEntryType], 'Inner Matrix');
+
+        $outerPlainTextField = ImportFixtures::plainTextField('outerPlainText', 'Outer Plain Text');
+        $outerEntryType = ImportFixtures::blockEntryType('outerEt', [$outerPlainTextField, $innerMatrixField], 'Outer ET');
+        $outerMatrixField = ImportFixtures::matrixField('outerMatrix', [$outerEntryType], 'Outer Matrix');
+
+        $seed = ImportFixtures::seedEntry(
+            [CustomField::make($outerMatrixField->handle)],
+            ['name' => 'With Outer Matrix', 'handle' => 'withOuterMatrix'],
+            entryAttrs: ['title' => 'matrix in matrix entry', 'slug' => 'matrix-in-matrix-entry'],
+        );
+
+        $this->matrixInMatrixSection = $seed->section;
+        $this->matrixInMatrixEntryType = $seed->entryType;
+
+        $this->matrixInMatrixImporter = EntryImporter::create()
+            ->site(Sites::getPrimarySite()->handle)
+            ->transformer(null);
+
+        $this->matrixInMatrixEntryData = fn (array $outerBlocks) => [
+            'title' => 'matrix in matrix entry',
+            'sectionId' => $this->matrixInMatrixSection->handle,
+            'typeId' => $this->matrixInMatrixEntryType->handle,
+            'matchCriteria' => ['title' => 'title'],
+            'outerMatrix' => $outerBlocks,
+        ];
+
+        // seed two outer blocks, each with one inner block
+        $this->import->importItem($this->matrixInMatrixImporter, ($this->matrixInMatrixEntryData)([
+            [
+                'type' => 'outerEt',
+                'title' => 'outer 1',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => [
+                    'outerPlainText' => 'outer one',
+                    'innerMatrix' => [
+                        [
+                            'type' => 'innerEt',
+                            'title' => 'inner 1',
+                            'matchCriteria' => ['title' => 'title'],
+                            'fields' => ['innerPlainText' => 'inner one'],
+                        ],
+                    ],
+                ],
+            ],
+            [
+                'type' => 'outerEt',
+                'title' => 'outer 2',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => [
+                    'outerPlainText' => 'outer two',
+                    'innerMatrix' => [
+                        [
+                            'type' => 'innerEt',
+                            'title' => 'inner 2',
+                            'matchCriteria' => ['title' => 'title'],
+                            'fields' => ['innerPlainText' => 'inner two'],
+                        ],
+                    ],
+                ],
+            ],
+        ]));
+
+        $entry = EntryElement::find()->title('matrix in matrix entry')->one();
+        expect($entry->getFieldValue('outerMatrix')->count())->toBe(2);
+    });
+
+    it('keeps an outer block missing from a later import when only the outer field opts in, while still pruning the remaining block’s missing inner block', function () {
+        $importer = (clone $this->matrixInMatrixImporter)
+            ->keepMissingNestedElements(['outerMatrix' => ['__keep__' => true]]);
+
+        // omit "outer 2" entirely, and omit "outer 1"'s inner block
+        $this->import->importItem($importer, ($this->matrixInMatrixEntryData)([
+            [
+                'type' => 'outerEt',
+                'title' => 'outer 1',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => [
+                    'outerPlainText' => 'outer one',
+                    'innerMatrix' => [],
+                ],
+            ],
+        ]));
+
+        $entry = EntryElement::find()->title('matrix in matrix entry')->one();
+        $outerBlocks = $entry->getFieldValue('outerMatrix')->all();
+        expect($outerBlocks)->toHaveCount(2);
+
+        $outerOne = collect($outerBlocks)->firstWhere('title', 'outer 1');
+        expect($outerOne->getFieldValue('innerMatrix')->count())->toBe(0);
+    });
+
+    it('prunes an outer block missing from a later import when only the inner field opts in, while keeping the remaining block’s missing inner block', function () {
+        $importer = (clone $this->matrixInMatrixImporter)
+            ->keepMissingNestedElements([
+                'outerMatrix' => [
+                    'outerEt' => [
+                        'fields' => [
+                            'innerMatrix' => ['__keep__' => true],
+                        ],
+                    ],
+                ],
+            ]);
+
+        // omit "outer 2" entirely, and omit "outer 1"'s inner block
+        $this->import->importItem($importer, ($this->matrixInMatrixEntryData)([
+            [
+                'type' => 'outerEt',
+                'title' => 'outer 1',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => [
+                    'outerPlainText' => 'outer one',
+                    'innerMatrix' => [],
+                ],
+            ],
+        ]));
+
+        $entry = EntryElement::find()->title('matrix in matrix entry')->one();
+        $outerBlocks = $entry->getFieldValue('outerMatrix')->all();
+        expect($outerBlocks)->toHaveCount(1);
+
+        $outerOne = $outerBlocks[0];
+        expect($outerOne->title)->toBe('outer 1');
+        expect($outerOne->getFieldValue('innerMatrix')->count())->toBe(1);
+    });
+});
+
+// Addresses::canKeepMissingNestedElements() is true (asserted in the unit test), but only matrix
+// fields exercised it until now.
+describe('addresses pruning', function () {
+    beforeEach(function () {
+        $this->import = app(Import::class);
+
+        $addressesField = Field::factory()->create([
+            'name' => 'My Addresses',
+            'handle' => 'myAddresses',
+            'type' => AddressesField::class,
+        ]);
+
+        Fields::refreshFields();
+
+        $seed = ImportFixtures::seedEntry(
+            [CustomField::make($addressesField->handle)],
+            ['name' => 'With Addresses', 'handle' => 'withAddresses'],
+            entryAttrs: ['title' => 'addresses entry', 'slug' => 'addresses-entry'],
+        );
+
+        $this->section = $seed->section;
+        $this->entryType = $seed->entryType;
+
+        $this->importer = EntryImporter::create()
+            ->site(Sites::getPrimarySite()->handle)
+            ->matchCriteria(['title' => 'title'])
+            ->transformer(null);
+
+        $this->address = fn (string $title, string $line1) => [
+            'title' => $title,
+            'matchCriteria' => ['title' => 'title'],
+            'countryCode' => 'US',
+            'addressLine1' => $line1,
+            'locality' => 'My Town',
+            'administrativeArea' => 'UT',
+            'postalCode' => '12345',
+        ];
+
+        $this->entryData = fn (array $addresses) => [
+            'title' => 'addresses entry',
+            'sectionId' => $this->section->handle,
+            'typeId' => $this->entryType->handle,
+            'matchCriteria' => ['title' => 'title'],
+            'myAddresses' => $addresses,
+        ];
+
+        // seed two addresses
+        $this->import->importItem($this->importer, ($this->entryData)([
+            ($this->address)('address 1', '1 First St'),
+            ($this->address)('address 2', '2 Second St'),
+        ]));
+
+        $seeded = Address::find()
+            ->ownerId(EntryElement::find()->title('addresses entry')->one()->id)
+            ->all();
+
+        // ids() order isn't tied to the order the addresses were imported in, so index them by label
+        $this->seededAddressIds = array_map(fn (Address $address) => $address->id, $seeded);
+        $this->seededAddressIdByTitle = array_column(
+            array_map(fn (Address $address) => ['title' => $address->title, 'id' => $address->id], $seeded),
+            'id',
+            'title',
+        );
+
+        expect($this->seededAddressIds)->toHaveCount(2);
+    });
+
+    it('deletes an existing address missing from a later import by default', function () {
+        $this->import->importItem($this->importer, ($this->entryData)([
+            ($this->address)('address 1', '1 First St'),
+        ]));
+
+        $entry = EntryElement::find()->title('addresses entry')->one();
+        $addresses = Address::find()->ownerId($entry->id)->all();
+
+        expect($addresses)->toHaveCount(1)
+            ->and($addresses[0]->title)->toBe('address 1');
+    });
+
+    it('matches the supplied address rather than recreating it while pruning the missing one', function () {
+        $this->import->importItem($this->importer, ($this->entryData)([
+            ($this->address)('address 1', '1 First St'),
+        ]));
+
+        $entry = EntryElement::find()->title('addresses entry')->one();
+
+        expect(Address::find()->ownerId($entry->id)->ids())->toBe([$this->seededAddressIdByTitle['address 1']]);
+    });
+
+    it('keeps an existing address missing from a later import when the field opts in to keeping missing elements', function () {
+        $importer = (clone $this->importer)->keepMissingNestedElements(['myAddresses' => ['__keep__' => true]]);
+
+        $this->import->importItem($importer, ($this->entryData)([
+            ($this->address)('address 1', '1 First St'),
+        ]));
+
+        $entry = EntryElement::find()->title('addresses entry')->one();
+
+        expect(Address::find()->ownerId($entry->id)->ids())->toEqualCanonicalizing($this->seededAddressIds);
+    });
+});
+
+// A matrix nested inside a content block: the container that opts in to keeping missing elements is
+// the matrix, but it's reached through the content block, so the keepMissingNestedElements key has
+// to line up with the path ElementImporter::collectAndEnableKeepFields() walks.
+describe('matrix inside a content block pruning', function () {
+    beforeEach(function () {
+        $this->import = app(Import::class);
+
+        $blockTextField = ImportFixtures::plainTextField('blockText', 'Block Text');
+        $blockEntryType = ImportFixtures::blockEntryType('cbBlockEt', [$blockTextField], 'CB Block ET');
+        $cbMatrixField = ImportFixtures::matrixField('cbMatrix', [$blockEntryType], 'CB Matrix');
+
+        Fields::refreshFields();
+
+        $contentBlockField = Field::factory()->create([
+            'name' => 'My Content Block',
+            'handle' => 'myContentBlock',
+            'type' => ContentBlockField::class,
+            'settings' => [
+                'fieldLayouts' => [
+                    Str::uuid()->toString() => [
+                        'tabs' => [[
+                            'uid' => Str::uuid()->toString(),
+                            'name' => 'Content',
+                            'elements' => [[
+                                'uid' => Str::uuid()->toString(),
+                                'type' => CustomField::class,
+                                'fieldUid' => $cbMatrixField->uid,
+                                'required' => false,
+                            ]],
+                        ]],
+                    ],
+                ],
+            ],
+        ]);
+
+        Fields::refreshFields();
+
+        $seed = ImportFixtures::seedEntry(
+            [CustomField::make($contentBlockField->handle)],
+            ['name' => 'With Content Block', 'handle' => 'withContentBlock'],
+            entryAttrs: ['title' => 'cb entry', 'slug' => 'cb-entry'],
+        );
+
+        $this->section = $seed->section;
+        $this->entryType = $seed->entryType;
+
+        $this->importer = EntryImporter::create()
+            ->site(Sites::getPrimarySite()->handle)
+            ->matchCriteria(['title' => 'title'])
+            ->transformer(null);
+
+        $this->block = fn (string $title, string $text) => [
+            'type' => 'cbBlockEt',
+            'title' => $title,
+            'matchCriteria' => ['title' => 'title'],
+            'fields' => ['blockText' => $text],
+        ];
+
+        $this->entryData = fn (array $blocks) => [
+            'title' => 'cb entry',
+            'sectionId' => $this->section->handle,
+            'typeId' => $this->entryType->handle,
+            'matchCriteria' => ['title' => 'title'],
+            'myContentBlock' => ['fields' => ['cbMatrix' => $blocks]],
+        ];
+
+        // seed two blocks inside the content block's matrix
+        $this->import->importItem($this->importer, ($this->entryData)([
+            ($this->block)('block 1', 'one'),
+            ($this->block)('block 2', 'two'),
+        ]));
+
+        $this->nestedBlocks = fn () => EntryElement::find()->title('cb entry')->one()
+            ->getFieldValue('myContentBlock')->getFieldValue('cbMatrix');
+
+        $this->seededBlockIds = ($this->nestedBlocks)()->ids();
+
+        expect($this->seededBlockIds)->toHaveCount(2);
+    });
+
+    it('deletes a nested block missing from a later import by default', function () {
+        $this->import->importItem($this->importer, ($this->entryData)([
+            ($this->block)('block 1', 'one'),
+        ]));
+
+        expect(($this->nestedBlocks)()->ids())->toBe([$this->seededBlockIds[0]]);
+    });
+
+    // The mapping UI names this input keepMissingNestedElements[myContentBlock][fields][cbMatrix][__keep__],
+    // so that's the shape a saved config carries.
+    it('keeps a nested block missing from a later import when the nested matrix opts in', function () {
+        $importer = (clone $this->importer)->keepMissingNestedElements([
+            'myContentBlock' => ['fields' => ['cbMatrix' => ['__keep__' => true]]],
+        ]);
+
+        $this->import->importItem($importer, ($this->entryData)([
+            ($this->block)('block 1', 'one'),
+        ]));
+
+        expect(($this->nestedBlocks)()->ids())->toEqualCanonicalizing($this->seededBlockIds);
+    });
+});
diff --git a/tests/Feature/Import/ImportMapSuggestionTest.php b/tests/Feature/Import/ImportMapSuggestionTest.php
new file mode 100644
index 00000000000..0f655f68c77
--- /dev/null
+++ b/tests/Feature/Import/ImportMapSuggestionTest.php
@@ -0,0 +1,130 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Field\Fields as FieldsService;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\FieldLayout\Models\FieldLayout;
+use CraftCms\Cms\Support\ImportHelper;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+/**
+ * Builds matrixOuter > withMatrix > matrixInner > withPlainText, and collects its destination
+ * columns the way the mapping screen and ImportController::nestedMappingCols() do — one
+ * level per request, each nested level prefixed with its container's prefixedHandle.
+ */
+function nestedMatrixDestinationCols(): array
+{
+    $plainText = ImportFixtures::plainTextField('plainText', 'Plain Text');
+    $plainText2 = ImportFixtures::plainTextField('plainText2', 'Plain Text 2');
+
+    $withPlainText = ImportFixtures::entryTypeWithTitle([
+        new CustomField(config: ['fieldUid' => $plainText->uid]),
+        new CustomField(config: ['fieldUid' => $plainText2->uid]),
+    ], ['handle' => 'withPlainText', 'name' => 'With Plain Text']);
+
+    $matrixInner = ImportFixtures::matrixField('matrixInner', [$withPlainText], 'Matrix Inner');
+
+    $withMatrix = ImportFixtures::entryTypeWithTitle([
+        new CustomField(config: ['fieldUid' => $matrixInner->uid]),
+    ], ['handle' => 'withMatrix', 'name' => 'With Matrix']);
+
+    $matrixOuter = ImportFixtures::matrixField('matrixOuter', [$withMatrix], 'Matrix Outer');
+
+    $layoutModel = FieldLayout::factory()->withContentTab([
+        CustomField::make($plainText->handle),
+        CustomField::make($matrixOuter->handle),
+    ])->create();
+
+    $fieldsService = app(FieldsService::class);
+
+    $colsFor = function (string $handle, string $prefix) use ($fieldsService): array {
+        $field = $fieldsService->getFieldByHandle($handle);
+        $cols = [];
+
+        foreach ($field->getFieldLayoutProviders() as $provider) {
+            $cols = array_merge($cols, ImportHelper::getDestinationColsForFieldLayout(
+                $provider->getFieldLayout(),
+                $field,
+                $provider,
+                $prefix,
+            ));
+        }
+
+        return $cols;
+    };
+
+    $top = ImportHelper::getDestinationColsForFieldLayout($fieldsService->getLayoutByUid($layoutModel->uid));
+    $level1 = $colsFor('matrixOuter', 'matrixOuter');
+    $innerCol = collect($level1)->firstWhere('handle', 'matrixInner');
+    $level2 = $colsFor('matrixInner', $innerCol['prefixedHandle']);
+
+    return [...$top, ...$level1, ...$level2];
+}
+
+/** The column list a nested-matrix export produces: it carries `fields`, never an entry type. */
+function nestedMatrixSourceCols(): array
+{
+    return array_map(fn (string $value) => ['label' => $value, 'value' => $value], [
+        '',
+        'authorIds',
+        'matrixOuter',
+        'matrixOuter.fields',
+        'matrixOuter.fields.matrixInner',
+        'matrixOuter.fields.matrixInner.fields',
+        'matrixOuter.fields.matrixInner.fields.plainText',
+        'matrixOuter.fields.matrixInner.fields.plainText2',
+        'matrixOuter.fields.matrixInner.matchCriteria',
+        'matrixOuter.fields.matrixInner.matchCriteria.title',
+        'matrixOuter.fields.matrixInner.title',
+        'matrixOuter.fields.matrixInner.type',
+        'matrixOuter.matchCriteria',
+        'matrixOuter.matchCriteria.title',
+        'matrixOuter.title',
+        'matrixOuter.type',
+        'plainText',
+        'sectionId',
+        'title',
+        'typeId',
+    ]);
+}
+
+it('suggests a column for every level of a real nested matrix', function () {
+    $result = ImportHelper::suggestMapValues(nestedMatrixDestinationCols(), nestedMatrixSourceCols(), []);
+
+    expect($result)->toEqual([
+        'plainText' => 'plainText',
+        'matrixOuter' => [
+            'withMatrix' => [
+                'title' => 'matrixOuter.title',
+                'fields' => [
+                    'matrixInner' => [
+                        'withPlainText' => [
+                            'title' => 'matrixOuter.fields.matrixInner.title',
+                            'fields' => [
+                                'plainText' => 'matrixOuter.fields.matrixInner.fields.plainText',
+                                'plainText2' => 'matrixOuter.fields.matrixInner.fields.plainText2',
+                            ],
+                        ],
+                    ],
+                ],
+            ],
+        ],
+    ]);
+});
+
+it('suggests the same columns however their handles are spelled', function () {
+    $sourceCols = array_map(fn (string $value) => ['label' => $value, 'value' => $value], [
+        'matrixouter.fields.matrix-inner.fields.plain-text',
+        'MATRIXOUTER.fields.matrix inner.fields.Plain Text 2',
+    ]);
+
+    $result = ImportHelper::suggestMapValues(nestedMatrixDestinationCols(), $sourceCols, []);
+
+    $innerFields = $result['matrixOuter']['withMatrix']['fields']['matrixInner']['withPlainText']['fields'];
+
+    expect($innerFields)->toBe([
+        'plainText' => 'matrixouter.fields.matrix-inner.fields.plain-text',
+        'plainText2' => 'MATRIXOUTER.fields.matrix inner.fields.Plain Text 2',
+    ]);
+});
diff --git a/tests/Feature/Import/ImportMatrixFieldTest.php b/tests/Feature/Import/ImportMatrixFieldTest.php
new file mode 100644
index 00000000000..d7513fe7c79
--- /dev/null
+++ b/tests/Feature/Import/ImportMatrixFieldTest.php
@@ -0,0 +1,696 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Entry\Models\EntryType;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\FieldLayout\LayoutElements\Entries\EntryTitleField;
+use CraftCms\Cms\FieldLayout\Models\FieldLayout;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Support\ImportHelper;
+use CraftCms\Cms\Support\Str;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $plainTextField = ImportFixtures::plainTextField('plainText', 'Plain Text');
+
+    $firstEntryTypeForMatrix = ImportFixtures::blockEntryType('firstEt', [$plainTextField], 'First ET');
+    $secondEntryTypeForMatrix = ImportFixtures::blockEntryType('secondEt', [$plainTextField], 'Second ET');
+
+    $nestedMatrixField = ImportFixtures::matrixField('myNestedMatrix', [$firstEntryTypeForMatrix, $secondEntryTypeForMatrix], 'My Nested Matrix');
+
+    // thirdEt has its own title field element (unlike the other block types, which rely on hasTitleField alone).
+    $thirdEntryTypeForMatrix = EntryType::factory()
+        ->withFieldLayout(
+            FieldLayout::factory()
+                ->withContentTab([
+                    new EntryTitleField(['uid' => Str::uuid()->toString(), 'required' => true]),
+                    CustomField::make($plainTextField->handle),
+                    CustomField::make($nestedMatrixField->handle),
+                ])
+                ->create()
+        )
+        ->create([
+            'name' => 'Third ET',
+            'handle' => 'thirdEt',
+            'hasTitleField' => true,
+        ]);
+
+    $this->matrixField = ImportFixtures::matrixField('myMatrix', [$firstEntryTypeForMatrix, $secondEntryTypeForMatrix, $thirdEntryTypeForMatrix], 'My Matrix');
+
+    $seed = ImportFixtures::seedEntry(
+        [CustomField::make($this->matrixField->handle)],
+        ['name' => 'With Matrix Field', 'handle' => 'withMatrixField'],
+    );
+
+    $this->section = $seed->section;
+    $this->entryType = $seed->entryType;
+
+    $this->importer = EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null);
+
+    // An importer's own matchCriteria only reaches the pipeline when it's resolved and passed into
+    // importItem() - which is what Import::import(), the import job and craft:import:element all do.
+    // Calling importItem() without it means config-level criteria is silently ignored.
+    $this->importWithConfigCriteria = fn ($importer, array $data) => ImportFixtures::importWithConfigCriteria($this->import, $importer, $data);
+
+    $this->importerMatchingSecondEtBlocks = fn () => (clone $this->importer)->matchCriteria([
+        'title' => 'title',
+        'myMatrix' => [
+            'secondEt' => ['title' => 'title'],
+        ],
+    ]);
+
+    $this->entryData = fn (array $blocks) => [
+        'title' => 'imported entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $this->entryType->handle,
+        'myMatrix' => $blocks,
+        'matchCriteria' => ['title' => 'title'],
+    ];
+});
+
+it('imports an entry with a matrix field', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        [
+            'type' => 'secondEt',
+            'title' => 'block 1',
+            'fields' => ['plainText' => 'foo'],
+        ],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry)->not()->toBeNull();
+    expect($entry->getFieldValue('myMatrix')->count())->toBe(1);
+});
+
+it('imports multiple blocks of different entry types', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        ['type' => 'secondEt', 'title' => 'block 1', 'fields' => ['plainText' => 'foo']],
+        ['type' => 'firstEt', 'title' => 'block 2', 'fields' => ['plainText' => 'bar']],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $blocks = $entry->getFieldValue('myMatrix')->all();
+
+    // assert the types too, so this can't pass with both blocks coming out as the same type
+    expect($blocks)->toHaveCount(2)
+        ->and(array_map(fn ($block) => $block->title, $blocks))->toBe(['block 1', 'block 2'])
+        ->and(array_map(fn ($block) => $block->getType()->handle, $blocks))->toBe(['secondEt', 'firstEt']);
+});
+
+it('maps block field values and title correctly', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        ['type' => 'secondEt', 'title' => 'block 1', 'fields' => ['plainText' => 'foo']],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $block = $entry->getFieldValue('myMatrix')->one();
+
+    expect($block->title)->toBe('block 1');
+    expect($block->getFieldValue('plainText'))->toBe('foo');
+});
+
+it('updates an existing block when match criteria matches', function () {
+    $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+
+    $this->import->importItem($importer, ($this->entryData)([
+        [
+            'type' => 'secondEt',
+            'title' => 'block 1',
+            'matchCriteria' => ['title' => 'title'],
+            'fields' => ['plainText' => 'foo'],
+        ],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myMatrix')->count())->toBe(1);
+    $blockId = $entry->getFieldValue('myMatrix')->one()->id;
+
+    $this->import->importItem($importer, ($this->entryData)([
+        [
+            'type' => 'secondEt',
+            'title' => 'block 1',
+            'matchCriteria' => ['title' => 'title'],
+            'fields' => ['plainText' => 'updated foo'],
+        ],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $block = $entry->getFieldValue('myMatrix')->one();
+    expect($entry->getFieldValue('myMatrix')->count())->toBe(1);
+    // The importer's own matchCriteria config has no entry for the myMatrix container field at all,
+    // so this relies entirely on the block's inline matchCriteria being resolved. If it isn't, the
+    // block never actually matches and a new one gets created (with the old one discarded) instead
+    // of the same block being updated in place, which the id check below would catch.
+    expect($block->id)->toBe($blockId);
+    expect($block->getFieldValue('plainText'))->toBe('updated foo');
+});
+
+it('resolves match criteria for nested blocks from the importer config, without it being inlined in the data', function () {
+    $importer = ($this->importerMatchingSecondEtBlocks)();
+
+    ($this->importWithConfigCriteria)($importer, ($this->entryData)([
+        ['type' => 'secondEt', 'title' => 'block 1', 'fields' => ['plainText' => 'foo']],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myMatrix')->count())->toBe(1);
+    $blockId = $entry->getFieldValue('myMatrix')->one()->id;
+
+    ($this->importWithConfigCriteria)($importer, ($this->entryData)([
+        ['type' => 'secondEt', 'title' => 'block 1', 'fields' => ['plainText' => 'updated foo']],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $block = $entry->getFieldValue('myMatrix')->one();
+
+    // the id check is what separates matching from the block being recreated - without it this
+    // test passes even when the config criteria never reaches the pipeline at all
+    expect($entry->getFieldValue('myMatrix')->count())->toBe(1)
+        ->and($block->id)->toBe($blockId)
+        ->and($block->getFieldValue('plainText'))->toBe('updated foo');
+});
+
+it('adds a new block alongside a matched one when a second row is imported', function () {
+    $importer = ($this->importerMatchingSecondEtBlocks)();
+
+    ($this->importWithConfigCriteria)($importer, ($this->entryData)([
+        ['type' => 'secondEt', 'title' => 'block 1', 'fields' => ['plainText' => 'foo']],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $blockId = $entry->getFieldValue('myMatrix')->one()->id;
+
+    ($this->importWithConfigCriteria)($importer, ($this->entryData)([
+        ['type' => 'secondEt', 'title' => 'block 1', 'fields' => ['plainText' => 'foo']],
+        ['type' => 'secondEt', 'title' => 'block 2', 'fields' => ['plainText' => 'bar']],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $blocks = $entry->getFieldValue('myMatrix')->all();
+
+    expect($blocks)->toHaveCount(2)
+        ->and(array_map(fn ($block) => $block->title, $blocks))->toBe(['block 1', 'block 2'])
+        ->and($blocks[0]->id)->toBe($blockId);
+});
+
+it('resolves inline pointer-style match criteria against the block\'s own field value', function () {
+    $importer = (clone $this->importer)->matchCriteria([
+        'title' => 'title',
+        'myMatrix' => [
+            'secondEt' => [],
+        ],
+    ]);
+
+    $this->import->importItem($importer, ($this->entryData)([
+        [
+            'type' => 'secondEt',
+            'title' => 'block 1',
+            'matchCriteria' => ['plainText' => 'plainText'],
+            'fields' => ['plainText' => 'foo'],
+        ],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myMatrix')->count())->toBe(1);
+    $blockId = $entry->getFieldValue('myMatrix')->one()->id;
+
+    // The block's title changes but its plainText value (the inline match criteria) stays the
+    // same, so if the pointer resolved correctly this should update the existing block rather
+    // than create a new one.
+    $this->import->importItem($importer, ($this->entryData)([
+        [
+            'type' => 'secondEt',
+            'title' => 'different title',
+            'matchCriteria' => ['plainText' => 'plainText'],
+            'fields' => ['plainText' => 'foo'],
+        ],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $block = $entry->getFieldValue('myMatrix')->one();
+
+    expect($entry->getFieldValue('myMatrix')->count())->toBe(1)
+        // without the id check, a discarded-and-recreated block passes this too
+        ->and($block->id)->toBe($blockId)
+        ->and($block->title)->toBe('different title');
+});
+
+it('creates a new block when match criteria does not match any existing block', function () {
+    $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+
+    $this->import->importItem($importer, ($this->entryData)([
+        [
+            'type' => 'secondEt',
+            'title' => 'block 1',
+            'matchCriteria' => ['title' => 'title'],
+            'fields' => ['plainText' => 'foo'],
+        ],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myMatrix')->count())->toBe(1);
+    $blockId = $entry->getFieldValue('myMatrix')->one()->id;
+
+    $this->import->importItem($importer, ($this->entryData)([
+        [
+            'type' => 'secondEt',
+            'title' => 'block 1',
+            'matchCriteria' => ['title' => 'title'],
+            'fields' => ['plainText' => 'foo'],
+        ],
+        [
+            'type' => 'secondEt',
+            'title' => 'block 2',
+            'matchCriteria' => ['title' => 'title'],
+            'fields' => ['plainText' => 'bar'],
+        ],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $blocks = $entry->getFieldValue('myMatrix')->all();
+
+    // only the second row is new; the first keeps the block it matched
+    expect($blocks)->toHaveCount(2)
+        ->and(array_map(fn ($block) => $block->title, $blocks))->toBe(['block 1', 'block 2'])
+        ->and($blocks[0]->id)->toBe($blockId);
+});
+
+describe('nested matrix', function () {
+    it('imports an entry with a matrix field inside a matrix field', function () {
+        $this->import->importItem($this->importer, ($this->entryData)([
+            [
+                'type' => 'thirdEt',
+                'title' => 'outer block 1',
+                'fields' => [
+                    'plainText' => 'outer text',
+                    'myNestedMatrix' => [
+                        ['type' => 'firstEt', 'title' => 'inner block 1', 'fields' => ['plainText' => 'nested foo']],
+                    ],
+                ],
+            ],
+        ]));
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+
+        expect($entry)->not()->toBeNull();
+
+        $outerBlocks = $entry->getFieldValue('myMatrix');
+        expect($outerBlocks->count())->toBe(1);
+
+        $outerBlock = $outerBlocks->one();
+        expect($outerBlock->title)->toBe('outer block 1');
+        expect($outerBlock->getFieldValue('plainText'))->toBe('outer text');
+
+        $innerBlocks = $outerBlock->getFieldValue('myNestedMatrix');
+        expect($innerBlocks->count())->toBe(1);
+        expect($innerBlocks->one()->getFieldValue('plainText'))->toBe('nested foo');
+    });
+
+    it('imports multiple nested blocks of different entry types', function () {
+        $this->import->importItem($this->importer, ($this->entryData)([
+            [
+                'type' => 'thirdEt',
+                'title' => 'outer block 1',
+                'fields' => [
+                    'plainText' => 'outer text',
+                    'myNestedMatrix' => [
+                        ['type' => 'firstEt', 'title' => 'inner block 1', 'fields' => ['plainText' => 'nested foo']],
+                        ['type' => 'secondEt', 'title' => 'inner block 2', 'fields' => ['plainText' => 'nested bar']],
+                    ],
+                ],
+            ],
+        ]));
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+        $outerBlock = $entry->getFieldValue('myMatrix')->one();
+
+        expect($outerBlock->getFieldValue('myNestedMatrix')->count())->toBe(2);
+    });
+
+    it('updates an existing nested block when match criteria matches', function () {
+        $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+
+        $outerBlock = [
+            'type' => 'thirdEt',
+            'title' => 'outer block 1',
+            'matchCriteria' => ['title' => 'title'],
+            'fields' => [
+                'plainText' => 'outer text',
+                'myNestedMatrix' => [
+                    [
+                        'type' => 'firstEt',
+                        'title' => 'inner block 1',
+                        'matchCriteria' => ['title' => 'title'],
+                        'fields' => ['plainText' => 'nested foo'],
+                    ],
+                ],
+            ],
+        ];
+
+        $this->import->importItem($importer, ($this->entryData)([$outerBlock]));
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+        $outerBlockBefore = $entry->getFieldValue('myMatrix')->one();
+        expect($outerBlockBefore->getFieldValue('myNestedMatrix')->count())->toBe(1);
+        $outerBlockId = $outerBlockBefore->id;
+        $innerBlockId = $outerBlockBefore->getFieldValue('myNestedMatrix')->one()->id;
+
+        $outerBlock['fields']['myNestedMatrix'][0]['fields']['plainText'] = 'updated nested foo';
+
+        $this->import->importItem($importer, ($this->entryData)([$outerBlock]));
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+        $outerBlockAfter = $entry->getFieldValue('myMatrix')->one();
+        $innerBlocks = $outerBlockAfter->getFieldValue('myNestedMatrix');
+        // Neither level has an importer-config matchCriteria entry (only inline matchCriteria is
+        // provided), so this only stays as the same rows if both levels' inline matchCriteria
+        // actually got resolved and used for matching, rather than a fresh outer/inner block pair
+        // being created and the old ones discarded.
+        expect($outerBlockAfter->id)->toBe($outerBlockId);
+        expect($innerBlocks->count())->toBe(1)
+            ->and($innerBlocks->one()->id)->toBe($innerBlockId)
+            ->and($innerBlocks->one()->getFieldValue('plainText'))->toBe('updated nested foo');
+    });
+
+    it('resolves match criteria for nested blocks inside a nested block from the importer config', function () {
+        $importer = (clone $this->importer)->matchCriteria([
+            'title' => 'title',
+            'myMatrix' => [
+                'thirdEt' => [
+                    'title' => 'title',
+                    'fields' => [
+                        'myNestedMatrix' => [
+                            'firstEt' => ['title' => 'title'],
+                        ],
+                    ],
+                ],
+            ],
+        ]);
+
+        $outerBlock = [
+            'type' => 'thirdEt',
+            'title' => 'outer block 1',
+            'fields' => [
+                'plainText' => 'outer text',
+                'myNestedMatrix' => [
+                    ['type' => 'firstEt', 'title' => 'inner block 1', 'fields' => ['plainText' => 'nested foo']],
+                ],
+            ],
+        ];
+
+        ($this->importWithConfigCriteria)($importer, ($this->entryData)([$outerBlock]));
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+        $innerBlock = $entry->getFieldValue('myMatrix')->one()->getFieldValue('myNestedMatrix')->one();
+        expect($entry->getFieldValue('myMatrix')->one()->getFieldValue('myNestedMatrix')->count())->toBe(1);
+        $innerBlockId = $innerBlock->id;
+
+        $outerBlock['fields']['myNestedMatrix'][0]['fields']['plainText'] = 'updated nested foo';
+
+        ($this->importWithConfigCriteria)($importer, ($this->entryData)([$outerBlock]));
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+        $innerBlocks = $entry->getFieldValue('myMatrix')->one()->getFieldValue('myNestedMatrix');
+        expect($innerBlocks->count())->toBe(1)
+            ->and($innerBlocks->one()->id)->toBe($innerBlockId)
+            ->and($innerBlocks->one()->getFieldValue('plainText'))->toBe('updated nested foo');
+    });
+
+    it('resolves inline pointer-style match criteria for a doubly-nested block', function () {
+        $importer = (clone $this->importer)->matchCriteria([
+            'title' => 'title',
+            'myMatrix' => [
+                'thirdEt' => [
+                    'title' => 'title',
+                    'fields' => [
+                        'myNestedMatrix' => [
+                            'firstEt' => [],
+                        ],
+                    ],
+                ],
+            ],
+        ]);
+
+        $outerBlock = [
+            'type' => 'thirdEt',
+            'title' => 'outer block 1',
+            // the outer block needs criteria of its own too: if it isn't matched, its nested
+            // blocks belong to a freshly created owner and can't survive either
+            'matchCriteria' => ['title' => 'title'],
+            'fields' => [
+                'plainText' => 'outer text',
+                'myNestedMatrix' => [
+                    [
+                        'type' => 'firstEt',
+                        'title' => 'inner block 1',
+                        'matchCriteria' => ['plainText' => 'plainText'],
+                        'fields' => ['plainText' => 'nested foo'],
+                    ],
+                ],
+            ],
+        ];
+
+        $this->import->importItem($importer, ($this->entryData)([$outerBlock]));
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+        $innerBlocks = $entry->getFieldValue('myMatrix')->one()->getFieldValue('myNestedMatrix');
+        expect($innerBlocks->count())->toBe(1);
+        $innerBlockId = $innerBlocks->one()->id;
+
+        // Title changes but the inline-matched plainText value stays the same, so the existing
+        // inner block should be updated (not duplicated) if the pointer resolved correctly.
+        $outerBlock['fields']['myNestedMatrix'][0]['title'] = 'renamed inner block';
+
+        $this->import->importItem($importer, ($this->entryData)([$outerBlock]));
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+        $innerBlocks = $entry->getFieldValue('myMatrix')->one()->getFieldValue('myNestedMatrix');
+
+        expect($innerBlocks->count())->toBe(1)
+            ->and($innerBlocks->one()->id)->toBe($innerBlockId)
+            ->and($innerBlocks->one()->title)->toBe('renamed inner block');
+    });
+
+    it('creates a new nested block when match criteria does not match any existing nested block', function () {
+        $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+
+        $this->import->importItem($importer, ($this->entryData)([
+            [
+                'type' => 'thirdEt',
+                'title' => 'outer block 1',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => [
+                    'plainText' => 'outer text',
+                    'myNestedMatrix' => [
+                        [
+                            'type' => 'firstEt',
+                            'title' => 'inner block 1',
+                            'matchCriteria' => ['title' => 'title'],
+                            'fields' => ['plainText' => 'nested foo'],
+                        ],
+                    ],
+                ],
+            ],
+        ]));
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+        $innerBlocks = $entry->getFieldValue('myMatrix')->one()->getFieldValue('myNestedMatrix');
+        expect($innerBlocks->count())->toBe(1);
+        $innerBlockId = $innerBlocks->one()->id;
+
+        $this->import->importItem($importer, ($this->entryData)([
+            [
+                'type' => 'thirdEt',
+                'title' => 'outer block 1',
+                'matchCriteria' => ['title' => 'title'],
+                'fields' => [
+                    'plainText' => 'outer text',
+                    'myNestedMatrix' => [
+                        [
+                            'type' => 'firstEt',
+                            'title' => 'inner block 1',
+                            'matchCriteria' => ['title' => 'title'],
+                            'fields' => ['plainText' => 'nested foo'],
+                        ],
+                        [
+                            'type' => 'secondEt',
+                            'title' => 'inner block 2',
+                            'matchCriteria' => ['title' => 'title'],
+                            'fields' => ['plainText' => 'nested bar'],
+                        ],
+                    ],
+                ],
+            ],
+        ]));
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+        $innerBlocks = $entry->getFieldValue('myMatrix')->one()->getFieldValue('myNestedMatrix')->all();
+
+        // only the second inner row is new; the first keeps the block it matched
+        expect($innerBlocks)->toHaveCount(2)
+            ->and(array_map(fn ($block) => $block->title, $innerBlocks))->toBe(['inner block 1', 'inner block 2'])
+            ->and(array_map(fn ($block) => $block->getType()->handle, $innerBlocks))->toBe(['firstEt', 'secondEt'])
+            ->and($innerBlocks[0]->id)->toBe($innerBlockId);
+    });
+});
+
+it('skips blocks that are missing a type', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        ['title' => 'no type block', 'fields' => ['plainText' => 'foo']],
+        ['type' => 'secondEt', 'title' => 'valid block', 'fields' => ['plainText' => 'bar']],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry->getFieldValue('myMatrix')->count())->toBe(1);
+    expect($entry->getFieldValue('myMatrix')->one()->title)->toBe('valid block');
+});
+
+it('skips blocks with a type not allowed by the field', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        ['type' => 'notAnEntryType', 'title' => 'bad block', 'fields' => ['plainText' => 'foo']],
+        ['type' => 'secondEt', 'title' => 'valid block', 'fields' => ['plainText' => 'bar']],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry->getFieldValue('myMatrix')->count())->toBe(1);
+    expect($entry->getFieldValue('myMatrix')->one()->title)->toBe('valid block');
+});
+
+it('accepts the sortOrder/entries keyed input format', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'sortOrder' => ['new:1', 'new:2'],
+        'entries' => [
+            'new:1' => ['type' => 'secondEt', 'title' => 'block 1', 'fields' => ['plainText' => 'foo']],
+            'new:2' => ['type' => 'firstEt', 'title' => 'block 2', 'fields' => ['plainText' => 'bar']],
+        ],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry->getFieldValue('myMatrix')->count())->toBe(2);
+});
+
+describe('raw grouped/flat data through the full pipeline', function () {
+    it('imports raw data end-to-end, matching and clearing correctly', function (array $map, callable $makeRawData) {
+        $importer = (clone $this->importer)
+            ->matchCriteria([
+                'title' => 'title',
+                'myMatrix' => [
+                    'secondEt' => ['title' => 'title'],
+                    'firstEt' => ['title' => 'title'],
+                ],
+            ])
+            ->clearableItems([
+                'myMatrix' => [
+                    'secondEt' => ['fields' => ['plainText' => true]],
+                    'firstEt' => ['fields' => ['plainText' => true]],
+                ],
+            ]);
+
+        $rawData = $makeRawData($this->section->handle, $this->entryType->handle, 'foo');
+
+        $this->import->importItem(
+            $importer,
+            ImportHelper::remapData($map, $rawData),
+            // we must pass the importer's matchCriteria as this way because it only depends on the importer config,
+            // so it's done once per config rather than for each root item that is being imported
+            ImportHelper::normalizeMatchCriteriaFromImporterConfig($importer),
+        );
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+        expect($entry->getFieldValue('myMatrix')->count())->toBe(2);
+
+        $block1 = $entry->getFieldValue('myMatrix')->status(null)->title('block 1')->one();
+        $block1Id = $block1->id;
+        expect($block1->getFieldValue('plainText'))->toBe('foo');
+
+        // Re-import block 1 with plainText omitted from the source entirely - since it's marked
+        // clearable, it should be cleared to null on the SAME block (matched by title), not left
+        // untouched on a freshly created duplicate.
+        $rawData = $makeRawData($this->section->handle, $this->entryType->handle, null);
+
+        $this->import->importItem(
+            $importer,
+            ImportHelper::remapData($map, $rawData),
+            ImportHelper::normalizeMatchCriteriaFromImporterConfig($importer),
+        );
+
+        $entry = EntryElement::find()->title('imported entry')->one();
+        expect($entry->getFieldValue('myMatrix')->count())->toBe(2);
+        $block1 = $entry->getFieldValue('myMatrix')->status(null)->title('block 1')->one();
+        expect($block1->id)->toBe($block1Id);
+        expect($block1->getFieldValue('plainText'))->toBeNull();
+    })->with([
+        'grouped-by-type' => [
+            [
+                'title' => 'title',
+                'sectionId' => 'sectionId',
+                'typeId' => 'typeId',
+                'myMatrix' => [
+                    'secondEt' => [
+                        'title' => 'myMatrix.secondEt.title',
+                        'fields' => ['plainText' => 'myMatrix.secondEt.plainText'],
+                    ],
+                    'firstEt' => [
+                        'title' => 'myMatrix.firstEt.title',
+                        'fields' => ['plainText' => 'myMatrix.firstEt.plainText'],
+                    ],
+                ],
+            ],
+            fn (string $sectionHandle, string $entryTypeHandle, ?string $block1PlainText) => [
+                'title' => 'imported entry',
+                'sectionId' => $sectionHandle,
+                'typeId' => $entryTypeHandle,
+                'myMatrix' => [
+                    'secondEt' => [
+                        $block1PlainText === null
+                            ? ['title' => 'block 1']
+                            : ['title' => 'block 1', 'plainText' => $block1PlainText],
+                    ],
+                    'firstEt' => [
+                        ['title' => 'block 2', 'plainText' => 'bar'],
+                    ],
+                ],
+            ],
+        ],
+        'flat own-type-per-row' => [
+            [
+                'title' => 'title',
+                'sectionId' => 'sectionId',
+                'typeId' => 'typeId',
+                'myMatrix' => [
+                    'secondEt' => [
+                        'title' => 'myMatrix.title',
+                        'fields' => ['plainText' => 'myMatrix.plainText'],
+                    ],
+                    'firstEt' => [
+                        'title' => 'myMatrix.title',
+                        'fields' => ['plainText' => 'myMatrix.plainText'],
+                    ],
+                ],
+            ],
+            fn (string $sectionHandle, string $entryTypeHandle, ?string $block1PlainText) => [
+                'title' => 'imported entry',
+                'sectionId' => $sectionHandle,
+                'typeId' => $entryTypeHandle,
+                'myMatrix' => [
+                    $block1PlainText === null
+                        ? ['type' => 'secondEt', 'title' => 'block 1']
+                        : ['type' => 'secondEt', 'title' => 'block 1', 'plainText' => $block1PlainText],
+                    ['type' => 'firstEt', 'title' => 'block 2', 'plainText' => 'bar'],
+                ],
+            ],
+        ],
+    ]);
+});
diff --git a/tests/Feature/Import/ImportMatrixValidationTest.php b/tests/Feature/Import/ImportMatrixValidationTest.php
new file mode 100644
index 00000000000..8bf8c336f58
--- /dev/null
+++ b/tests/Feature/Import/ImportMatrixValidationTest.php
@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Element\Import\ElementImporter;
+use CraftCms\Cms\Entry\Models\EntryType;
+use CraftCms\Cms\Field\Fields as FieldsService;
+use CraftCms\Cms\Field\Matrix;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\Field\PlainText;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\Facades\Fields;
+use Illuminate\Support\Facades\Validator as ValidatorFacade;
+
+beforeEach(function () {
+    $plainTextField = Field::factory()->create([
+        'name' => 'Plain Text',
+        'handle' => 'plainText',
+        'type' => PlainText::class,
+    ]);
+
+    $this->firstEntryType = EntryType::factory()
+        ->withField($plainTextField)
+        ->create(['name' => 'First ET', 'handle' => 'firstEt']);
+
+    $this->secondEntryType = EntryType::factory()
+        ->withField($plainTextField)
+        ->create(['name' => 'Second ET', 'handle' => 'secondEt']);
+
+    $matrixFieldModel = Field::factory()->create([
+        'name' => 'My Matrix',
+        'handle' => 'myMatrix',
+        'type' => Matrix::class,
+        'settings' => ['entryTypes' => [$this->firstEntryType->id, $this->secondEntryType->id]],
+    ]);
+
+    EntryTypes::refreshEntryTypes();
+    Fields::refreshFields();
+
+    $this->matrixField = app(FieldsService::class)->getFieldByHandle('myMatrix');
+    $this->validator = ValidatorFacade::make([], []);
+});
+
+it('validateMapping returns true when all entry types in the map are allowed', function () {
+    $failCalled = false;
+    $fail = function () use (&$failCalled) {
+        $failCalled = true;
+    };
+
+    $value = [
+        'firstEt' => ['map' => ['plainText' => 'plainText']],
+        'secondEt' => ['map' => ['plainText' => 'plainText']],
+    ];
+
+    $result = $this->matrixField->validateMapping($value, 'map', $fail, $this->validator, ['field' => $this->matrixField]);
+
+    expect($result)->toBeTrue();
+    expect($failCalled)->toBeFalse();
+});
+
+it('validateMapping returns false and calls $fail when the map references a disallowed entry type', function () {
+    $failMessages = [];
+    $fail = function (string $attr, string $msg) use (&$failMessages) {
+        $failMessages[] = $msg;
+    };
+
+    $value = [
+        'type' => [
+            'firstEt' => ['map' => ['plainText' => 'plainText']],
+            'notAllowed' => ['map' => ['plainText' => 'plainText']],
+        ],
+    ];
+
+    $result = $this->matrixField->validateMapping($value, 'map', $fail, $this->validator, ['field' => $this->matrixField]);
+
+    expect($result)->toBeFalse();
+    expect($failMessages)->not()->toBeEmpty();
+});
+
+it('ElementImporter::validateMap returns true when no field param is given', function () {
+    $failCalled = false;
+    $fail = function () use (&$failCalled) {
+        $failCalled = true;
+    };
+
+    $result = ElementImporter::validateMap(['type' => []], 'map', $fail, $this->validator);
+
+    expect($result)->toBeTrue();
+    expect($failCalled)->toBeFalse();
+});
+
+it('ElementImporter::validateMap calls $fail via the field when an entry type is not allowed', function () {
+    $failMessages = [];
+    $fail = function (string $attr, string $msg) use (&$failMessages) {
+        $failMessages[] = $msg;
+    };
+
+    $value = [
+        'type' => [
+            'notAllowed' => ['map' => []],
+        ],
+    ];
+
+    // validateMap always returns true; it surfaces errors through $fail
+    $result = ElementImporter::validateMap($value, 'map', $fail, $this->validator, ['field' => $this->matrixField]);
+
+    expect($result)->toBeTrue();
+    expect($failMessages)->not()->toBeEmpty();
+});
diff --git a/tests/Feature/Import/ImportNestedContentTest.php b/tests/Feature/Import/ImportNestedContentTest.php
new file mode 100644
index 00000000000..4afd0d3f14e
--- /dev/null
+++ b/tests/Feature/Import/ImportNestedContentTest.php
@@ -0,0 +1,245 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Address\Elements\Address;
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Entry\Models\EntryType;
+use CraftCms\Cms\Field\Addresses as AddressesField;
+use CraftCms\Cms\Field\ContentBlock as ContentBlockField;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\Field\PlainText;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\FieldLayout\LayoutElements\Entries\EntryTitleField;
+use CraftCms\Cms\FieldLayout\Models\FieldLayout;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Support\Str;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    // Fields inside the content block
+    $cbTextField = Field::factory()->create([
+        'name' => 'CB Text',
+        'handle' => 'cbText',
+        'type' => PlainText::class,
+    ]);
+
+    $cbAddressesField = Field::factory()->create([
+        'name' => 'CB Addresses',
+        'handle' => 'cbAddresses',
+        'type' => AddressesField::class,
+    ]);
+
+    Fields::refreshFields();
+
+    $contentBlockField = Field::factory()->create([
+        'name' => 'My Content Block',
+        'handle' => 'myContentBlock',
+        'type' => ContentBlockField::class,
+        'settings' => [
+            'fieldLayouts' => [
+                Str::uuid()->toString() => [
+                    'tabs' => [[
+                        'uid' => Str::uuid()->toString(),
+                        'name' => 'Content',
+                        'elements' => [
+                            [
+                                'uid' => Str::uuid()->toString(),
+                                'type' => CustomField::class,
+                                'fieldUid' => $cbTextField->uid,
+                                'required' => false,
+                            ],
+                            [
+                                'uid' => Str::uuid()->toString(),
+                                'type' => CustomField::class,
+                                'fieldUid' => $cbAddressesField->uid,
+                                'required' => false,
+                            ],
+                        ],
+                    ]],
+                ],
+            ],
+        ],
+    ]);
+
+    Fields::refreshFields();
+
+    $plainTextField = ImportFixtures::plainTextField('plainText', 'Plain Text');
+
+    Fields::refreshFields();
+
+    $forMatrixEntryType = EntryType::factory()
+        ->withFieldLayout(
+            FieldLayout::factory()
+                ->withContentTab([
+                    new EntryTitleField(['uid' => Str::uuid()->toString(), 'required' => true]),
+                    CustomField::make($plainTextField->handle),
+                    CustomField::make($contentBlockField->handle),
+                ])
+                ->create()
+        )
+        ->create([
+            'name' => 'For Matrix Entry Type',
+            'handle' => 'forMatrixEntryType',
+            'hasTitleField' => true,
+        ]);
+
+    $matrixField = ImportFixtures::matrixField('myMatrix', [$forMatrixEntryType], 'My Matrix');
+
+    $seed = ImportFixtures::seedEntry(
+        [CustomField::make($matrixField->handle)],
+        ['name' => 'With Matrix Field', 'handle' => 'withMatrixField'],
+    );
+
+    $this->section = $seed->section;
+    $this->entryType = $seed->entryType;
+
+    $this->importer = EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null);
+
+    $this->address = [
+        'title' => 'address 1',
+        'countryCode' => 'US',
+        'addressLine1' => '123 Main St',
+        'administrativeArea' => 'UT',
+        'postalCode' => '12345',
+        'locality' => 'My Town',
+    ];
+
+    $this->entryData = fn (array $blocks) => [
+        'title' => 'imported entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $this->entryType->handle,
+        'myMatrix' => $blocks,
+        'matchCriteria' => ['title' => 'title'],
+    ];
+});
+
+it('imports all fields through the matrix → content block → plain text and addresses chain', function () {
+    $this->import->importItem($this->importer, ($this->entryData)([
+        [
+            'type' => 'forMatrixEntryType',
+            'title' => 'block 1',
+            'fields' => [
+                'plainText' => 'block text value',
+                'myContentBlock' => [
+                    'fields' => [
+                        'cbText' => 'content block text',
+                        'cbAddresses' => [$this->address],
+                    ],
+                ],
+            ],
+        ],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry)->not()->toBeNull();
+
+    $block = $entry->getFieldValue('myMatrix')->one();
+    expect($block->getFieldValue('plainText'))->toBe('block text value');
+
+    $contentBlock = $block->getFieldValue('myContentBlock');
+    expect($contentBlock)->not()->toBeNull();
+    expect($contentBlock->getFieldValue('cbText'))->toBe('content block text');
+
+    $address = Address::find()->ownerId($contentBlock->id)->one();
+    expect($address)->not()->toBeNull()
+        ->and($address->countryCode)->toBe('US')
+        ->and($address->addressLine1)->toBe('123 Main St');
+});
+
+it('updates values at all levels on reimport', function () {
+    $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+
+    $block = [
+        'type' => 'forMatrixEntryType',
+        'title' => 'block 1',
+        'matchCriteria' => ['title' => 'title'],
+        'fields' => [
+            'plainText' => 'block text value',
+            'myContentBlock' => [
+                'fields' => [
+                    'cbText' => 'content block text',
+                    'cbAddresses' => [$this->address],
+                ],
+            ],
+        ],
+    ];
+
+    $this->import->importItem($importer, ($this->entryData)([$block]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $contentBlock = $entry->getFieldValue('myMatrix')->one()->getFieldValue('myContentBlock');
+    expect($contentBlock->getFieldValue('cbText'))->toBe('content block text');
+    expect(Address::find()->ownerId($contentBlock->id)->count())->toBe(1);
+
+    $block['fields']['plainText'] = 'updated block text';
+    $block['fields']['myContentBlock']['fields']['cbText'] = 'updated content block text';
+    $block['fields']['myContentBlock']['fields']['cbAddresses'][0]['addressLine1'] = '456 Updated Ave';
+
+    $this->import->importItem($importer, ($this->entryData)([$block]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $matrixBlock = $entry->getFieldValue('myMatrix')->one();
+    expect($matrixBlock->getFieldValue('plainText'))->toBe('updated block text');
+
+    $contentBlock = $matrixBlock->getFieldValue('myContentBlock');
+    expect($contentBlock->getFieldValue('cbText'))->toBe('updated content block text');
+    expect(Address::find()->ownerId($contentBlock->id)->one()->addressLine1)->toBe('456 Updated Ave');
+});
+
+// Identity through the whole chain: every level is matched in place rather than recreated, which
+// needs the content block element to be handed down as the owner for its nested fields.
+it('keeps every element in the chain on reimport when match criteria are set at each level', function () {
+    $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+
+    $block = fn (string $text) => [
+        'type' => 'forMatrixEntryType',
+        'title' => 'block 1',
+        'matchCriteria' => ['title' => 'title'],
+        'fields' => [
+            'plainText' => $text,
+            'myContentBlock' => [
+                'fields' => [
+                    'cbText' => $text,
+                    'cbAddresses' => [[...$this->address, 'matchCriteria' => ['title' => 'title']]],
+                ],
+            ],
+        ],
+    ];
+
+    $this->import->importItem($importer, ($this->entryData)([$block('one')]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $matrixBlock = $entry->getFieldValue('myMatrix')->one();
+    $contentBlock = $matrixBlock->getFieldValue('myContentBlock');
+    $seededIds = [
+        'entry' => $entry->id,
+        'matrixBlock' => $matrixBlock->id,
+        'contentBlock' => $contentBlock->id,
+        'address' => Address::find()->ownerId($contentBlock->id)->one()->id,
+    ];
+
+    $this->import->importItem($importer, ($this->entryData)([$block('two')]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    $matrixBlock = $entry->getFieldValue('myMatrix')->one();
+    $contentBlock = $matrixBlock->getFieldValue('myContentBlock');
+    $addresses = Address::find()->ownerId($contentBlock->id)->all();
+
+    expect($matrixBlock->getFieldValue('plainText'))->toBe('two')
+        ->and($contentBlock->getFieldValue('cbText'))->toBe('two')
+        ->and($addresses)->toHaveCount(1)
+        ->and([
+            'entry' => $entry->id,
+            'matrixBlock' => $matrixBlock->id,
+            'contentBlock' => $contentBlock->id,
+            'address' => $addresses[0]->id,
+        ])->toBe($seededIds);
+});
diff --git a/tests/Feature/Import/ImportRelationFieldsTest.php b/tests/Feature/Import/ImportRelationFieldsTest.php
new file mode 100644
index 00000000000..f85f229c019
--- /dev/null
+++ b/tests/Feature/Import/ImportRelationFieldsTest.php
@@ -0,0 +1,202 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Asset\Models\Asset;
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Entry\Import\EntryTransformer;
+use CraftCms\Cms\Entry\Models\Entry;
+use CraftCms\Cms\Field\Assets as AssetsField;
+use CraftCms\Cms\Field\Entries as EntriesField;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\Field\Users as UsersField;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+use CraftCms\Cms\User\Models\User;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $allFields = [
+        Field::factory()->create(['name' => 'My Entries', 'handle' => 'myEntries', 'type' => EntriesField::class]),
+        Field::factory()->create(['name' => 'My Users', 'handle' => 'myUsers', 'type' => UsersField::class]),
+        Field::factory()->create(['name' => 'My Assets', 'handle' => 'myAssets', 'type' => AssetsField::class]),
+    ];
+
+    Fields::refreshFields();
+
+    $this->relatedUser = User::factory()->createElement();
+    $this->relatedAsset = Asset::factory()->createElement();
+
+    $layoutElements = array_map(fn ($field) => CustomField::make($field->handle), $allFields);
+
+    $seed = ImportFixtures::seedEntry($layoutElements, ['name' => 'With Relation Fields', 'handle' => 'withRelationFields']);
+
+    $this->section = $seed->section;
+    $this->entryType = $seed->entryType;
+
+    $relatedResult = Entry::factory()
+        ->forSection($seed->section)
+        ->forEntryType($seed->entryType)
+        ->withFieldLayout($seed->fieldLayout)
+        ->createElementWithFields(['title' => 'related entry', 'slug' => 'related-entry']);
+
+    $this->relatedEntry = $relatedResult->element;
+
+    $this->importer = EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null);
+
+    $this->entryData = fn (array $fieldValues) => array_merge([
+        'title' => 'imported entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $this->entryType->handle,
+        'matchCriteria' => ['title' => 'title'],
+    ], $fieldValues);
+});
+
+it('imports an entries field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myEntries' => [$this->relatedEntry->id]]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    // assert the whole list, so an extra or reordered relation can't slip through
+    expect($entry->getFieldValue('myEntries')->ids())->toBe([$this->relatedEntry->id]);
+});
+
+it('imports a users field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myUsers' => [$this->relatedUser->id]]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myUsers')->ids())->toBe([$this->relatedUser->id]);
+});
+
+it('imports an assets field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myAssets' => [$this->relatedAsset->id]]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myAssets')->ids())->toBe([$this->relatedAsset->id]);
+});
+
+it('imports an entries field value using a transformer with ID map', function () {
+    $importer = (clone $this->importer)
+        ->transformer(new class extends EntryTransformer
+        {
+            public function transform(mixed $item): array
+            {
+                $array = parent::transform($item);
+                $array['myEntries'] = $item['myEntriesToBeMapped'];
+
+                return $array;
+            }
+        });
+
+    $this->import->importItem($importer, ($this->entryData)(['myEntriesToBeMapped' => [$this->relatedEntry->id]]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myEntries')->ids())->toBe([$this->relatedEntry->id]);
+});
+
+it('imports an entries field value using a transformer with element lookup', function () {
+    $importer = (clone $this->importer)
+        ->transformer(new class extends EntryTransformer
+        {
+            public function transform(mixed $item): array
+            {
+                $array = parent::transform($item);
+                $array['myEntries'] = EntryElement::find()->title($item['myEntriesToBeMapped'])->ids();
+
+                return $array;
+            }
+        });
+
+    $this->import->importItem($importer, ($this->entryData)(['myEntriesToBeMapped' => [$this->relatedEntry->title]]));
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myEntries')->ids())->toBe([$this->relatedEntry->id]);
+});
+
+// the manual fixture lists ids in a deliberately non-ascending order ("image": [141, 140])
+it('preserves the order of related element ids', function () {
+    $second = Entry::factory()
+        ->forSection($this->section)
+        ->forEntryType($this->entryType)
+        ->createElementWithFields(['title' => 'second related entry', 'slug' => 'second-related-entry'])
+        ->element;
+
+    $this->import->importItem($this->importer, ($this->entryData)([
+        'myEntries' => [$second->id, $this->relatedEntry->id],
+    ]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry->getFieldValue('myEntries')->ids())->toBe([$second->id, $this->relatedEntry->id]);
+});
+
+it('leaves existing relations alone when the field is absent from a later import', function () {
+    $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+
+    $this->import->importItem($importer, ($this->entryData)(['myEntries' => [$this->relatedEntry->id]]));
+    $this->import->importItem($importer, ($this->entryData)([]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry->getFieldValue('myEntries')->ids())->toBe([$this->relatedEntry->id]);
+});
+
+// an empty value only clears a field that's marked clearable - the same rule ImportClearableItemsTest
+// covers for plain text, here for relations
+it('leaves existing relations alone when an empty list is provided and the field is not clearable', function () {
+    $importer = (clone $this->importer)->matchCriteria(['title' => 'title']);
+
+    $this->import->importItem($importer, ($this->entryData)(['myEntries' => [$this->relatedEntry->id]]));
+    $this->import->importItem($importer, ($this->entryData)(['myEntries' => []]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry->getFieldValue('myEntries')->ids())->toBe([$this->relatedEntry->id]);
+});
+
+// applyClearableItems() turns the empty list into null, and BaseRelationField::normalizeValueForImport()
+// turns that into an empty list again - which is the value that actually clears relations.
+it('clears existing relations when an empty list is provided for a clearable field', function () {
+    $importer = (clone $this->importer)
+        ->matchCriteria(['title' => 'title'])
+        ->clearableItems(['myEntries']);
+
+    $this->import->importItem($importer, ($this->entryData)(['myEntries' => [$this->relatedEntry->id]]));
+    $this->import->importItem($importer, ($this->entryData)(['myEntries' => []]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry->getFieldValue('myEntries')->ids())->toBe([]);
+});
+
+// the other trigger in applyClearableItems(): the handle is absent altogether
+it('clears existing relations when a clearable field is absent from a later import', function () {
+    $importer = (clone $this->importer)
+        ->matchCriteria(['title' => 'title'])
+        ->clearableItems(['myEntries']);
+
+    $this->import->importItem($importer, ($this->entryData)(['myEntries' => [$this->relatedEntry->id]]));
+    $this->import->importItem($importer, ($this->entryData)([]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+
+    expect($entry->getFieldValue('myEntries')->ids())->toBe([]);
+});
+
+// the fix lives on BaseRelationField, so it covers every relation field type, not just entries
+it('clears an assets field marked clearable', function () {
+    $importer = (clone $this->importer)
+        ->matchCriteria(['title' => 'title'])
+        ->clearableItems(['myAssets']);
+
+    $this->import->importItem($importer, ($this->entryData)(['myAssets' => [$this->relatedAsset->id]]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myAssets')->ids())->toBe([$this->relatedAsset->id]);
+
+    $this->import->importItem($importer, ($this->entryData)(['myAssets' => []]));
+
+    $entry = EntryElement::find()->title('imported entry')->one();
+    expect($entry->getFieldValue('myAssets')->ids())->toBe([]);
+});
diff --git a/tests/Feature/Import/ImportSectionsAndTypesTest.php b/tests/Feature/Import/ImportSectionsAndTypesTest.php
new file mode 100644
index 00000000000..67fb1016daf
--- /dev/null
+++ b/tests/Feature/Import/ImportSectionsAndTypesTest.php
@@ -0,0 +1,127 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Section\Models\Section;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $plainTextField = ImportFixtures::plainTextField('plainText', 'Plain Text');
+    Fields::refreshFields();
+
+    $this->sharedType = ImportFixtures::entryTypeWithTitle(
+        [CustomField::make($plainTextField->handle)],
+        ['name' => 'Shared Type', 'handle' => 'sharedType'],
+    );
+
+    // only allowed in the second section, like withPlainText2 is only in one of the manual sections
+    $this->secondSectionOnlyType = ImportFixtures::entryTypeWithTitle(
+        [CustomField::make($plainTextField->handle)],
+        ['name' => 'Second Section Only', 'handle' => 'secondSectionOnlyType'],
+    );
+
+    $this->firstSection = Section::factory()
+        ->withEntryTypes($this->sharedType)
+        ->create(['handle' => 'firstImportSection', 'minAuthors' => 0]);
+
+    $this->secondSection = Section::factory()
+        ->withEntryTypes($this->sharedType, $this->secondSectionOnlyType)
+        ->create(['handle' => 'secondImportSection', 'minAuthors' => 0]);
+
+    EntryTypes::refreshEntryTypes();
+    Fields::refreshFields();
+
+    $this->importer = EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null)
+        ->matchCriteria(['title' => 'title']);
+
+    // a single payload spanning both sections and both entry types, as the manual
+    // "different sections and ets" fixture does
+    $this->rows = [
+        [
+            'title' => 'row in the first section',
+            'sectionId' => 'firstImportSection',
+            'typeId' => 'sharedType',
+            'plainText' => 'one',
+            'matchCriteria' => ['title' => 'title'],
+        ],
+        [
+            'title' => 'row in the second section',
+            'sectionId' => 'secondImportSection',
+            'typeId' => 'sharedType',
+            'plainText' => 'two',
+            'matchCriteria' => ['title' => 'title'],
+        ],
+        [
+            'title' => 'row with the second section’s own type',
+            'sectionId' => 'secondImportSection',
+            'typeId' => 'secondSectionOnlyType',
+            'plainText' => 'three',
+            'matchCriteria' => ['title' => 'title'],
+        ],
+    ];
+
+    $this->importRows = function (array $rows) {
+        foreach ($rows as $row) {
+            $this->import->importItem($this->importer, $row);
+        }
+    };
+});
+
+it('imports rows into different sections and entry types from one payload', function () {
+    ($this->importRows)($this->rows);
+
+    $first = EntryElement::find()->title('row in the first section')->status(null)->one();
+    $second = EntryElement::find()->title('row in the second section')->status(null)->one();
+    $third = EntryElement::find()->title('row with the second section’s own type')->status(null)->one();
+
+    expect($first->sectionId)->toBe($this->firstSection->id)
+        ->and($first->getType()->handle)->toBe('sharedType')
+        ->and($second->sectionId)->toBe($this->secondSection->id)
+        ->and($second->getType()->handle)->toBe('sharedType')
+        ->and($third->sectionId)->toBe($this->secondSection->id)
+        ->and($third->getType()->handle)->toBe('secondSectionOnlyType');
+});
+
+it('re-imports the same payload without duplicating any row', function () {
+    ($this->importRows)($this->rows);
+    $ids = EntryElement::find()->status(null)->ids();
+
+    ($this->importRows)($this->rows);
+
+    expect(EntryElement::find()->status(null)->ids())->toBe($ids);
+});
+
+// Each row carries its own typeId and the importer has no field layout provider, so the row wins -
+// the opposite of ImportEntryTest's "uses the entry type selected via the field layout provider",
+// where the importer is editable and its provider takes over.
+it('uses each row’s own entry type when the importer has no field layout provider', function () {
+    ($this->importRows)([$this->rows[2]]);
+
+    expect(EntryElement::find()->title('row with the second section’s own type')->status(null)->one()->getType()->handle)
+        ->toBe('secondSectionOnlyType');
+});
+
+// Validation rejects the entry, so the row is skipped (logged as a warning) rather than imported
+// under a type its section doesn't allow.
+it('skips a row whose entry type is not allowed in its section', function () {
+    ($this->importRows)([[
+        'title' => 'row with a disallowed type',
+        'sectionId' => 'firstImportSection',
+        'typeId' => 'secondSectionOnlyType',
+        'plainText' => 'mismatched',
+        'matchCriteria' => ['title' => 'title'],
+    ]]);
+
+    expect(EntryElement::find()->title('row with a disallowed type')->status(null)->one())->toBeNull();
+});
diff --git a/tests/Feature/Import/ImportSkipsUnchangedElementTest.php b/tests/Feature/Import/ImportSkipsUnchangedElementTest.php
new file mode 100644
index 00000000000..3194078c126
--- /dev/null
+++ b/tests/Feature/Import/ImportSkipsUnchangedElementTest.php
@@ -0,0 +1,136 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Element\Events\ElementSaving;
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Field\Entries as EntriesField;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\Field\PlainText;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\Tests\Support\ImportFixtures;
+use Illuminate\Support\Facades\Event;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $textField = Field::factory()->create(['name' => 'My Plain Text', 'handle' => 'myPlainText', 'type' => PlainText::class]);
+    $relationField = Field::factory()->create(['name' => 'My Entries', 'handle' => 'myEntries', 'type' => EntriesField::class]);
+    $blockTextField = ImportFixtures::plainTextField('blockText', 'Block Text');
+    $blockEntryType = ImportFixtures::blockEntryType('blockEt', [$blockTextField], 'Block ET');
+    $matrixField = ImportFixtures::matrixField('myMatrix', [$blockEntryType], 'My Matrix');
+
+    Fields::refreshFields();
+
+    $seed = ImportFixtures::seedEntry(
+        [
+            CustomField::make($textField->handle),
+            CustomField::make($relationField->handle),
+            CustomField::make($matrixField->handle),
+        ],
+        ['name' => 'With Fields', 'handle' => 'withFields'],
+    );
+
+    $this->section = $seed->section;
+    $this->entryType = $seed->entryType;
+
+    // the seeded entry is both the element the imports below match against, and the element the
+    // relation field points at
+    $this->relatedEntry = $seed->entry;
+
+    $this->importer = EntryImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null)
+        ->matchCriteria(['title' => 'title']);
+
+    $this->entryData = fn (array $fieldValues = []) => array_merge([
+        'title' => 'seed entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $this->entryType->handle,
+        'myPlainText' => 'original text',
+        'matchCriteria' => ['title' => 'title'],
+    ], $fieldValues);
+
+    // establish the initial field value through the importer itself, so re-imports below can compare against it
+    $this->import->importItem($this->importer, ($this->entryData)());
+
+    // count ElementSaving occurrences from here on, so the seeding save above isn't counted
+    $this->saveCount = 0;
+    Event::listen(ElementSaving::class, function () {
+        $this->saveCount++;
+    });
+});
+
+it('does not save when re-importing identical attribute and field values', function () {
+    $this->import->importItem($this->importer, ($this->entryData)());
+
+    expect($this->saveCount)->toBe(0);
+});
+
+it('saves when re-importing with a changed attribute', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['postDate' => '2020-06-15 12:00:00']));
+
+    expect($this->saveCount)->toBeGreaterThan(0);
+
+    $entry = EntryElement::find()->title('seed entry')->status(null)->one();
+    expect($entry->postDate->year)->toBe(2020);
+});
+
+it('saves when re-importing with a changed field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myPlainText' => 'updated text']));
+
+    expect($this->saveCount)->toBe(1);
+
+    $entry = EntryElement::find()->title('seed entry')->status(null)->one();
+    expect($entry->getFieldValue('myPlainText'))->toBe('updated text');
+});
+
+it('saves when re-importing with a changed relation field value', function () {
+    $this->import->importItem($this->importer, ($this->entryData)(['myEntries' => [$this->relatedEntry->id]]));
+
+    expect($this->saveCount)->toBeGreaterThan(0);
+
+    $entry = EntryElement::find()->title('seed entry')->status(null)->one();
+    expect($entry->getFieldValue('myEntries')->one()->id)->toBe($this->relatedEntry->id);
+});
+
+it('always saves a brand-new element even when mapped values match field defaults', function () {
+    $this->import->importItem($this->importer, [
+        'title' => 'brand new entry',
+        'sectionId' => $this->section->handle,
+        'typeId' => $this->entryType->handle,
+    ]);
+
+    expect($this->saveCount)->toBeGreaterThan(0);
+
+    $entry = EntryElement::find()->title('brand new entry')->status(null)->one();
+    expect($entry)->not->toBeNull();
+});
+
+// The fix for "a container field the element has nothing for yet" must not turn into "always save
+// when container data is present" - a matrix whose blocks are unchanged still diffs correctly.
+it('does not save when re-importing a row whose matrix blocks are unchanged', function () {
+    $blocks = [
+        [
+            'type' => 'blockEt',
+            'title' => 'block 1',
+            'matchCriteria' => ['title' => 'title'],
+            'fields' => ['blockText' => 'one'],
+        ],
+    ];
+
+    // the seed import in beforeEach had no matrix data, so this one creates the blocks
+    $this->import->importItem($this->importer, ($this->entryData)(['myMatrix' => $blocks]));
+    expect($this->saveCount)->toBeGreaterThan(0);
+
+    $this->saveCount = 0;
+
+    $this->import->importItem($this->importer, ($this->entryData)(['myMatrix' => $blocks]));
+
+    expect($this->saveCount)->toBe(0)
+        ->and(EntryElement::find()->title('seed entry')->status(null)->one()->getFieldValue('myMatrix')->count())->toBe(1);
+});
diff --git a/tests/Feature/Import/ImportToModelTest.php b/tests/Feature/Import/ImportToModelTest.php
new file mode 100644
index 00000000000..62d06043f70
--- /dev/null
+++ b/tests/Feature/Import/ImportToModelTest.php
@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Support\ImportHelper;
+use CraftCms\Cms\SystemMessage\Import\SystemMessageImporter;
+use CraftCms\Cms\SystemMessage\Models\SystemMessage;
+use CraftCms\Cms\User\Elements\User;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $this->importer = SystemMessageImporter::create();
+
+    // as the CLI command and the Import job do, resolve the importer's own match criteria once
+    $this->matchCriteria = ImportHelper::normalizeMatchCriteriaFromImporterConfig($this->importer);
+
+    $this->modelData = [
+        'key' => 'my_message',
+        'language' => 'en',
+        'subject' => 'my subject',
+        'body' => 'my body',
+        'fake' => 'foo', // this should be filtered out by the import
+    ];
+});
+
+it('imports into a model that is not an element', function () {
+    $this->import->importItem($this->importer, $this->modelData, $this->matchCriteria);
+
+    $message = SystemMessage::where(['key' => 'my_message', 'language' => 'en'])->first();
+    expect($message?->getAttribute('subject'))->toBe('my subject')
+        ->and($message?->getAttribute('body'))->toBe('my body');
+});
+
+it('always saves a brand-new model', function () {
+    $saveCount = 0;
+    SystemMessage::saving(function () use (&$saveCount) {
+        $saveCount++;
+    });
+
+    $this->import->importItem($this->importer, $this->modelData, $this->matchCriteria);
+
+    expect($saveCount)->toBe(1);
+});
+
+it('does not save when re-importing identical attributes', function () {
+    $this->import->importItem($this->importer, $this->modelData, $this->matchCriteria);
+
+    $saveCount = 0;
+    SystemMessage::saving(function () use (&$saveCount) {
+        $saveCount++;
+    });
+
+    $this->import->importItem($this->importer, $this->modelData, $this->matchCriteria);
+
+    expect($saveCount)->toBe(0);
+});
+
+it('saves when re-importing with a changed attribute', function () {
+    $this->import->importItem($this->importer, $this->modelData, $this->matchCriteria);
+
+    $saveCount = 0;
+    SystemMessage::saving(function () use (&$saveCount) {
+        $saveCount++;
+    });
+
+    $this->import->importItem($this->importer, [...$this->modelData, 'body' => 'updated body'], $this->matchCriteria);
+
+    expect($saveCount)->toBe(1);
+
+    $message = SystemMessage::where(['key' => 'my_message', 'language' => 'en'])->first();
+    expect($message?->getAttribute('body'))->toBe('updated body');
+});
+
+it('resolves the importer registered for a model', function () {
+    expect($this->import->getModelImporterTypeFor(SystemMessage::class))->toBe(SystemMessageImporter::class);
+});
+
+it('returns null for a model with no registered importer', function () {
+    expect($this->import->getModelImporterTypeFor(User::class))->toBeNull();
+});
diff --git a/tests/Feature/Import/ImportUserAddressesTest.php b/tests/Feature/Import/ImportUserAddressesTest.php
new file mode 100644
index 00000000000..72845bb03b2
--- /dev/null
+++ b/tests/Feature/Import/ImportUserAddressesTest.php
@@ -0,0 +1,137 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Address\Elements\Address;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Support\Facades\Sites;
+use CraftCms\Cms\User\Elements\User as UserElement;
+use CraftCms\Cms\User\Import\UserImporter;
+
+beforeEach(function () {
+    $this->import = app(Import::class);
+
+    $this->importer = UserImporter::create()
+        ->site(Sites::getPrimarySite()->handle)
+        ->transformer(null);
+
+    $this->userData = fn (array $addresses, array $overrides = []) => array_merge([
+        'username' => 'importeduser',
+        'email' => 'imported@example.com',
+        'matchCriteria' => ['email' => 'email'],
+    ], $overrides, ['addresses' => $addresses]);
+
+    $this->address = [
+        'title' => 'address 1',
+        'countryCode' => 'US',
+        'addressLine1' => '123 Main St',
+        'addressLine2' => 'Apt 4',
+        'administrativeArea' => 'UT',
+        'postalCode' => '12345',
+        'locality' => 'My Town',
+    ];
+});
+
+it('imports a user with an address', function () {
+    $this->import->importItem($this->importer, ($this->userData)([$this->address]));
+
+    $user = UserElement::find()->username('importeduser')->one();
+
+    expect($user)->not()->toBeNull();
+    expect(Address::find()->ownerId($user->id)->count())->toBe(1);
+});
+
+it('imports multiple addresses into the user', function () {
+    $second = array_merge($this->address, ['title' => 'address 2', 'addressLine1' => '456 Elm St']);
+
+    $this->import->importItem($this->importer, ($this->userData)([$this->address, $second]));
+
+    $user = UserElement::find()->username('importeduser')->one();
+
+    expect(Address::find()->ownerId($user->id)->count())->toBe(2);
+});
+
+it('maps native address fields correctly', function () {
+    $this->import->importItem($this->importer, ($this->userData)([$this->address]));
+
+    $user = UserElement::find()->username('importeduser')->one();
+    $address = Address::find()->ownerId($user->id)->one();
+
+    expect($address->countryCode)->toBe($this->address['countryCode'])
+        ->and($address->addressLine1)->toBe($this->address['addressLine1'])
+        ->and($address->addressLine2)->toBe($this->address['addressLine2'])
+        ->and($address->administrativeArea)->toBe($this->address['administrativeArea'])
+        ->and($address->postalCode)->toBe($this->address['postalCode'])
+        ->and($address->locality)->toBe($this->address['locality'])
+        ->and($address->title)->toBe($this->address['title']);
+});
+
+it('updates an existing address when match criteria matches', function () {
+    $importer = (clone $this->importer);
+
+    $addressWithCriteria = array_merge($this->address, [
+        'matchCriteria' => ['title' => $this->address['title']],
+    ]);
+
+    $this->import->importItem($importer, ($this->userData)([$addressWithCriteria]));
+
+    $user = UserElement::find()->username('importeduser')->one();
+    expect(Address::find()->ownerId($user->id)->count())->toBe(1);
+    $originalAddressId = Address::find()->ownerId($user->id)->one()->id;
+
+    $addressLine1Updated = '999 Updated Ave';
+
+    $updated = array_merge($addressWithCriteria, ['addressLine1' => $addressLine1Updated]);
+    $this->import->importItem($importer, ($this->userData)([$updated]));
+
+    expect(Address::find()->ownerId($user->id)->count())->toBe(1);
+    $address = Address::find()->ownerId($user->id)->one();
+    expect($address->id)->toBe($originalAddressId);
+    expect($address->addressLine1)->toBe($addressLine1Updated);
+});
+
+it('creates a new address when match criteria does not match any existing address', function () {
+    $importer = (clone $this->importer);
+
+    $firstAddress = array_merge($this->address, [
+        'matchCriteria' => ['title' => $this->address['title']],
+    ]);
+
+    $this->import->importItem($importer, ($this->userData)([$firstAddress]));
+
+    $user = UserElement::find()->username('importeduser')->one();
+    expect(Address::find()->ownerId($user->id)->count())->toBe(1);
+
+    // re-importing the same address (matched by title) alongside a second, unmatched one
+    // should reuse the first and create only one new address
+    $newAddress = array_merge($this->address, [
+        'title' => 'address 2',
+        'addressLine1' => '456 Elm St',
+        'matchCriteria' => ['title' => 'address 2'],
+    ]);
+    $this->import->importItem($importer, ($this->userData)([$firstAddress, $newAddress]));
+
+    expect(Address::find()->ownerId($user->id)->count())->toBe(2);
+});
+
+it('skips empty or invalid address rows', function () {
+    $emptyAddress = ['title' => '', 'addressLine1' => ''];
+
+    $this->import->importItem($this->importer, ($this->userData)([$this->address, $emptyAddress, null, 'not-an-array']));
+
+    $user = UserElement::find()->username('importeduser')->one();
+
+    expect($user)->not()->toBeNull();
+    expect(Address::find()->ownerId($user->id)->count())->toBe(1);
+});
+
+it('does not create any addresses when the addresses key is absent', function () {
+    $data = ['username' => 'importeduser', 'email' => 'imported@example.com'];
+
+    $this->import->importItem($this->importer, $data);
+
+    $user = UserElement::find()->username('importeduser')->one();
+
+    expect($user)->not()->toBeNull();
+    expect(Address::find()->ownerId($user->id)->count())->toBe(0);
+});
diff --git a/tests/Feature/Import/ImportValidationTest.php b/tests/Feature/Import/ImportValidationTest.php
new file mode 100644
index 00000000000..af53fcbc1b4
--- /dev/null
+++ b/tests/Feature/Import/ImportValidationTest.php
@@ -0,0 +1,118 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Element\Import\ElementImporter;
+use CraftCms\Cms\Element\Import\ElementTransformer;
+use CraftCms\Cms\Entry\Elements\Entry as EntryElement;
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\FieldLayout\Models\FieldLayout;
+use CraftCms\Cms\Import\Data\Import as ImportData;
+use CraftCms\Cms\Import\Imports;
+use CraftCms\Cms\Support\Facades\Fields;
+use Illuminate\Support\Facades\Config;
+use Illuminate\Support\Facades\Validator;
+use Illuminate\Validation\ValidationException;
+
+it('getSettingsRules covers a step’s settings while getRules adds its file and transformer', function () {
+    $settingsRules = ElementImporter::getSettingsRules();
+    $fullRules = ElementImporter::getRules();
+
+    expect($settingsRules)->not->toHaveKey('file')
+        ->and($settingsRules)->not->toHaveKey('transformer')
+        ->and($settingsRules)->toHaveKeys(['settings.map', 'settings.site'])
+        ->and($fullRules)->toHaveKeys(['file', 'transformer', 'settings.map', 'settings.site']);
+});
+
+it('keeps the import’s own name and handle off the step rules', function () {
+    expect(ElementImporter::getRules())->not->toHaveKey('name')
+        ->and(ElementImporter::getRules())->not->toHaveKey('handle')
+        ->and(new ImportData()->getRules())->toHaveKeys(['name', 'handle', 'steps']);
+});
+
+it('validateSettings throws with settings-only errors for an ad-hoc importer missing file/site', function () {
+    $importer = EntryImporter::create();
+
+    try {
+        $importer->validateSettings();
+        expect(false)->toBeTrue('Expected a ValidationException to be thrown.');
+    } catch (ValidationException $e) {
+        expect($e->errors())->not->toHaveKey('file')
+            ->and($e->errors())->toHaveKey('settings.site')
+            ->and($e->errors())->not->toHaveKey('name')
+            ->and($e->errors())->not->toHaveKey('handle');
+    }
+});
+
+it('validate throws for a step missing its file', function () {
+    $importer = EntryImporter::create();
+
+    try {
+        $importer->validate();
+        expect(false)->toBeTrue('Expected a ValidationException to be thrown.');
+    } catch (ValidationException $e) {
+        expect($e->errors())->toHaveKey('file')
+            ->and($e->errors())->toHaveKey('settings.site');
+    }
+});
+
+it('validateSite fails for an invalid handle', function () {
+    $errors = Validator::make([
+        'settings' => ['site' => 'nonexistent-handle'],
+    ], ['settings.site' => ElementImporter::getSettingsRules()['settings.site']])->errors();
+
+    expect($errors)->toHaveKey('settings.site');
+});
+
+it('validateFieldLayout passes when the layout matches the element type', function () {
+    $fieldLayout = FieldLayout::factory()->create(['type' => EntryElement::class]);
+    Fields::refreshFields();
+
+    $errors = Validator::make([
+        'settings' => ['fieldLayout' => $fieldLayout->uid],
+    ], [
+        'settings.fieldLayout' => ElementImporter::getSettingsRules()['settings.fieldLayout'],
+    ])->errors();
+
+    expect($errors)->not->toHaveKey('settings.fieldLayout');
+});
+
+it('validateFieldLayout still passes the existence check when className is missing', function () {
+    $fieldLayout = FieldLayout::factory()->create(['type' => EntryElement::class]);
+    Fields::refreshFields();
+
+    $errors = Validator::make([
+        'settings' => ['fieldLayout' => $fieldLayout->uid],
+    ], ['settings.fieldLayout' => ElementImporter::getSettingsRules()['settings.fieldLayout']])->errors();
+
+    expect($errors)->not->toHaveKey('settings.fieldLayout');
+});
+
+it('validateTransformer still passes for a valid class, arrow function, and empty value, and fails for garbage', function () {
+    $rule = ElementImporter::getRules()['transformer'];
+
+    $passing = Validator::make(['transformer' => null], ['transformer' => $rule])->errors();
+    $passingClass = Validator::make(['transformer' => ElementTransformer::class], ['transformer' => $rule])->errors();
+    $passingArrowFn = Validator::make(['transformer' => 'fn ($element) => $element'], ['transformer' => $rule])->errors();
+    $failing = Validator::make(['transformer' => 'NotARealClass'], ['transformer' => $rule])->errors();
+
+    expect($passing)->not->toHaveKey('transformer')
+        ->and($passingClass)->not->toHaveKey('transformer')
+        ->and($passingArrowFn)->not->toHaveKey('transformer')
+        ->and($failing)->toHaveKey('transformer');
+});
+
+it('excludes an invalid file-based import from getAllImports', function () {
+    Config::set('craft.import', [
+        'invalidFileImport' => fn () => new ImportData()
+            ->name('Invalid File Import')
+            ->handle('invalidFileImport')
+            ->steps([]),
+    ]);
+
+    $imports = app(Imports::class);
+
+    expect($imports->getAllImports()->has('invalidFileImport'))->toBeFalse()
+        ->and($imports->getNonEditableImports()->has('invalidFileImport'))->toBeFalse()
+        ->and($imports->getImportByHandle('invalidFileImport'))->toBeNull();
+});
diff --git a/tests/Feature/Support/PathTest.php b/tests/Feature/Support/PathTest.php
index d2cde96c876..367ed83ed2f 100644
--- a/tests/Feature/Support/PathTest.php
+++ b/tests/Feature/Support/PathTest.php
@@ -215,6 +215,46 @@
         ->and(File::exists(dirname((string) $composerBackupPath).$ds.'.gitignore'))->toBeTrue();
 });
 
+test('normalizePath returns a normalized path with a trailing separator for an existing path', function () {
+    $ds = DIRECTORY_SEPARATOR;
+
+    expect(Path::normalizePath($this->sandboxPath))->toBe(File::normalizePath($this->sandboxPath).$ds);
+});
+
+test('normalizePath returns false for a nonexistent path', function () {
+    expect(Path::normalizePath($this->sandboxPath.DIRECTORY_SEPARATOR.'does-not-exist'))->toBeFalse();
+});
+
+test('normalizePath returns false for a false input', function () {
+    expect(Path::normalizePath(false))->toBeFalse();
+});
+
+test('isPathWithinRoots returns true immediately for a path under a temp-dir root', function () {
+    $tempRoot = $this->sandboxPath;
+    $path = $tempRoot.DIRECTORY_SEPARATOR.'foo.txt';
+
+    expect(Path::isPathWithinRoots($path, [[$tempRoot, true]]))->toBeTrue();
+});
+
+test('isPathWithinRoots returns false when the path matches no allowed root', function () {
+    $path = $this->sandboxPath.DIRECTORY_SEPARATOR.'foo.txt';
+
+    expect(Path::isPathWithinRoots($path, [[$this->aliases['@storage'], false]]))->toBeFalse();
+});
+
+test('isPathWithinRoots returns true for a path under a non-temp root that is not within any system dir', function () {
+    $path = $this->sandboxPath.DIRECTORY_SEPARATOR.'not-a-system-dir'.DIRECTORY_SEPARATOR.'foo.txt';
+    File::ensureDirectoryExists(dirname($path));
+
+    expect(Path::isPathWithinRoots($path, [[$this->sandboxPath, false]]))->toBeTrue();
+});
+
+test('isPathWithinRoots returns false for a path under a non-temp root that is also within a system dir', function () {
+    $path = $this->aliases['@tests'].DIRECTORY_SEPARATOR.'foo.txt';
+
+    expect(Path::isPathWithinRoots($path, [[$this->sandboxPath, false]]))->toBeFalse();
+});
+
 test('ensurePathIsContained', function (bool $expected, string $path) {
     expect(Path::ensurePathIsContained($path))->toBe($expected);
 })->with([
diff --git a/tests/Fixtures/Form/plain-text-settings.json b/tests/Fixtures/Form/plain-text-settings.json
index 39bcf57eeac..fdea1daf3d7 100644
--- a/tests/Fixtures/Form/plain-text-settings.json
+++ b/tests/Fixtures/Form/plain-text-settings.json
@@ -1,181 +1,185 @@
 {
-  "scope": ["settings"],
-  "refreshable": false,
-  "nodes": [
-    {
-      "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
-      "component": "craft:field",
-      "props": {
-        "label": "UI Mode",
-        "instructions": "How the field should be presented in the control panel.",
-        "required": false
-      },
-      "control": {
-        "type": "CraftCms\\Cms\\Form\\Controls\\Choice",
-        "component": "craft:choice",
-        "props": {
-          "options": [
-            {"label": "Normal", "value": "normal"},
-            {"label": "Enlarged", "value": "enlarged"}
-          ],
-          "multiple": false,
-          "presentation": "select"
-        },
-        "path": ["settings", "uiMode"],
-        "mode": "editable",
-        "deltaGroup": ["settings", "uiMode"]
-      }
-    },
-    {
-      "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
-      "component": "craft:field",
-      "props": {
-        "label": "Placeholder Text",
-        "instructions": "The text that will be shown if the field doesn’t have a value.",
-        "required": false
-      },
-      "control": {
-        "type": "CraftCms\\Cms\\Form\\Controls\\Text",
-        "component": "craft:text",
-        "props": [],
-        "path": ["settings", "placeholder"],
-        "mode": "editable",
-        "deltaGroup": ["settings", "placeholder"]
-      }
-    },
-    {
-      "type": "CraftCms\\Cms\\Form\\Nodes\\Group",
-      "component": "craft:group",
-      "props": {"label": "Field Limit"},
-      "uid": "plain-text-field-limit",
-      "children": [
+    "scope": ["settings"],
+    "refreshable": false,
+    "nodes": [
         {
-          "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
-          "component": "craft:field",
-          "props": {
-            "label": "Maximum",
-            "instructions": "The maximum number of characters or bytes the field is allowed to have.",
-            "required": false
-          },
-          "control": {
-            "type": "CraftCms\\Cms\\Form\\Controls\\Number",
-            "component": "craft:number",
-            "props": {"inputType": "number", "min": 1},
-            "path": ["settings", "fieldLimit"],
-            "mode": "editable",
-            "deltaGroup": ["settings"]
-          }
+            "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
+            "component": "craft:field",
+            "props": {
+                "label": "UI Mode",
+                "instructions": "How the field should be presented in the control panel.",
+                "required": false
+            },
+            "control": {
+                "type": "CraftCms\\Cms\\Form\\Controls\\Choice",
+                "component": "craft:choice",
+                "props": {
+                    "options": [
+                        {"label": "Normal", "value": "normal"},
+                        {"label": "Enlarged", "value": "enlarged"}
+                    ],
+                    "multiple": false,
+                    "presentation": "select"
+                },
+                "path": ["settings", "uiMode"],
+                "mode": "editable",
+                "deltaGroup": ["settings", "uiMode"]
+            }
         },
         {
-          "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
-          "component": "craft:field",
-          "props": {"label": "Unit", "instructions": null, "required": false},
-          "control": {
-            "type": "CraftCms\\Cms\\Form\\Controls\\Choice",
-            "component": "craft:choice",
+            "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
+            "component": "craft:field",
             "props": {
-              "options": [
-                {"label": "Characters", "value": "chars"},
-                {"label": "Bytes", "value": "bytes"}
-              ],
-              "multiple": false,
-              "presentation": "select"
+                "label": "Placeholder Text",
+                "instructions": "The text that will be shown if the field doesn’t have a value.",
+                "required": false
             },
-            "path": ["settings", "limitUnit"],
-            "mode": "editable",
-            "deltaGroup": ["settings"]
-          }
-        }
-      ]
-    },
-    {
-      "type": "CraftCms\\Cms\\Form\\Nodes\\Group",
-      "component": "craft:group",
-      "props": {"label": null},
-      "uid": "plain-text-behavior",
-      "children": [
+            "control": {
+                "type": "CraftCms\\Cms\\Form\\Controls\\Text",
+                "component": "craft:text",
+                "props": [],
+                "path": ["settings", "placeholder"],
+                "mode": "editable",
+                "deltaGroup": ["settings", "placeholder"]
+            }
+        },
+        {
+            "type": "CraftCms\\Cms\\Form\\Nodes\\Group",
+            "component": "craft:group",
+            "props": {"label": "Field Limit"},
+            "uid": "plain-text-field-limit",
+            "children": [
+                {
+                    "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
+                    "component": "craft:field",
+                    "props": {
+                        "label": "Maximum",
+                        "instructions": "The maximum number of characters or bytes the field is allowed to have.",
+                        "required": false
+                    },
+                    "control": {
+                        "type": "CraftCms\\Cms\\Form\\Controls\\Number",
+                        "component": "craft:number",
+                        "props": {"inputType": "number", "min": 1},
+                        "path": ["settings", "fieldLimit"],
+                        "mode": "editable",
+                        "deltaGroup": ["settings"]
+                    }
+                },
+                {
+                    "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
+                    "component": "craft:field",
+                    "props": {
+                        "label": "Unit",
+                        "instructions": null,
+                        "required": false
+                    },
+                    "control": {
+                        "type": "CraftCms\\Cms\\Form\\Controls\\Choice",
+                        "component": "craft:choice",
+                        "props": {
+                            "options": [
+                                {"label": "Characters", "value": "chars"},
+                                {"label": "Bytes", "value": "bytes"}
+                            ],
+                            "multiple": false,
+                            "presentation": "select"
+                        },
+                        "path": ["settings", "limitUnit"],
+                        "mode": "editable",
+                        "deltaGroup": ["settings"]
+                    }
+                }
+            ]
+        },
         {
-          "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
-          "component": "craft:field",
-          "props": {
-            "label": "Use a monospaced font",
-            "instructions": null,
-            "required": false
-          },
-          "control": {
-            "type": "CraftCms\\Cms\\Form\\Controls\\Lightswitch",
-            "component": "craft:lightswitch",
-            "props": [],
-            "path": ["settings", "code"],
-            "mode": "editable",
-            "deltaGroup": ["settings", "code"]
-          }
+            "type": "CraftCms\\Cms\\Form\\Nodes\\Group",
+            "component": "craft:group",
+            "props": {"label": null},
+            "uid": "plain-text-behavior",
+            "children": [
+                {
+                    "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
+                    "component": "craft:field",
+                    "props": {
+                        "label": "Use a monospaced font",
+                        "instructions": null,
+                        "required": false
+                    },
+                    "control": {
+                        "type": "CraftCms\\Cms\\Form\\Controls\\Lightswitch",
+                        "component": "craft:lightswitch",
+                        "props": [],
+                        "path": ["settings", "code"],
+                        "mode": "editable",
+                        "deltaGroup": ["settings", "code"]
+                    }
+                },
+                {
+                    "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
+                    "component": "craft:field",
+                    "props": {
+                        "label": "Allow line breaks",
+                        "instructions": null,
+                        "required": false
+                    },
+                    "control": {
+                        "type": "CraftCms\\Cms\\Form\\Controls\\Lightswitch",
+                        "component": "craft:lightswitch",
+                        "props": [],
+                        "path": ["settings", "multiline"],
+                        "mode": "editable",
+                        "deltaGroup": ["settings", "multiline"],
+                        "reactive": true
+                    }
+                }
+            ]
         },
         {
-          "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
-          "component": "craft:field",
-          "props": {
-            "label": "Allow line breaks",
-            "instructions": null,
-            "required": false
-          },
-          "control": {
-            "type": "CraftCms\\Cms\\Form\\Controls\\Lightswitch",
-            "component": "craft:lightswitch",
-            "props": [],
-            "path": ["settings", "multiline"],
-            "mode": "editable",
-            "deltaGroup": ["settings", "multiline"],
-            "reactive": true
-          }
+            "type": "CraftCms\\Cms\\Form\\Nodes\\Group",
+            "component": "craft:group",
+            "props": {
+                "label": null,
+                "dependsOn": ["settings", "multiline"]
+            },
+            "uid": "plain-text-multiline-settings",
+            "children": [
+                {
+                    "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
+                    "component": "craft:field",
+                    "props": {
+                        "label": "Initial Rows",
+                        "instructions": null,
+                        "required": false
+                    },
+                    "control": {
+                        "type": "CraftCms\\Cms\\Form\\Controls\\Number",
+                        "component": "craft:number",
+                        "props": {"inputType": "number", "min": 1},
+                        "path": ["settings", "initialRows"],
+                        "mode": "editable",
+                        "deltaGroup": ["settings", "initialRows"]
+                    }
+                }
+            ]
+        }
+    ],
+    "values": {
+        "settings": {
+            "uiMode": "enlarged",
+            "placeholder": "Submitted placeholder",
+            "fieldLimit": 120,
+            "limitUnit": "chars",
+            "code": true,
+            "multiline": true,
+            "initialRows": 8
         }
-      ]
     },
-    {
-      "type": "CraftCms\\Cms\\Form\\Nodes\\Group",
-      "component": "craft:group",
-      "props": {
-        "label": null,
-        "dependsOn": ["settings", "multiline"]
-      },
-      "uid": "plain-text-multiline-settings",
-      "children": [
+    "errors": [
         {
-          "type": "CraftCms\\Cms\\Form\\Nodes\\Field",
-          "component": "craft:field",
-          "props": {
-            "label": "Initial Rows",
-            "instructions": null,
-            "required": false
-          },
-          "control": {
-            "type": "CraftCms\\Cms\\Form\\Controls\\Number",
-            "component": "craft:number",
-            "props": {"inputType": "number", "min": 1},
-            "path": ["settings", "initialRows"],
-            "mode": "editable",
-            "deltaGroup": ["settings", "initialRows"]
-          }
+            "path": ["settings", "placeholder"],
+            "messages": ["Placeholder is invalid."]
         }
-      ]
-    }
-  ],
-  "values": {
-    "settings": {
-      "uiMode": "enlarged",
-      "placeholder": "Submitted placeholder",
-      "fieldLimit": 120,
-      "limitUnit": "chars",
-      "code": true,
-      "multiline": true,
-      "initialRows": 8
-    }
-  },
-  "errors": [
-    {
-      "path": ["settings", "placeholder"],
-      "messages": ["Placeholder is invalid."]
-    }
-  ],
-  "globalErrors": ["The settings could not be saved."]
+    ],
+    "globalErrors": ["The settings could not be saved."]
 }
diff --git a/tests/Fixtures/Import/broken.json b/tests/Fixtures/Import/broken.json
new file mode 100644
index 00000000000..dfb959e4483
--- /dev/null
+++ b/tests/Fixtures/Import/broken.json
@@ -0,0 +1 @@
+[{"title": "unterminated"
diff --git a/tests/Fixtures/Import/empty.json b/tests/Fixtures/Import/empty.json
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/Fixtures/Import/entries-matrix-in-matrix.json b/tests/Fixtures/Import/entries-matrix-in-matrix.json
new file mode 100644
index 00000000000..c580adb06d0
--- /dev/null
+++ b/tests/Fixtures/Import/entries-matrix-in-matrix.json
@@ -0,0 +1,31 @@
+[
+    {
+        "sectionId": "fixtureSection",
+        "typeId": "fixtureType",
+        "title": "file entry with matrix in matrix",
+        "myMatrix": [
+            {
+                "type": "outerEt",
+                "title": "file outer block",
+                "fields": {
+                    "myNestedMatrix": [
+                        {
+                            "type": "blockEt",
+                            "title": "file inner block 1",
+                            "fields": {
+                                "plainText": "inner one"
+                            }
+                        },
+                        {
+                            "type": "blockEt",
+                            "title": "file inner block 2",
+                            "fields": {
+                                "plainText": "inner two"
+                            }
+                        }
+                    ]
+                }
+            }
+        ]
+    }
+]
diff --git a/tests/Fixtures/Import/entries-matrix.json b/tests/Fixtures/Import/entries-matrix.json
new file mode 100644
index 00000000000..3662314fdac
--- /dev/null
+++ b/tests/Fixtures/Import/entries-matrix.json
@@ -0,0 +1,23 @@
+[
+    {
+        "sectionId": "fixtureSection",
+        "typeId": "fixtureType",
+        "title": "file entry with matrix",
+        "myMatrix": [
+            {
+                "type": "blockEt",
+                "title": "file block 1",
+                "fields": {
+                    "plainText": "block one"
+                }
+            },
+            {
+                "type": "blockEt",
+                "title": "file block 2",
+                "fields": {
+                    "plainText": "block two"
+                }
+            }
+        ]
+    }
+]
diff --git a/tests/Fixtures/Import/entries-plain-text-updated.json b/tests/Fixtures/Import/entries-plain-text-updated.json
new file mode 100644
index 00000000000..0bfce14d716
--- /dev/null
+++ b/tests/Fixtures/Import/entries-plain-text-updated.json
@@ -0,0 +1,21 @@
+[
+    {
+        "sectionId": "fixtureSection",
+        "typeId": "fixtureType",
+        "title": "first file entry",
+        "plainText": "UPDATED text from the file"
+    },
+    {
+        "sectionId": "fixtureSection",
+        "typeId": "fixtureType",
+        "title": "second file entry",
+        "plainText": "UPDATED more text from the file",
+        "slug": "second-file-entry-slug"
+    },
+    {
+        "sectionId": "fixtureSection",
+        "typeId": "fixtureType",
+        "title": "third file entry",
+        "plainText": "UPDATED even more text from the file"
+    }
+]
diff --git a/tests/Fixtures/Import/entries-plain-text.json b/tests/Fixtures/Import/entries-plain-text.json
new file mode 100644
index 00000000000..b793532a6a0
--- /dev/null
+++ b/tests/Fixtures/Import/entries-plain-text.json
@@ -0,0 +1,21 @@
+[
+    {
+        "sectionId": "fixtureSection",
+        "typeId": "fixtureType",
+        "title": "first file entry",
+        "plainText": "text from the file"
+    },
+    {
+        "sectionId": "fixtureSection",
+        "typeId": "fixtureType",
+        "title": "second file entry",
+        "plainText": "more text from the file",
+        "slug": "second-file-entry-slug"
+    },
+    {
+        "sectionId": "fixtureSection",
+        "typeId": "fixtureType",
+        "title": "third file entry",
+        "plainText": "even more text from the file"
+    }
+]
diff --git a/tests/Fixtures/Import/entries.csv b/tests/Fixtures/Import/entries.csv
new file mode 100644
index 00000000000..c88df68f8af
--- /dev/null
+++ b/tests/Fixtures/Import/entries.csv
@@ -0,0 +1,3 @@
+sectionId,typeId,title,plainText
+fixtureSection,fixtureType,first csv entry,csv text one
+fixtureSection,fixtureType,second csv entry,csv text two
diff --git a/tests/Fixtures/Import/entries.xml b/tests/Fixtures/Import/entries.xml
new file mode 100644
index 00000000000..2d8091e8b9d
--- /dev/null
+++ b/tests/Fixtures/Import/entries.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<entries>
+    <entry>
+        <sectionId>fixtureSection</sectionId>
+        <typeId>fixtureType</typeId>
+        <title>first xml entry</title>
+        <plainText>xml text one</plainText>
+    </entry>
+    <entry>
+        <sectionId>fixtureSection</sectionId>
+        <typeId>fixtureType</typeId>
+        <title>second xml entry</title>
+        <plainText>xml text two</plainText>
+    </entry>
+</entries>
diff --git a/tests/Fixtures/Import/single-object.json b/tests/Fixtures/Import/single-object.json
new file mode 100644
index 00000000000..528911becb1
--- /dev/null
+++ b/tests/Fixtures/Import/single-object.json
@@ -0,0 +1,6 @@
+{
+    "sectionId": "fixtureSection",
+    "typeId": "fixtureType",
+    "title": "single object entry",
+    "plainText": "not wrapped in a list"
+}
diff --git a/tests/Fixtures/Import/unsupported.txt b/tests/Fixtures/Import/unsupported.txt
new file mode 100644
index 00000000000..df40187ec4f
--- /dev/null
+++ b/tests/Fixtures/Import/unsupported.txt
@@ -0,0 +1 @@
+not import data
diff --git a/tests/Support/ImportFixtures.php b/tests/Support/ImportFixtures.php
new file mode 100644
index 00000000000..0cbc244fad8
--- /dev/null
+++ b/tests/Support/ImportFixtures.php
@@ -0,0 +1,129 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CraftCms\Cms\Tests\Support;
+
+use CraftCms\Cms\Entry\Models\Entry;
+use CraftCms\Cms\Entry\Models\EntryType;
+use CraftCms\Cms\Field\Matrix;
+use CraftCms\Cms\Field\Models\Field;
+use CraftCms\Cms\Field\PlainText;
+use CraftCms\Cms\FieldLayout\LayoutElements\CustomField;
+use CraftCms\Cms\FieldLayout\LayoutElements\Entries\EntryTitleField;
+use CraftCms\Cms\FieldLayout\Models\FieldLayout;
+use CraftCms\Cms\Import\Import;
+use CraftCms\Cms\Import\Importers\BaseImporter;
+use CraftCms\Cms\Section\Models\Section;
+use CraftCms\Cms\Support\Facades\EntryTypes;
+use CraftCms\Cms\Support\Facades\Fields;
+use CraftCms\Cms\Support\ImportHelper;
+use CraftCms\Cms\Support\Str;
+
+final class ImportFixtures
+{
+    /**
+     * Builds a field layout (title + given layout elements), an EntryType wrapping it, a
+     * Section for that EntryType, and seeds one Entry through the Import-safe factory path.
+     */
+    public static function seedEntry(
+        array $layoutElements,
+        array $entryTypeAttrs = [],
+        array $sectionAttrs = ['minAuthors' => 0],
+        array $entryAttrs = [],
+    ): object {
+        $entryType = self::entryTypeWithTitle($layoutElements, array_merge([
+            'name' => 'Seed Type',
+            'handle' => 'seedType',
+        ], $entryTypeAttrs));
+
+        $fieldLayout = $entryType->fieldLayout;
+
+        $section = Section::factory()->withEntryTypes($entryType)->create($sectionAttrs);
+
+        $result = Entry::factory()
+            ->forSection($section)
+            ->forEntryType($entryType)
+            ->withFieldLayout($fieldLayout)
+            ->createElementWithFields(array_merge([
+                'title' => 'seed entry',
+                'slug' => 'seed-entry',
+            ], $entryAttrs));
+
+        return (object) [
+            'fieldLayout' => $fieldLayout,
+            'entryType' => $entryType,
+            'section' => $section,
+            'entry' => $result->element,
+        ];
+    }
+
+    /**
+     * Imports one item with the importer's own matchCriteria resolved and passed in, the way
+     * Import::Import(), the Import job and the Import commands all do. Calling
+     * Import::importItem() without that third argument silently ignores config-level criteria.
+     */
+    public static function importWithConfigCriteria(Import $import, BaseImporter $importer, array $data): void
+    {
+        $import->importItem($importer, $data, ImportHelper::normalizeMatchCriteriaFromImporterConfig($importer));
+    }
+
+    /**
+     * An EntryType with a required title field element plus the given layout elements.
+     */
+    public static function entryTypeWithTitle(array $layoutElements = [], array $attrs = []): EntryType
+    {
+        $fieldLayout = FieldLayout::factory()
+            ->withContentTab([
+                new EntryTitleField(['uid' => Str::uuid()->toString(), 'required' => true]),
+                ...$layoutElements,
+            ])
+            ->create();
+
+        return EntryType::factory()
+            ->withFieldLayout($fieldLayout)
+            ->create(array_merge([
+                'name' => 'With Title',
+                'handle' => 'withTitle',
+                'hasTitleField' => true,
+            ], $attrs));
+    }
+
+    /** A PlainText field with the given handle. */
+    public static function plainTextField(string $handle, ?string $name = null): Field
+    {
+        return Field::factory()->create([
+            'name' => $name ?? $handle,
+            'handle' => $handle,
+            'type' => PlainText::class,
+        ]);
+    }
+
+    /** An EntryType usable as a Matrix block type, carrying the given fields. */
+    public static function blockEntryType(string $handle, array $fields, ?string $name = null): EntryType
+    {
+        $fieldLayout = FieldLayout::factory()
+            ->withContentTab(array_map(fn (Field $field) => new CustomField(config: ['fieldUid' => $field->uid]), $fields))
+            ->create();
+
+        return EntryType::factory()
+            ->withFieldLayout($fieldLayout)
+            ->create(['name' => $name ?? $handle, 'handle' => $handle, 'hasTitleField' => true]);
+    }
+
+    /** A Matrix field restricted to the given block entry types. Refreshes entry-type/field caches. */
+    public static function matrixField(string $handle, array $entryTypes, ?string $name = null): Field
+    {
+        $field = Field::factory()->create([
+            'name' => $name ?? $handle,
+            'handle' => $handle,
+            'type' => Matrix::class,
+            'settings' => ['entryTypes' => array_map(fn (EntryType $et) => $et->id, $entryTypes)],
+        ]);
+
+        EntryTypes::refreshEntryTypes();
+        Fields::refreshFields();
+
+        return $field;
+    }
+}
diff --git a/tests/Unit/Asset/AssetsHelperTest.php b/tests/Unit/Asset/AssetsHelperTest.php
index bcd0d1ba0bc..594337832c8 100644
--- a/tests/Unit/Asset/AssetsHelperTest.php
+++ b/tests/Unit/Asset/AssetsHelperTest.php
@@ -8,7 +8,9 @@
 use CraftCms\Cms\Asset\Events\SetAssetFilename;
 use CraftCms\Cms\Cms;
 use CraftCms\Cms\Support\Path;
+use Illuminate\Http\Client\RequestException;
 use Illuminate\Support\Facades\Event;
+use Illuminate\Support\Facades\Http;
 
 beforeEach(function () {
     Cms::setIsInstalled(false);
@@ -516,6 +518,47 @@
     });
 });
 
+describe('downloadUrl', function () {
+    test('throws for a URL with a disallowed hostname, without making a request', function () {
+        Http::fake();
+
+        expect(fn () => AssetsHelper::downloadUrl('http://127.0.0.1/file.txt', AssetsHelper::tempFilePath()))
+            ->toThrow(InvalidArgumentException::class);
+
+        Http::assertNothingSent();
+    });
+
+    test('throws for a URL with an invalid scheme, without making a request', function () {
+        Http::fake();
+
+        expect(fn () => AssetsHelper::downloadUrl('file:///etc/passwd', AssetsHelper::tempFilePath()))
+            ->toThrow(InvalidArgumentException::class);
+
+        Http::assertNothingSent();
+    });
+
+    test('downloads a remote file to the given temp path', function () {
+        Http::fake([
+            'example.com/*' => Http::response('hello from the internet'),
+        ]);
+
+        $tempPath = AssetsHelper::tempFilePath();
+
+        AssetsHelper::downloadUrl('http://example.com/file.txt', $tempPath);
+
+        expect(file_get_contents($tempPath))->toBe('hello from the internet');
+    });
+
+    test('does not swallow a failed response', function () {
+        Http::fake([
+            'example.com/*' => Http::response('not found', 404),
+        ]);
+
+        expect(fn () => AssetsHelper::downloadUrl('http://example.com/missing.txt', AssetsHelper::tempFilePath()))
+            ->toThrow(RequestException::class);
+    });
+});
+
 describe('INDEX_SKIP_ITEMS_PATTERN', function () {
     test('matches system files that should be skipped', function (string $path) {
         expect(preg_match(AssetsHelper::INDEX_SKIP_ITEMS_PATTERN, $path))->toBe(1);
diff --git a/tests/Unit/Import/CsvDataTypeTest.php b/tests/Unit/Import/CsvDataTypeTest.php
new file mode 100644
index 00000000000..1e9d390f8bc
--- /dev/null
+++ b/tests/Unit/Import/CsvDataTypeTest.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Import\DataTypes\Csv;
+
+/** CSV carries flat rows only - format() zips each row against the heading row. */
+const CSV = <<<'CSVDATA'
+title,plainText
+first entry,text one
+second entry,text two
+CSVDATA;
+
+// format()
+
+it('formats CSV rows keyed by the heading row', function () {
+    $result = Csv::format(CSV);
+
+    expect($result['success'])->toBeTrue()
+        ->and($result['data'])->toBe([
+            ['title' => 'first entry', 'plainText' => 'text one'],
+            ['title' => 'second entry', 'plainText' => 'text two'],
+        ]);
+});
+
+it('formats a heading-only CSV into no rows', function () {
+    $result = Csv::format("title,plainText\n");
+
+    expect($result['success'])->toBeTrue()
+        ->and($result['data'])->toBe([]);
+});
+
+it('reads a quoted value containing a comma as one field', function () {
+    $result = Csv::format("title,plainText\n\"first, entry\",text one");
+
+    expect($result['data'][0]['title'])->toBe('first, entry');
+});
+
+// getHeadings()
+
+it('returns the heading row as sorted label/value pairs, each hinting at its first value', function () {
+    $result = Csv::getHeadings(CSV);
+
+    expect($result)->toBe([
+        ['label' => 'plainText', 'value' => 'plainText', 'data' => ['hint' => 'text one']],
+        ['label' => 'title', 'value' => 'title', 'data' => ['hint' => 'first entry']],
+    ]);
+});
diff --git a/tests/Unit/Import/ImportHelperTest.php b/tests/Unit/Import/ImportHelperTest.php
new file mode 100644
index 00000000000..82c24a660b4
--- /dev/null
+++ b/tests/Unit/Import/ImportHelperTest.php
@@ -0,0 +1,519 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Support\ImportHelper;
+
+it('returns an empty array when the field layout is null', function () {
+    $result = ImportHelper::getDestinationColsForFieldLayout(null);
+
+    expect($result)->toBe([]);
+});
+
+// decodeRecursive
+
+it('decodes a JSON-encoded string into an array', function () {
+    expect(ImportHelper::decodeRecursive('["a","b"]'))->toBe(['a', 'b']);
+});
+
+it('decodes each JSON-encoded string element inside an array', function () {
+    expect(ImportHelper::decodeRecursive(['["a","b"]', '["c","d"]']))->toBe([['a', 'b'], ['c', 'd']]);
+});
+
+it('recursively decodes a JSON-encoded string element inside an array', function () {
+    expect(ImportHelper::decodeRecursive(['["a","b"]']))->toBe([['a', 'b']]);
+});
+
+it('unpacks a JSON-encoded falsy value instead of leaving it as a string', function () {
+    expect(ImportHelper::decodeRecursive(['flag' => 'false', 'count' => '0']))->toBe(['flag' => false, 'count' => 0]);
+});
+
+// getPrefixedHandlesForMapping – fifth return value
+
+it('returns the handle split into path-part segments as the fifth return value', function () {
+    [,,,, $parts] = ImportHelper::getPrefixedHandlesForMapping('title', null, null, null, null);
+
+    expect($parts)->toBe(['title']);
+});
+
+// remapData – scalar rules
+
+it('renames a top-level key', function () {
+    $result = ImportHelper::remapData(['b' => 'a'], ['a' => 1]);
+
+    expect($result)->toBe(['b' => 1]);
+});
+
+it('leaves unmapped keys in the output', function () {
+    $result = ImportHelper::remapData(['b' => 'a'], ['a' => 1, 'c' => 2]);
+
+    expect($result)->toBe(['b' => 1, 'c' => 2]);
+});
+
+it('doesn’t set a key when the rule is null', function () {
+    $result = ImportHelper::remapData(['b' => null], ['a' => 1]);
+
+    expect(array_keys($result))->not()->toContain('b');
+    expect($result['a'])->toBe(1);
+});
+
+it('sets a key to an empty string when the rule is the sentinel \'""\'', function () {
+    $result = ImportHelper::remapData(['b' => '""'], ['a' => 1]);
+
+    expect($result['b'])->toBe('');
+});
+
+it('maps a missing source path to null', function () {
+    $result = ImportHelper::remapData(['b' => 'missing'], ['a' => 1]);
+
+    expect($result['b'])->toBeNull();
+    expect($result['a'])->toBe(1);
+});
+
+// remapData – nested objects
+
+it('maps a nested sub-object when leaves share a common path prefix', function () {
+    $data = ['address' => ['street' => '123 Main St', 'city' => 'Boston']];
+    $map = ['location' => ['street' => 'address.street', 'city' => 'address.city']];
+
+    $result = ImportHelper::remapData($map, $data);
+
+    expect($result['location'])->toBe(['street' => '123 Main St', 'city' => 'Boston']);
+    expect($result)->not()->toHaveKey('address');
+});
+
+it('keeps unused keys inside a mapped nested object', function () {
+    $data = ['address' => ['street' => '123 Main St', 'city' => 'Boston', 'zip' => '02101']];
+    $map = ['location' => ['street' => 'address.street', 'city' => 'address.city']];
+
+    $result = ImportHelper::remapData($map, $data);
+
+    expect($result['location']['zip'])->toBe('02101');
+});
+
+// remapData – list of rows
+
+it('applies the map to each row when the source resolves to a list', function () {
+    $data = ['items' => [['name' => 'Alice', 'age' => 30], ['name' => 'Bob', 'age' => 25]]];
+    $map = ['people' => ['fullName' => 'items.name', 'years' => 'items.age']];
+
+    $result = ImportHelper::remapData($map, $data);
+
+    expect($result['people'])->toBe([
+        ['fullName' => 'Alice', 'years' => 30],
+        ['fullName' => 'Bob', 'years' => 25],
+    ]);
+});
+
+it('passes non-array rows inside a list through unchanged', function () {
+    $data = ['tags' => ['php', 'laravel']];
+    $map = ['keywords' => ['upper' => 'tags.upper']];
+
+    $result = ImportHelper::remapData($map, $data);
+
+    expect($result['keywords'])->toBe(['php', 'laravel']);
+});
+
+// remapData – block-type containers
+
+it('flattens a block-type container into a flat list with a type key on each row', function () {
+    $data = [
+        'blocks' => [
+            'heading' => [['text' => 'Hello']],
+            'text' => [['body' => 'Content']],
+        ],
+    ];
+    $map = [
+        'blocks' => [
+            'heading' => ['title' => 'blocks.heading.text'],
+            'text' => ['content' => 'blocks.text.body'],
+        ],
+    ];
+
+    $result = ImportHelper::remapData($map, $data);
+
+    expect($result['blocks'])->toBe([
+        ['type' => 'heading', 'title' => 'Hello'],
+        ['type' => 'text', 'content' => 'Content'],
+    ]);
+});
+
+it('omits items for block types present in source but absent from the map', function () {
+    $data = [
+        'blocks' => [
+            'heading' => [['text' => 'Hello']],
+            'image' => [['url' => 'img.png']],
+        ],
+    ];
+    $map = [
+        'blocks' => [
+            'heading' => ['title' => 'blocks.heading.text'],
+        ],
+    ];
+
+    $result = ImportHelper::remapData($map, $data);
+
+    expect($result['blocks'])->toHaveCount(1);
+    expect($result['blocks'][0]['type'])->toBe('heading');
+});
+
+it('produces no items for block types in the map that are absent from source', function () {
+    $data = [
+        'blocks' => [
+            'heading' => [['text' => 'Hello']],
+        ],
+    ];
+    $map = [
+        'blocks' => [
+            'heading' => ['title' => 'blocks.heading.text'],
+            'missing' => ['content' => 'blocks.missing.body'],
+        ],
+    ];
+
+    $result = ImportHelper::remapData($map, $data);
+
+    expect($result['blocks'])->toHaveCount(1)
+        ->and($result['blocks'][0]['type'])->toBe('heading');
+});
+
+it('dispatches each row of a nested inline-typed container to only its matching sibling type', function () {
+    $data = [
+        'fields' => [
+            'plainText' => 'foo3',
+            'innerMatrix' => [
+                ['type' => 'simple2', 'title' => 'nested 1', 'fields' => ['plainText' => 'bar']],
+                ['type' => 'simple', 'title' => 'nested 2', 'fields' => ['plainText' => 'baz'], 'matchCriteria' => ['title' => 'title']],
+            ],
+        ],
+    ];
+    $map = [
+        'fields' => [
+            'plainText' => null,
+            'innerMatrix' => [
+                'simple' => ['title' => 'fields.innerMatrix.title', 'fields' => ['plainText' => 'fields.innerMatrix.fields.plainText']],
+                'simple2' => ['title' => 'fields.innerMatrix.title', 'fields' => ['plainText' => 'fields.innerMatrix.fields.plainText']],
+            ],
+        ],
+    ];
+
+    $result = ImportHelper::remapData($map, $data);
+
+    expect($result['fields']['innerMatrix'])->toBe([
+        ['type' => 'simple2', 'title' => 'nested 1', 'fields' => ['plainText' => 'bar']],
+        ['type' => 'simple', 'title' => 'nested 2', 'fields' => ['plainText' => 'baz'], 'matchCriteria' => ['title' => 'title']],
+    ]);
+});
+
+it('keeps a nested container field keyed under fields when the block type maps no other field', function () {
+    $map = [
+        'matrixOuter' => [
+            'withMatrix' => [
+                'title' => 'matrixOuter.title',
+                'fields' => [
+                    'matrixInner' => [
+                        'withPlainText' => [
+                            'title' => 'matrixOuter.fields.matrixInner.title',
+                            'fields' => [
+                                'plainText' => 'matrixOuter.fields.matrixInner.fields.plainText',
+                                'plainText2' => 'matrixOuter.fields.matrixInner.fields.plainText2',
+                            ],
+                        ],
+                    ],
+                ],
+            ],
+        ],
+    ];
+    $data = [
+        'matrixOuter' => [
+            [
+                'type' => 'withMatrix',
+                'matchCriteria' => ['title' => 'title'],
+                'title' => 'outer matrix 1',
+                'fields' => [
+                    'matrixInner' => [
+                        [
+                            'type' => 'withPlainText',
+                            'matchCriteria' => ['title' => 'title'],
+                            'title' => 'inner matrix entry',
+                            'fields' => ['plainText' => 'foo', 'plainText2' => 'bar'],
+                        ],
+                    ],
+                ],
+            ],
+        ],
+    ];
+
+    $result = ImportHelper::remapData($map, $data);
+
+    expect($result['matrixOuter'])->toBe([
+        [
+            'type' => 'withMatrix',
+            'title' => 'outer matrix 1',
+            'fields' => [
+                'matrixInner' => [
+                    [
+                        'type' => 'withPlainText',
+                        'title' => 'inner matrix entry',
+                        'fields' => ['plainText' => 'foo', 'plainText2' => 'bar'],
+                        'matchCriteria' => ['title' => 'title'],
+                    ],
+                ],
+            ],
+            'matchCriteria' => ['title' => 'title'],
+        ],
+    ]);
+});
+
+it('still flattens a grouped-by-type nested container inside a block\'s fields', function () {
+    $map = [
+        'matrixOuter' => [
+            'withMatrix' => [
+                'title' => 'matrixOuter.title',
+                'fields' => [
+                    'matrixInner' => [
+                        'withPlainText' => [
+                            'title' => 'matrixOuter.fields.matrixInner.withPlainText.title',
+                            'fields' => ['plainText' => 'matrixOuter.fields.matrixInner.withPlainText.plainText'],
+                        ],
+                    ],
+                ],
+            ],
+        ],
+    ];
+    $data = [
+        'matrixOuter' => [
+            [
+                'type' => 'withMatrix',
+                'title' => 'outer matrix 1',
+                'fields' => [
+                    'matrixInner' => [
+                        'withPlainText' => [
+                            ['title' => 'inner matrix entry', 'plainText' => 'foo'],
+                        ],
+                    ],
+                ],
+            ],
+        ],
+    ];
+
+    $result = ImportHelper::remapData($map, $data);
+
+    expect($result['matrixOuter'][0]['fields']['matrixInner'])->toBe([
+        [
+            'type' => 'withPlainText',
+            'title' => 'inner matrix entry',
+            'fields' => ['plainText' => 'foo'],
+        ],
+    ]);
+});
+
+// suggestMapValues
+
+it('suggests a source column that exactly matches the destination handle', function () {
+    $destinationCols = [['handle' => 'myContent', 'prefixedHandleAsArray' => ['myContent']]];
+    $sourceDataCols = [['label' => 'Please select', 'value' => ''], ['label' => 'myContent', 'value' => 'myContent']];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, []);
+
+    expect($result)->toBe(['myContent' => 'myContent']);
+});
+
+it('suggests a source column whose normalized handle matches, even when spelled differently', function () {
+    $destinationCols = [['handle' => 'myContent', 'prefixedHandleAsArray' => ['myContent']]];
+    $sourceDataCols = [['label' => 'My Content', 'value' => 'My Content']];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, []);
+
+    expect($result)->toBe(['myContent' => 'My Content']);
+});
+
+it('leaves a destination column unmapped when no source column matches', function () {
+    $destinationCols = [['handle' => 'myContent', 'prefixedHandleAsArray' => ['myContent']]];
+    $sourceDataCols = [['label' => 'unrelated', 'value' => 'unrelated']];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, []);
+
+    expect($result)->toBe([]);
+});
+
+it('suggests nothing for a destination the map already has a value for', function () {
+    $destinationCols = [['handle' => 'myContent', 'prefixedHandleAsArray' => ['myContent']]];
+    $sourceDataCols = [['label' => 'myContent', 'value' => 'myContent']];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, ['myContent' => 'alreadyMapped']);
+
+    expect($result)->toBe([]);
+});
+
+it('skips container columns since they have no value of their own', function () {
+    $destinationCols = [['handle' => 'matrixField', 'prefixedHandleAsArray' => ['matrixField'], 'isContainer' => true]];
+    $sourceDataCols = [['label' => 'matrixField', 'value' => 'matrixField']];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, []);
+
+    expect($result)->toBe([]);
+});
+
+it('recurses into a MappingColSet\'s subfields', function () {
+    $destinationCols = [
+        [
+            'multiple' => true,
+            'subfields' => [
+                ['handle' => 'lat', 'prefixedHandleAsArray' => ['location', 'lat']],
+                ['handle' => 'lng', 'prefixedHandleAsArray' => ['location', 'lng']],
+            ],
+        ],
+    ];
+    $sourceDataCols = [['label' => 'lat', 'value' => 'lat'], ['label' => 'lng', 'value' => 'lng']];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, []);
+
+    expect($result)->toBe(['location' => ['lat' => 'lat', 'lng' => 'lng']]);
+});
+
+it('suggests a nested leaf without repeating a sibling the map already has', function () {
+    $destinationCols = [['handle' => 'city', 'prefixedHandleAsArray' => ['address', 'city']]];
+    $sourceDataCols = [['label' => 'city', 'value' => 'city']];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, ['address' => ['street' => 'streetCol']]);
+
+    expect($result)->toBe(['address' => ['city' => 'city']]);
+});
+
+it('prefers the source column that matches the destination\'s whole path over a bare handle match', function () {
+    $destinationCols = [
+        ['handle' => 'title', 'prefixedHandleAsArray' => ['title']],
+        ['handle' => 'title', 'prefixedHandleAsArray' => ['outerMatrix', 'withText', 'title']],
+    ];
+    $sourceDataCols = [
+        ['label' => 'title', 'value' => 'title'],
+        ['label' => 'outerMatrix.withText.title', 'value' => 'outerMatrix.withText.title'],
+    ];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, []);
+
+    // the more specific match is assigned (and so keyed) first
+    expect($result)->toBe([
+        'outerMatrix' => ['withText' => ['title' => 'outerMatrix.withText.title']],
+        'title' => 'title',
+    ]);
+});
+
+it('gives a source column that matches a destination\'s whole path to that destination alone', function () {
+    $destinationCols = [
+        ['handle' => 'title', 'prefixedHandleAsArray' => ['title']],
+        ['handle' => 'title', 'prefixedHandleAsArray' => ['outerMatrix', 'withText', 'title']],
+    ];
+    $sourceDataCols = [['label' => 'title', 'value' => 'title']];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, []);
+
+    expect($result)->toBe(['title' => 'title']);
+});
+
+it('falls back to a source column that only matches the tail of a nested destination\'s path', function () {
+    $destinationCols = [
+        ['handle' => 'title', 'prefixedHandleAsArray' => ['title']],
+        ['handle' => 'title', 'prefixedHandleAsArray' => ['outerMatrix', 'withText', 'title']],
+    ];
+    $sourceDataCols = [['label' => 'withText.title', 'value' => 'withText.title']];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, []);
+
+    expect($result)->toBe([
+        'outerMatrix' => ['withText' => ['title' => 'withText.title']],
+    ]);
+});
+
+it('reuses a partially matched source column across every entry type that wants it', function () {
+    $destinationCols = [
+        ['handle' => 'title', 'prefixedHandleAsArray' => ['outerMatrix', 'withText', 'title']],
+        ['handle' => 'title', 'prefixedHandleAsArray' => ['outerMatrix', 'withImage', 'title']],
+    ];
+    $sourceDataCols = [['label' => 'title', 'value' => 'title']];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, []);
+
+    expect($result)->toBe([
+        'outerMatrix' => [
+            'withText' => ['title' => 'title'],
+            'withImage' => ['title' => 'title'],
+        ],
+    ]);
+});
+
+it('matches a source column that names only some of the destination\'s path segments', function () {
+    $destinationCols = [
+        ['handle' => 'plainText', 'prefixedHandleAsArray' => ['outerMatrix', 'withText', 'fields', 'plainText']],
+    ];
+    // no `fields`, no entry type — the segments just have to line up in order
+    $sourceDataCols = [['label' => 'outerMatrix.plainText', 'value' => 'outerMatrix.plainText']];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, []);
+
+    expect($result)->toBe([
+        'outerMatrix' => ['withText' => ['fields' => ['plainText' => 'outerMatrix.plainText']]],
+    ]);
+});
+
+it('does not match a source column whose last segment isn\'t the destination\'s own handle', function () {
+    $destinationCols = [
+        ['handle' => 'plainText', 'prefixedHandleAsArray' => ['outerMatrix', 'withText', 'fields', 'plainText']],
+    ];
+    $sourceDataCols = [
+        ['label' => 'outerMatrix.fields', 'value' => 'outerMatrix.fields'],
+        ['label' => 'outerMatrix.fields.plainText2', 'value' => 'outerMatrix.fields.plainText2'],
+    ];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, []);
+
+    expect($result)->toBe([]);
+});
+
+it('never suggests a match criteria column, which belongs to a different tree', function () {
+    $destinationCols = [
+        ['handle' => 'title', 'prefixedHandleAsArray' => ['matrixOuter', 'withMatrix', 'title']],
+    ];
+    $sourceDataCols = [[
+        'label' => 'matrixOuter.matchCriteria.title',
+        'value' => 'matrixOuter.matchCriteria.title',
+    ]];
+
+    $result = ImportHelper::suggestMapValues($destinationCols, $sourceDataCols, []);
+
+    expect($result)->toBe([]);
+});
+
+// remapData – path resolution
+
+it('resolves a rule path relative to the current base path', function () {
+    $data = [
+        'rows' => [
+            ['orig' => 'Alice'],
+            ['orig' => 'Bob'],
+        ],
+    ];
+    $map = ['rows' => ['name' => 'rows.orig']];
+
+    $result = ImportHelper::remapData($map, $data);
+
+    expect($result['rows'][0]['name'])->toBe('Alice');
+    expect($result['rows'][1]['name'])->toBe('Bob');
+});
+
+it('falls back to root data when the rule path does not start with the current base path', function () {
+    $data = [
+        'meta' => ['author' => 'Craft'],
+        'items' => [['title' => 'Entry 1']],
+    ];
+    $map = [
+        'items' => [
+            'title' => 'items.title',
+            'source' => 'meta.author',
+        ],
+    ];
+
+    $result = ImportHelper::remapData($map, $data);
+
+    expect($result['items'][0]['source'])->toBe('Craft');
+});
diff --git a/tests/Unit/Import/ImportKeepMissingNestedElementsTest.php b/tests/Unit/Import/ImportKeepMissingNestedElementsTest.php
new file mode 100644
index 00000000000..0f9f4b25db1
--- /dev/null
+++ b/tests/Unit/Import/ImportKeepMissingNestedElementsTest.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Entry\Import\EntryImporter;
+use CraftCms\Cms\Field\Addresses;
+use CraftCms\Cms\Field\ContentBlock;
+use CraftCms\Cms\Field\Matrix;
+
+it('supports keeping missing nested elements by default for matrix fields', function () {
+    expect((new Matrix)->canKeepMissingNestedElements())->toBeTrue();
+});
+
+it('supports keeping missing nested elements by default for addresses fields', function () {
+    expect((new Addresses)->canKeepMissingNestedElements())->toBeTrue();
+});
+
+it('does not support keeping missing nested elements for content block fields', function () {
+    expect((new ContentBlock)->canKeepMissingNestedElements())->toBeFalse();
+});
+
+it('normalizes a flat list of dot-notation handles into the nested __keep__-leaf shape', function () {
+    $importer = EntryImporter::create()->keepMissingNestedElements(['myMatrix', 'some.nested.handle']);
+
+    expect($importer->keepMissingNestedElements)->toBe([
+        'myMatrix' => ['__keep__' => true],
+        'some' => ['nested' => ['handle' => ['__keep__' => true]]],
+    ]);
+});
diff --git a/tests/Unit/Import/ImportLogTest.php b/tests/Unit/Import/ImportLogTest.php
new file mode 100644
index 00000000000..7303e998582
--- /dev/null
+++ b/tests/Unit/Import/ImportLogTest.php
@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Import\ImportLog;
+use CraftCms\Cms\Import\ImportServiceProvider;
+use Illuminate\Support\Facades\Log;
+
+it('registers the import log channel without any app-level config', function () {
+    expect(config('logging.channels.import'))->toMatchArray([
+        'driver' => 'daily',
+        'path' => storage_path('logs/import.log'),
+    ]);
+});
+
+it('does not override a consumer-defined import channel', function () {
+    config()->set('logging.channels.import', ['driver' => 'single', 'path' => 'custom.log']);
+
+    app()->register(ImportServiceProvider::class, force: true);
+
+    expect(config('logging.channels.import'))->toBe(['driver' => 'single', 'path' => 'custom.log']);
+});
+
+it('routes warning messages to the import channel', function () {
+    Log::shouldReceive('channel')
+        ->once()
+        ->with('import')
+        ->andReturnSelf();
+    Log::shouldReceive('warning')
+        ->once()
+        ->with('something went wrong', ['foo' => 'bar']);
+
+    app(ImportLog::class)->warning('something went wrong', ['foo' => 'bar']);
+});
+
+it('routes error messages to the import channel', function () {
+    Log::shouldReceive('channel')
+        ->once()
+        ->with('import')
+        ->andReturnSelf();
+    Log::shouldReceive('error')
+        ->once()
+        ->with('it broke', []);
+
+    app(ImportLog::class)->error('it broke');
+});
+
+it('routes info messages to the import channel', function () {
+    Log::shouldReceive('channel')
+        ->once()
+        ->with('import')
+        ->andReturnSelf();
+    Log::shouldReceive('info')
+        ->once()
+        ->with('fyi', []);
+
+    app(ImportLog::class)->info('fyi');
+});
diff --git a/tests/Unit/Import/JsonDataTypeTest.php b/tests/Unit/Import/JsonDataTypeTest.php
new file mode 100644
index 00000000000..a43ea7396c7
--- /dev/null
+++ b/tests/Unit/Import/JsonDataTypeTest.php
@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Import\DataTypes\Json;
+
+// format()
+
+it('formats a JSON list into rows', function () {
+    $result = Json::format('[{"title": "one"}, {"title": "two"}]');
+
+    expect($result['success'])->toBeTrue()
+        ->and($result['data'])->toBe([['title' => 'one'], ['title' => 'two']]);
+});
+
+it('keeps nested structures intact when formatting', function () {
+    $result = Json::format('[{"blocks": [{"type": "a", "fields": {"text": "x"}}]}]');
+
+    expect($result['data'][0]['blocks'][0])->toBe(['type' => 'a', 'fields' => ['text' => 'x']]);
+});
+
+it('reports malformed JSON instead of throwing', function () {
+    $result = Json::format('[{"title": "unterminated"');
+
+    expect($result['success'])->toBeFalse()
+        ->and($result['error'])->toStartWith('Invalid JSON:');
+});
+
+it('reports malformed JSON when reading headings', function () {
+    $result = Json::getHeadings('[{"title": "unterminated"');
+
+    expect($result['success'])->toBeFalse()
+        ->and($result['error'])->toStartWith('Invalid JSON:');
+});
+
+// getHeadings()
+
+it('returns top-level keys for a flat JSON array', function () {
+    $result = Json::getHeadings('[{"name": "Alice", "age": 30}]');
+
+    $values = array_column($result, 'value');
+    expect($values)->toContain('name')->toContain('age');
+});
+
+it('returns dot-notation keys for nested JSON objects', function () {
+    $result = Json::getHeadings('[{"user": {"name": "Alice", "address": {"city": "NYC"}}}]');
+
+    $values = array_column($result, 'value');
+    expect($values)
+        ->toContain('user')
+        ->toContain('user.name')
+        ->toContain('user.address')
+        ->toContain('user.address.city');
+});
+
+it('traverses array items without appending numeric index to the path', function () {
+    $result = Json::getHeadings('[{"tags": [{"name": "foo"}, {"name": "bar"}]}]');
+
+    $values = array_column($result, 'value');
+    expect($values)->toContain('tags')->toContain('tags.name');
+    expect($values)->not()->toContain('tags.0')->not()->toContain('tags.0.name');
+});
+
+it('deduplicates keys that appear across multiple top-level objects', function () {
+    $result = Json::getHeadings('[{"a": 1}, {"a": 2, "b": 3}]');
+
+    $values = array_column($result, 'value');
+    expect(array_count_values($values)['a'])->toBe(1);
+    expect($values)->toContain('b');
+});
+
+it('returns label and value for each heading', function () {
+    $result = Json::getHeadings('[{"title": "Hello"}]');
+
+    expect($result)->toHaveCount(1);
+    expect($result[0])->toHaveKeys(['label', 'value']);
+    expect($result[0]['label'])->toBe($result[0]['value']);
+});
diff --git a/tests/Unit/Import/XmlDataTypeTest.php b/tests/Unit/Import/XmlDataTypeTest.php
new file mode 100644
index 00000000000..3a3ea87c750
--- /dev/null
+++ b/tests/Unit/Import/XmlDataTypeTest.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+use CraftCms\Cms\Import\DataTypes\Xml;
+
+/** getData() unwraps the root element, so <entries><entry>… becomes a list of entry rows. */
+const XML = <<<'XMLDATA'
+<?xml version="1.0" encoding="UTF-8"?>
+<entries>
+    <entry>
+        <title>first entry</title>
+        <plainText>text one</plainText>
+    </entry>
+    <entry>
+        <title>second entry</title>
+        <plainText>text two</plainText>
+    </entry>
+</entries>
+XMLDATA;
+
+// format()
+
+it('formats XML into rows, unwrapping the root element', function () {
+    $result = Xml::format(XML);
+
+    expect($result['success'])->toBeTrue()
+        ->and($result['data'])->toBe([
+            ['title' => 'first entry', 'plainText' => 'text one'],
+            ['title' => 'second entry', 'plainText' => 'text two'],
+        ]);
+});
+
+it('keeps nested elements as nested arrays', function () {
+    $xml = '<entries>'
+        .'<entry><title>one</title><fields><text>x</text></fields></entry>'
+        .'<entry><title>two</title><fields><text>y</text></fields></entry>'
+        .'</entries>';
+
+    $result = Xml::format($xml);
+
+    expect($result['data'][0]['fields'])->toBe(['text' => 'x']);
+});
+
+// getData() unwraps the root's first key, which is the row list only when there are 2+ rows: with a
+// single <entry> the unwrapped value is that row itself, so the result is one row rather than a
+// list of one. Import::Import() foreaches whatever comes back, so this shape matters.
+it('formats a single-row XML document into one row rather than a list of one', function () {
+    $result = Xml::format('<entries><entry><title>only one</title></entry></entries>');
+
+    expect($result['data'])->toBe(['title' => 'only one'])
+        ->and($result['data'])->not()->toHaveKey(0);
+});
+
+it('reports malformed XML instead of throwing', function () {
+    $result = Xml::format('<entries><entry><title>unterminated</entries>');
+
+    expect($result['success'])->toBeFalse()
+        ->and($result['error'])->toStartWith('Invalid XML:');
+});
+
+// getHeadings()
+
+it('returns dot-notation headings for XML elements', function () {
+    $result = Xml::getHeadings(XML);
+
+    expect(array_column($result, 'value'))->toContain('title', 'plainText');
+});
diff --git a/tests/Unit/Support/ArrTest.php b/tests/Unit/Support/ArrTest.php
index 9fb14ff7a37..5192830bf0e 100644
--- a/tests/Unit/Support/ArrTest.php
+++ b/tests/Unit/Support/ArrTest.php
@@ -217,3 +217,84 @@
     ['a.b.c.d', 'a[b][c][d]'],
     [0, 0],
 ]);
+
+test('undotifyKey', function (string|int $expected, string|int $string) {
+    expect(Arr::undotifyKey($string))->toBe($expected);
+})->with([
+    ['foo[bar]', 'foo.bar'],
+    ['sources[custom:5bb5537d][condition]', 'sources.custom:5bb5537d.condition'],
+    ['foo', 'foo'],
+    ['a[b][c][d]', 'a.b.c.d'],
+    [0, 0],
+]);
+
+test('bracketsToArray', function (array $expected, string $string) {
+    expect(Arr::bracketsToArray($string))->toBe($expected);
+})->with([
+    [['foo', 'bar'], 'foo[bar]'],
+    [['sources', 'custom:5bb5537d', 'condition'], 'sources[custom:5bb5537d][condition]'],
+    [['foo'], 'foo'],
+    [['a', 'b', 'c', 'd'], 'a[b][c][d]'],
+]);
+
+test('uniqueDotifiedKeys', function (array $expected, array $array, string $prepend = '') {
+    expect(Arr::uniqueDotifiedKeys($array, $prepend))->toBe($expected);
+})->with([
+    [['title'], ['title' => 'my title'], ''],
+    [
+        ['title', 'plainText', 'myMatrix', 'myMatrix.et1', 'myMatrix.et1.title', 'myMatrix.et1.text', 'myMatrix.et1.notUsed', 'myMatrix.et2', 'myMatrix.et2.title', 'myMatrix.et2.otherField'],
+        [
+            'title' => 'my title',
+            'plainText' => 'my plain text',
+            'myMatrix' => [
+                'et1' => [
+                    [
+                        'title' => 'my title',
+                        'text' => 'my text',
+                    ],
+                    [
+                        'title' => 'my title2',
+                        'text' => 'my text2',
+                        'notUsed' => 'my not used',
+                    ],
+                ],
+                'et2' => [
+                    [
+                        'title' => 'my title3',
+                        'otherField' => 'my other field',
+                    ],
+                ],
+            ],
+        ],
+        '',
+    ],
+    [
+        ['myPrefix.title', 'myPrefix.plainText', 'myPrefix.myMatrix', 'myPrefix.myMatrix.et1', 'myPrefix.myMatrix.et1.title', 'myPrefix.myMatrix.et1.text', 'myPrefix.myMatrix.et1.notUsed', 'myPrefix.myMatrix.et2', 'myPrefix.myMatrix.et2.title', 'myPrefix.myMatrix.et2.otherField'],
+        [
+            'title' => 'my title',
+            'plainText' => 'my plain text',
+            'myMatrix' => [
+                'et1' => [
+                    [
+                        'title' => 'my title',
+                        'text' => 'my text',
+                    ],
+                    [
+                        'title' => 'my title2',
+                        'text' => 'my text2',
+                        'notUsed' => 'my not used',
+                    ],
+                ],
+                'et2' => [
+                    [
+                        'title' => 'my title3',
+                        'otherField' => 'my other field',
+                    ],
+                ],
+            ],
+        ],
+        'myPrefix',
+    ],
+]);
+
+// TODO: add tests for: bracketsToArray and uniqueDotifiedKeys
diff --git a/vite.config.js b/vite.config.js
index e8a5c4eac37..30a70648efc 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -223,12 +223,13 @@ export default defineConfig(({mode}) => {
       'yii2-adapter/**/*.scss':
         'stylelint --fix --allow-empty-input -c ./yii2-adapter/.stylelintrc.json',
       '!(yii2-adapter)/**/*.scss': 'stylelint --fix --allow-empty-input',
-      '!(yii2-adapter)/**/*.{html,json,css,scss}': 'vp fmt --write',
+      '!(yii2-adapter)/**/*.{html,json,css,scss}': 'vp fmt --write --no-error-on-unmatched-pattern',
       'resources/js/**/*.{ts,vue}': 'vp check --fix',
     },
     fmt: {
       singleQuote: true,
       bracketSpacing: false,
+      tabWidth: 2,
       vueIndentScriptAndStyle: true,
       trailingComma: 'es5',
       printWidth: 80,
@@ -247,6 +248,7 @@ export default defineConfig(({mode}) => {
         'resources/js/wayfinder/*',
         'yii2-adapter/*',
         'tests-playwright/.authentication.json',
+        'tests/Fixtures/Import/*',
       ],
     },
     base: './',