diff --git a/.gitignore b/.gitignore
index 875fb89..e8d44e6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -60,3 +60,6 @@ site/
 
 # direnv
 .envrc
+
+# Brainstorming / design specs (local only, not for version control)
+docs/superpowers/
diff --git a/docs/configuration.md b/docs/configuration.md
index 015d9de..205828d 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -49,21 +49,6 @@ NetBox installs:  interface name = "5"   (raw bay position)
 Plugin renames:   interface name = "et-0/0/5"
 ```
 
-### `{module_path}` (NetBox ≥ 4.9)
-
-When a module type's interface template uses `{module_path}`, NetBox resolves
-the full module bay path at install time.  For a transceiver in "X2 Port 1"
-inside a line card in "Slot 1", `{module_path}` resolves to `1/1`.  The plugin
-signal still fires, but may compute the same name the interface already has —
-so it becomes a no-op.
-
-For directly-attached pluggables (single bay depth), `{module_path}` resolves to
-just the bay position, behaving identically to `{module}`.
-
-!!! tip
-    New module types should use `{module_path}` for best NetBox compatibility.
-    Legacy module types using `{module}` continue to work — the plugin handles the rename.
-
 ### The `potentially-deprecated` Tag
 
 After installing a module, if the plugin's signal fires but finds the interface
@@ -71,8 +56,7 @@ is already correctly named, it automatically tags the rule `potentially-deprecat
 This means:
 
 - For **new installs**: the rule may no longer be needed (NetBox generates the name)
-- For **retroactive applies**: the rule is still useful for modules installed before
-  `{module_path}` support was added, or before the rule existed
+- For **retroactive applies**: the rule is still useful for modules installed before the rule existed
 
 The tag is informational only — the rule remains active.
 
diff --git a/netbox_interface_name_rules/engine.py b/netbox_interface_name_rules/engine.py
index c1c2ecb..64ae903 100644
--- a/netbox_interface_name_rules/engine.py
+++ b/netbox_interface_name_rules/engine.py
@@ -561,8 +561,7 @@ def has_applicable_interfaces(rule) -> bool:
     Calls find_interfaces_for_rule(limit=1) to determine if any currently installed
     interface would receive a new name.  Returns False when:
       - no matching modules/interfaces are installed, OR
-      - all matching interfaces are already correctly named (e.g. NetBox resolved
-        {module_path} at install time, making the rule a no-op for existing interfaces).
+      - all matching interfaces are already correctly named.
 
     This is more expensive than a plain EXISTS query but ensures the Applicable
     column in the Apply Rules list accurately reflects "would something change?"
diff --git a/netbox_interface_name_rules/models.py b/netbox_interface_name_rules/models.py
index 314b165..1d14891 100644
--- a/netbox_interface_name_rules/models.py
+++ b/netbox_interface_name_rules/models.py
@@ -283,3 +283,45 @@ def __str__(self):
         device = f" on {self.device_type.model}" if self.device_type else ""
         platform = f" [{self.platform.name}]" if self.platform else ""
         return f"{module}{parent}{device}{platform} → {self.name_template}"
+
+    csv_headers = [
+        "module_type",
+        "module_type_pattern",
+        "module_type_is_regex",
+        "parent_module_type",
+        "device_type",
+        "platform",
+        "name_template",
+        "channel_count",
+        "channel_start",
+        "description",
+        "enabled",
+        "applies_to_device_interfaces",
+    ]
+
+    def to_csv(self):
+        """Return a tuple of field values for CSV export (matches csv_headers order)."""
+        return (
+            self.module_type.model if self.module_type else "",
+            self.module_type_pattern,
+            self.module_type_is_regex,
+            self.parent_module_type.model if self.parent_module_type else "",
+            self.device_type.model if self.device_type else "",
+            self.platform.name if self.platform else "",
+            self.name_template,
+            self.channel_count,
+            self.channel_start,
+            self.description,
+            self.enabled,
+            self.applies_to_device_interfaces,
+        )
+
+    def to_yaml(self):
+        """Return a YAML document for this rule (used by NetBox's built-in Export)."""
+        import yaml
+
+        entry = {}
+        for header, value in zip(self.csv_headers, self.to_csv()):
+            if (value != "" and value is not None) or header in {"name_template"}:
+                entry[header] = value
+        return yaml.dump([entry], default_flow_style=False, allow_unicode=True, sort_keys=False)
diff --git a/netbox_interface_name_rules/tables.py b/netbox_interface_name_rules/tables.py
index 5d38970..89e3ca0 100644
--- a/netbox_interface_name_rules/tables.py
+++ b/netbox_interface_name_rules/tables.py
@@ -96,7 +96,7 @@ class InterfaceNameRuleTable(NetBoxTable):
     applies_to_device_interfaces = columns.BooleanColumn(verbose_name="Device Ifaces")
     name_template = tables.Column(verbose_name="Name Template")
     channel_count = tables.Column(verbose_name="Channels")
-    channel_start = tables.Column(verbose_name="Ch. Start")
+    channel_start = tables.Column(verbose_name="Channel Start")
     description = tables.Column(verbose_name="Description", linkify=False)
     actions = columns.ActionsColumn(
         actions=("edit", "delete"),
diff --git a/netbox_interface_name_rules/templates/netbox_interface_name_rules/buttons/export_yaml_only.html b/netbox_interface_name_rules/templates/netbox_interface_name_rules/buttons/export_yaml_only.html
new file mode 100644
index 0000000..d1ccffc
--- /dev/null
+++ b/netbox_interface_name_rules/templates/netbox_interface_name_rules/buttons/export_yaml_only.html
@@ -0,0 +1,33 @@
+{# SPDX-License-Identifier: Apache-2.0 #}
+{# Copyright (C) 2025 Marcin Zieba <marcinpsk@gmail.com> #}
+{% load i18n %}
+<div class="dropdown">
+  <button type="button" class="btn btn-purple dropdown-toggle" data-bs-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
+    <i class="mdi mdi-download" aria-hidden="true"></i> {{ label }}
+  </button>
+  <ul class="dropdown-menu dropdown-menu-end">
+    <li><a class="dropdown-item" href="?{% if url_params %}{{ url_params }}&{% endif %}export">{% trans "All Data" %} ({{ data_format }})</a></li>
+    {% if export_templates %}
+      <li>
+        <hr class="dropdown-divider">
+      </li>
+      {% for et in export_templates %}
+        <li>
+          <a class="dropdown-item" href="?{% if url_params %}{{ url_params }}&{% endif %}export={{ et.name|urlencode }}"
+            {% if et.description %} title="{{ et.description }}"{% endif %}
+          >
+            {{ et.name }}
+          </a>
+        </li>
+      {% endfor %}
+    {% endif %}
+    {% if perms.extras.add_exporttemplate %}
+      <li>
+        <hr class="dropdown-divider">
+      </li>
+      <li>
+        <a class="dropdown-item" href="{% url 'extras:exporttemplate_add' %}?object_types={{ object_type.pk }}">{% trans "Add export template" %}...</a>
+      </li>
+    {% endif %}
+  </ul>
+</div>
diff --git a/netbox_interface_name_rules/templates/netbox_interface_name_rules/interfacenamerule_list.html b/netbox_interface_name_rules/templates/netbox_interface_name_rules/interfacenamerule_list.html
index 9ca0f97..217b0d1 100644
--- a/netbox_interface_name_rules/templates/netbox_interface_name_rules/interfacenamerule_list.html
+++ b/netbox_interface_name_rules/templates/netbox_interface_name_rules/interfacenamerule_list.html
@@ -78,23 +78,6 @@ <h6 class="mt-3">Examples</h6>
                     (device-level rule, pattern <code>Ethernet\d+/\d+</code>)</li>
             </ul>
 
-            {% if supports_module_path %}
-            <div class="alert alert-success mt-3 mb-0">
-                <i class="mdi mdi-check-circle me-1"></i>
-                <strong><code>{module_path}</code> supported:</strong>
-                Platform naming rules (e.g., <code>et-0/0/{bay_position}</code>)
-                may be replaceable by using <code>{module_path}</code> in module type interface templates directly.
-                Converter offset and breakout rules are still needed.
-            </div>
-            {% else %}
-            <div class="alert alert-warning mt-3 mb-0">
-                <i class="mdi mdi-information-outline me-1"></i>
-                <strong><code>{module_path}</code> not available:</strong>
-                Platform naming rules
-                (e.g., Juniper <code>et-0/0/{bay_position}</code>) are required for correct interface naming.
-                Upgrade NetBox to get native <code>{module_path}</code> support.
-            </div>
-            {% endif %}
         </div>
     </div>
     <script>
diff --git a/netbox_interface_name_rules/tests/test_misc.py b/netbox_interface_name_rules/tests/test_misc.py
index 8f4986f..c3c6271 100644
--- a/netbox_interface_name_rules/tests/test_misc.py
+++ b/netbox_interface_name_rules/tests/test_misc.py
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
 # Copyright (C) 2025 Marcin Zieba <marcinpsk@gmail.com>
-"""Tests for utils, jobs, model properties, and API serializer edge-cases."""
+"""Tests for jobs, model properties, and API serializer edge-cases."""
 
 from unittest.mock import MagicMock, patch
 
@@ -9,21 +9,6 @@
 from django.test import TestCase
 
 from netbox_interface_name_rules.models import InterfaceNameRule
-from netbox_interface_name_rules.utils import supports_module_path
-
-# ---------------------------------------------------------------------------
-# utils.py
-# ---------------------------------------------------------------------------
-
-
-class SupportModulePathTest(TestCase):
-    """Test the supports_module_path feature-detection helper."""
-
-    def test_returns_bool(self):
-        """supports_module_path() returns a boolean (True or False)."""
-        result = supports_module_path()
-        self.assertIsInstance(result, bool)
-
 
 # ---------------------------------------------------------------------------
 # jobs.py
@@ -742,31 +727,77 @@ def test_job_run_exception_reraises_and_logs(self):
 
 
 # ---------------------------------------------------------------------------
-# utils.py — supports_module_path ImportError path (lines 16-17)
+# Model csv_headers / to_csv() — regression: KeyError 'Ch' on CSV import
 # ---------------------------------------------------------------------------
 
 
-class UtilsModulePathFalseTest(TestCase):
-    """Test supports_module_path() returns False when MODULE_PATH_TOKEN is missing."""
+class ModelCSVExportTest(TestCase):
+    """Test that InterfaceNameRule exposes csv_headers and to_csv() for round-trip CSV."""
 
-    def test_returns_false_when_token_missing(self):
-        """supports_module_path() returns False when MODULE_PATH_TOKEN is absent.
-
-        Temporarily removes the attribute from dcim.constants (if present) to
-        trigger the ImportError branch in supports_module_path, then restores it.
-        Asserts False regardless of whether the attribute existed beforehand.
-        """
-        import dcim.constants as dc
-
-        from netbox_interface_name_rules.utils import supports_module_path
-
-        had_attr = hasattr(dc, "MODULE_PATH_TOKEN")
-        original = getattr(dc, "MODULE_PATH_TOKEN", None)
-        try:
-            if had_attr:
-                delattr(dc, "MODULE_PATH_TOKEN")
-            result = supports_module_path()
-            self.assertFalse(result)
-        finally:
-            if had_attr:
-                dc.MODULE_PATH_TOKEN = original
+    @classmethod
+    def setUpTestData(cls):
+        manufacturer = Manufacturer.objects.create(name="CSVMfg", slug="csvmfg")
+        cls.module_type = ModuleType.objects.create(manufacturer=manufacturer, model="CSV-SFP", part_number="CSV-SFP")
+        cls.rule = InterfaceNameRule.objects.create(
+            module_type=cls.module_type,
+            name_template="et-0/0/{bay_position}",
+            channel_count=4,
+            channel_start=0,
+            description="CSV test rule",
+        )
+        cls.regex_rule = InterfaceNameRule.objects.create(
+            module_type_is_regex=True,
+            module_type_pattern="QSFP-.*",
+            name_template="{base}/{channel}",
+            channel_count=4,
+            channel_start=1,
+            description="Regex CSV rule",
+        )
+
+    def test_csv_headers_attribute_exists(self):
+        """InterfaceNameRule.csv_headers class attribute must exist."""
+        self.assertTrue(hasattr(InterfaceNameRule, "csv_headers"), "InterfaceNameRule.csv_headers missing")
+
+    def test_csv_headers_is_list_or_tuple(self):
+        """csv_headers must be a list or tuple of strings."""
+        self.assertIsInstance(InterfaceNameRule.csv_headers, (list, tuple))
+
+    def test_csv_headers_matches_import_form_fields(self):
+        """csv_headers must exactly match InterfaceNameRuleImportForm.Meta.fields."""
+        from netbox_interface_name_rules.forms import InterfaceNameRuleImportForm
+
+        form_fields = list(InterfaceNameRuleImportForm.Meta.fields)
+        self.assertEqual(list(InterfaceNameRule.csv_headers), form_fields)
+
+    def test_to_csv_method_exists(self):
+        """InterfaceNameRule instances must have a to_csv() method."""
+        self.assertTrue(callable(getattr(self.rule, "to_csv", None)), "InterfaceNameRule.to_csv() missing")
+
+    def test_to_csv_returns_sequence(self):
+        """to_csv() must return a tuple or list."""
+        result = self.rule.to_csv()
+        self.assertIsInstance(result, (tuple, list))
+
+    def test_to_csv_length_matches_csv_headers(self):
+        """to_csv() must return exactly len(csv_headers) values."""
+        result = self.rule.to_csv()
+        self.assertEqual(len(result), len(InterfaceNameRule.csv_headers))
+
+    def test_to_csv_exact_rule_module_type(self):
+        """to_csv() for exact rule must include the module_type model string."""
+        result = self.rule.to_csv()
+        values = list(result)
+        idx = list(InterfaceNameRule.csv_headers).index("module_type")
+        self.assertEqual(values[idx], "CSV-SFP")
+
+    def test_to_csv_regex_rule_no_module_type(self):
+        """to_csv() for regex rule must have empty string for module_type."""
+        result = self.regex_rule.to_csv()
+        values = list(result)
+        idx = list(InterfaceNameRule.csv_headers).index("module_type")
+        self.assertEqual(values[idx], "")
+
+    def test_to_csv_no_dots_in_headers(self):
+        """csv_headers must not contain dots (regression guard for KeyError 'Ch' bug)."""
+        for header in InterfaceNameRule.csv_headers:
+            self.assertNotIn(".", header, f"csv_headers entry '{header}' contains a dot — would break import")
diff --git a/netbox_interface_name_rules/tests/test_views.py b/netbox_interface_name_rules/tests/test_views.py
index a92d40a..f9339f1 100644
--- a/netbox_interface_name_rules/tests/test_views.py
+++ b/netbox_interface_name_rules/tests/test_views.py
@@ -402,6 +402,55 @@ def test_post_no_permission_raises_403(self):
         self.assertEqual(response.status_code, 403)
 
 
+class RuleTestViewAddOnlyPermissionTest(ViewTestBase2):
+    """Test RuleTestView behaviour for users with add but not view permission."""
+
+    def _url(self):
+        return reverse("plugins:netbox_interface_name_rules:interfacenamerule_test")
+
+    def _create_add_only_user(self):
+        from users.models import ObjectPermission
+
+        user = User.objects.create_user(username="add_only_tester", password=TEST_PASSWORD)
+        # object_types targets ContentType on older NetBox and ObjectType on newer NetBox
+        obj_type_model = ObjectPermission._meta.get_field("object_types").related_model
+        ct = obj_type_model.objects.get_for_model(InterfaceNameRule)
+        obj_perm = ObjectPermission.objects.create(name="add_only_rule", actions=["add"])
+        obj_perm.object_types.add(ct)
+        obj_perm.users.add(user)
+        return user
+
+    def test_get_with_rule_id_add_only_shows_blank_form_with_warning(self):
+        """GET with ?rule_id= when user has add but not view permission returns blank form."""
+        user = self._create_add_only_user()
+        self.client.force_login(user)
+        response = self.client.get(self._url() + f"?rule_id={self.rule.pk}")
+        self.assertEqual(response.status_code, 200)
+        form = response.context["form"]
+        self.assertFalse(form.initial, "Form should have no initial data for add-only user")
+        self.assertIsNone(response.context.get("loaded_rule"))
+        from django.contrib.messages import get_messages
+
+        msgs = [str(m) for m in get_messages(response.wsgi_request)]
+        self.assertTrue(any("permission" in m.lower() for m in msgs))
+
+    def test_save_rule_add_only_skips_duplicate_check(self):
+        """POST save_rule with add-only permission skips duplicate detection, redirects to add."""
+        user = self._create_add_only_user()
+        self.client.force_login(user)
+        add_url = reverse("plugins:netbox_interface_name_rules:interfacenamerule_add")
+        data = {
+            "name_template": "ge-0/0/{bay_position}",
+            "channel_count": "0",
+            "channel_start": "0",
+            "module_type": str(self.module_type.pk),
+            "action": "save_rule",
+        }
+        response = self.client.post(self._url(), data)
+        self.assertEqual(response.status_code, 302)
+        self.assertIn(add_url, response["Location"])
+
+
 class RuleApplyDetailViewGetPermissionTest(ViewTestBase2):
     """Test RuleApplyDetailView.get() permission check for unprivileged users."""
 
@@ -660,3 +709,152 @@ def test_post_background_success_shows_success_message(self):
         success_msgs = [m for m in msgs if m.level == SUCCESS]
         self.assertTrue(success_msgs, "Expected a success-level message but none found")
         self.assertTrue(any("42" in str(m) for m in success_msgs))
+
+
+# ---------------------------------------------------------------------------
+# BulkImportCSVTest — regression: KeyError 'Ch' on CSV import round-trip
+# ---------------------------------------------------------------------------
+
+
+class BulkImportCSVTest(ViewTestBase):
+    """CSV import round-trip tests; guards against the KeyError 'Ch' regression."""
+
+    def _csv_from_rule(self, rule):
+        """Build a one-row CSV string from a rule's csv_headers and to_csv()."""
+        import csv
+        import io
+
+        buf = io.StringIO()
+        writer = csv.writer(buf)
+        writer.writerow(InterfaceNameRule.csv_headers)
+        writer.writerow(rule.to_csv())
+        return buf.getvalue()
+
+    def test_csv_import_does_not_raise_key_error(self):
+        """POST to import with a properly exported CSV must not produce a KeyError.
+
+        This is the regression test for the 'Ch' KeyError: when using csv_headers
+        and to_csv() the column names are plain field names with no dots.
+        """
+        self.client.force_login(self.superuser)
+        csv_data = self._csv_from_rule(self.rule)
+        url = reverse("plugins:netbox_interface_name_rules:interfacenamerule_bulk_import")
+        # If a KeyError is raised the view returns 500; assert it doesn't.
+        try:
+            response = self.client.post(url, {"data": csv_data, "format": "csv", "csv_delimiter": "auto"})
+        except KeyError as exc:
+            self.fail(f"CSV import raised KeyError: {exc!r}")
+        self.assertNotEqual(response.status_code, 500, "CSV import returned a 500 error")
+
+    def test_csv_round_trip_creates_rule(self):
+        """CSV exported from a fresh rule can be imported to create a new rule."""
+        import csv
+        import io
+        import uuid
+
+        self.client.force_login(self.superuser)
+        # Build a unique ModuleType so the imported row doesn't collide with fixtures.
+        unique_model = f"ROUND-TRIP-{uuid.uuid4().hex[:8]}"
+        mt = ModuleType.objects.create(
+            manufacturer=self.module_type.manufacturer,
+            model=unique_model,
+            part_number=unique_model,
+        )
+        buf = io.StringIO()
+        writer = csv.writer(buf)
+        writer.writerow(InterfaceNameRule.csv_headers)
+        writer.writerow(
+            [
+                mt.model,  # module_type
+                "",  # module_type_pattern
+                False,  # module_type_is_regex
+                "",  # parent_module_type
+                "",  # device_type
+                "",  # platform
+                "et-0/0/{bay_position}",  # name_template
+                0,  # channel_count
+                0,  # channel_start
+                "round-trip test",  # description
+                True,  # enabled
+                False,  # applies_to_device_interfaces
+            ]
+        )
+        csv_data = buf.getvalue()
+
+        url = reverse("plugins:netbox_interface_name_rules:interfacenamerule_bulk_import")
+        before_count = InterfaceNameRule.objects.count()
+        response = self.client.post(url, {"data": csv_data, "format": "csv", "csv_delimiter": "auto"})
+        # A successful import redirects (302); failure re-renders the form (200).
+        self.assertEqual(response.status_code, 302, f"Import did not redirect; status={response.status_code}")
+        after_count = InterfaceNameRule.objects.count()
+        self.assertGreater(after_count, before_count, "No new rule was created after CSV import")
+
+
+# ---------------------------------------------------------------------------
+# YAMLExportTest — YAML export via NetBox's built-in Export dropdown
+# ---------------------------------------------------------------------------
+
+
+class YAMLExportTest(ViewTestBase):
+    """Tests for YAML export via the list view's ?export query parameter."""
+
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+        cls.LIST_URL = reverse("plugins:netbox_interface_name_rules:interfacenamerule_list")
+
+    def test_yaml_export_unauthenticated_responds(self):
+        """Unauthenticated export must not serve content to anonymous users."""
+        self.client.logout()
+        response = self.client.get(self.LIST_URL, {"export": ""})
+        self.assertIn(response.status_code, [301, 302, 403])
+
+    def test_yaml_export_all_returns_200(self):
+        """Authenticated GET ?export= must return 200."""
+        self.client.force_login(self.superuser)
+        response = self.client.get(self.LIST_URL, {"export": ""})
+        self.assertEqual(response.status_code, 200)
+
+    def test_yaml_export_content_type(self):
+        """Response Content-Type must contain 'yaml'."""
+        self.client.force_login(self.superuser)
+        response = self.client.get(self.LIST_URL, {"export": ""})
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("yaml", response["Content-Type"].lower())
+
+    def test_yaml_export_content_disposition(self):
+        """Response must include a Content-Disposition attachment header."""
+        self.client.force_login(self.superuser)
+        response = self.client.get(self.LIST_URL, {"export": ""})
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("attachment", response.get("Content-Disposition", "").lower())
+
+    def test_yaml_export_all_contains_rules(self):
+        """Exported YAML must be parseable, contain all rules, in PK order."""
+        import yaml
+
+        self.client.force_login(self.superuser)
+        response = self.client.get(self.LIST_URL, {"export": ""})
+        self.assertEqual(response.status_code, 200)
+        data = yaml.safe_load(response.content)
+        self.assertIsInstance(data, list)
+        expected_templates = list(InterfaceNameRule.objects.order_by("pk").values_list("name_template", flat=True))
+        exported_templates = [entry["name_template"] for entry in data]
+        self.assertEqual(exported_templates, expected_templates)
+
+    def test_yaml_export_structure(self):
+        """Each exported YAML entry must contain key fields and no blank optional keys."""
+        import yaml
+
+        self.client.force_login(self.superuser)
+        response = self.client.get(self.LIST_URL, {"export": ""})
+        self.assertEqual(response.status_code, 200)
+        rules = yaml.safe_load(response.content)
+        self.assertIsInstance(rules, list)
+        optional_headers = set(InterfaceNameRule.csv_headers) - {"name_template"}
+        for entry in rules:
+            self.assertIsInstance(entry, dict)
+            self.assertIn("name_template", entry)
+            for key, value in entry.items():
+                if key in optional_headers:
+                    self.assertNotIn(value, ["", None], f"Key {key!r} has blank value in exported rule")
diff --git a/netbox_interface_name_rules/utils.py b/netbox_interface_name_rules/utils.py
deleted file mode 100644
index b7bfdc9..0000000
--- a/netbox_interface_name_rules/utils.py
+++ /dev/null
@@ -1,17 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# Copyright (C) 2025 Marcin Zieba <marcinpsk@gmail.com>
-"""Feature-detection utilities for the interface name rules plugin."""
-
-
-def supports_module_path():
-    """Check if the running NetBox supports the {module_path} template token.
-
-    Detects by checking for MODULE_PATH_TOKEN in dcim.constants rather than
-    comparing version strings — works with patched/pre-release builds too.
-    """
-    try:
-        from dcim.constants import MODULE_PATH_TOKEN  # noqa: F401
-
-        return True
-    except ImportError:
-        return False
diff --git a/netbox_interface_name_rules/views.py b/netbox_interface_name_rules/views.py
index 4237a01..5a39892 100644
--- a/netbox_interface_name_rules/views.py
+++ b/netbox_interface_name_rules/views.py
@@ -4,16 +4,17 @@
 import logging
 import re
 
+import yaml
 from django.conf import settings
 from django.contrib import messages
 from django.core.exceptions import PermissionDenied
 from django.http import JsonResponse
-from django.shortcuts import get_object_or_404, redirect, render
+from django.shortcuts import redirect, render
 from django.urls import reverse
 from django.utils.http import url_has_allowed_host_and_scheme
-from django.views import View
 from netbox.views import generic
-from utilities.views import ConditionalLoginRequiredMixin, register_model_view
+from netbox.views.generic.base import BaseMultiObjectView
+from utilities.views import register_model_view
 
 from .filters import InterfaceNameRuleFilterSet
 from .forms import InterfaceNameRuleFilterForm, InterfaceNameRuleForm, InterfaceNameRuleImportForm, RuleTestForm
@@ -44,6 +45,19 @@ class RulePreview:
     channel_start: int
 
 
+try:
+    from netbox.object_actions import AddObject, BulkDelete, BulkEdit, BulkExport, BulkImport, BulkRename
+
+    class _YAMLOnlyExport(BulkExport):
+        """Export action that only offers YAML (no CSV "Current View" option)."""
+
+        template_name = "netbox_interface_name_rules/buttons/export_yaml_only.html"
+
+    _LIST_VIEW_ACTIONS: tuple = (AddObject, BulkImport, _YAMLOnlyExport, BulkEdit, BulkRename, BulkDelete)
+except ImportError:
+    _LIST_VIEW_ACTIONS = None
+
+
 class InterfaceNameRuleListView(generic.ObjectListView):
     """List view for InterfaceNameRule."""
 
@@ -52,14 +66,21 @@ class InterfaceNameRuleListView(generic.ObjectListView):
     filterset = InterfaceNameRuleFilterSet
     filterset_form = InterfaceNameRuleFilterForm
     template_name = "netbox_interface_name_rules/interfacenamerule_list.html"
+    if _LIST_VIEW_ACTIONS is not None:
+        actions = _LIST_VIEW_ACTIONS
 
-    def get_extra_context(self, request):
-        """Inject feature-detection flags into the list template context."""
-        from .utils import supports_module_path
-
-        return {
-            "supports_module_path": supports_module_path(),
-        }
+    def export_yaml(self):
+        """Export all rules as a single YAML list (overrides NetBox's per-object concatenation)."""
+        data = []
+        for rule in self.queryset.order_by("pk").select_related(
+            "module_type", "parent_module_type", "device_type", "platform"
+        ):
+            entry = {}
+            for header, value in zip(InterfaceNameRule.csv_headers, rule.to_csv()):
+                if (value != "" and value is not None) or header in {"name_template"}:
+                    entry[header] = value
+            data.append(entry)
+        return yaml.dump(data, default_flow_style=False, allow_unicode=True, sort_keys=False)
 
 
 class InterfaceNameRuleCreateView(generic.ObjectEditView):
@@ -109,39 +130,46 @@ class InterfaceNameRuleChangeLogView(generic.ObjectChangeLogView):
     queryset = InterfaceNameRule.objects.all()
 
 
-class InterfaceNameRuleDuplicateView(ConditionalLoginRequiredMixin, View):
+class InterfaceNameRuleDuplicateView(generic.ObjectView):
     """Redirect to the add view pre-populated with a clone of the given rule."""
 
-    def get(self, request, pk):
-        """Redirect to the add view pre-populated with fields cloned from rule pk."""
+    queryset = InterfaceNameRule.objects.all()
+
+    def get(self, request, **kwargs):
+        """Redirect to the add view pre-populated with fields cloned from the given rule."""
         from utilities.querydict import prepare_cloned_fields
 
-        rule = get_object_or_404(InterfaceNameRule, pk=pk)
+        rule = self.get_object(**kwargs)
         params = prepare_cloned_fields(rule)
         url = reverse("plugins:netbox_interface_name_rules:interfacenamerule_add")
         return redirect(f"{url}?{params.urlencode()}")
 
 
-class RuleTestView(ConditionalLoginRequiredMixin, View):
+class RuleTestView(BaseMultiObjectView):
     """Live-preview a name template with user-supplied variable values and optional DB lookup."""
 
+    queryset = InterfaceNameRule.objects.all()
     template_name = "netbox_interface_name_rules/rule_test.html"
 
-    def _check_permission(self, request):
-        if not request.user.has_perm("netbox_interface_name_rules.add_interfacenamerule"):
-            raise PermissionDenied
+    def get_required_permission(self):
+        """Return the permission required to access the rule test tool."""
+        return "netbox_interface_name_rules.add_interfacenamerule"
 
     def get(self, request):
         """Render the test form, pre-populated from rule_id query param if given."""
-        self._check_permission(request)
         initial = {}
         loaded_rule = None
         rule_id = request.GET.get("rule_id")
-        if rule_id:
+        can_view = request.user.has_perm("netbox_interface_name_rules.view_interfacenamerule")
+        if rule_id and not can_view:
+            messages.warning(request, "You do not have permission to load an existing rule.")
+        if rule_id and can_view:
             try:
-                loaded_rule = InterfaceNameRule.objects.select_related(
-                    "module_type", "parent_module_type", "device_type", "platform"
-                ).get(pk=int(rule_id))
+                loaded_rule = (
+                    InterfaceNameRule.objects.restrict(request.user, "view")
+                    .select_related("module_type", "parent_module_type", "device_type", "platform")
+                    .get(pk=int(rule_id))
+                )
                 initial = {
                     "name_template": loaded_rule.name_template,
                     "module_type_is_regex": loaded_rule.module_type_is_regex,
@@ -159,7 +187,6 @@ def get(self, request):
 
     def post(self, request):
         """Evaluate the submitted template and return a preview or redirect to save."""
-        self._check_permission(request)
         form = RuleTestForm(request.POST)
         preview_results = None
         db_preview = None
@@ -188,6 +215,22 @@ def post(self, request):
             },
         )
 
+    def _find_existing_rule(self, cd, user=None):
+        """Return the first existing rule matching the form data, or None."""
+        module_type_is_regex = cd.get("module_type_is_regex", False)
+        qs = InterfaceNameRule.objects.restrict(user, "view") if user else InterfaceNameRule.objects.all()
+        if module_type_is_regex:
+            qs = qs.filter(module_type_is_regex=True, module_type_pattern=cd.get("module_type_pattern", ""))
+        else:
+            qs = qs.filter(module_type_is_regex=False, module_type=cd.get("module_type"))
+        for field in ("parent_module_type", "device_type", "platform"):
+            val = cd.get(field)
+            if val:
+                qs = qs.filter(**{field: val})
+            else:
+                qs = qs.filter(**{f"{field}__isnull": True})
+        return qs.first()
+
     def _handle_save_rule(self, request, cd):
         """Find an existing matching rule or redirect to the add-rule form with pre-filled params."""
         from urllib.parse import urlencode
@@ -197,26 +240,20 @@ def _handle_save_rule(self, request, cd):
         channel_start = cd.get("channel_start") or 0
         module_type_is_regex = cd.get("module_type_is_regex", False)
         module_type = cd.get("module_type")
-        module_type_pattern = cd.get("module_type_pattern", "")
 
-        qs = InterfaceNameRule.objects.all()
-        if module_type_is_regex:
-            qs = qs.filter(module_type_is_regex=True, module_type_pattern=module_type_pattern)
-        else:
-            qs = qs.filter(module_type_is_regex=False, module_type=module_type)
-        for field in ("parent_module_type", "device_type", "platform"):
-            val = cd.get(field)
-            if val:
-                qs = qs.filter(**{field: val})
-            else:
-                qs = qs.filter(**{f"{field}__isnull": True})
-        existing = qs.first()
-        if existing:
-            messages.info(
-                request,
-                f"A matching rule already exists (#{existing.pk}). Redirecting to edit it.",
-            )
-            return redirect(reverse("plugins:netbox_interface_name_rules:interfacenamerule_edit", args=[existing.pk]))
+        # Skip duplicate detection when the user lacks view permission — we cannot
+        # query existing rules without it, so add-only users always land on the
+        # create form (potentially allowing duplicates).
+        if request.user.has_perm("netbox_interface_name_rules.view_interfacenamerule"):
+            existing = self._find_existing_rule(cd, request.user)
+            if existing:
+                messages.info(
+                    request,
+                    f"A matching rule already exists (#{existing.pk}). Redirecting to edit it.",
+                )
+                return redirect(
+                    reverse("plugins:netbox_interface_name_rules:interfacenamerule_edit", args=[existing.pk])
+                )
 
         params = {
             "name_template": name_template,
@@ -225,7 +262,7 @@ def _handle_save_rule(self, request, cd):
             "channel_start": channel_start,
         }
         if module_type_is_regex:
-            params["module_type_pattern"] = module_type_pattern
+            params["module_type_pattern"] = cd.get("module_type_pattern", "")
         elif module_type:
             params["module_type"] = module_type.pk
         for field in ("parent_module_type", "device_type", "platform"):
@@ -311,37 +348,42 @@ def _fetch_db_preview(self, cd):
             return [], 0, f"Unexpected error: {type(exc).__name__}"
 
 
-class RuleApplyListView(ConditionalLoginRequiredMixin, View):
+class RuleApplyListView(BaseMultiObjectView):
     """Display all rules with buttons to preview/apply each one."""
 
+    queryset = InterfaceNameRule.objects.all()
     template_name = "netbox_interface_name_rules/rule_apply.html"
 
+    def get_required_permission(self):
+        """Return the permission required to access the apply-rules page."""
+        return "netbox_interface_name_rules.view_interfacenamerule"
+
     def get(self, request):
         """Render the list of all rules with apply/preview buttons."""
-        rules = InterfaceNameRule.objects.select_related(
-            "module_type", "parent_module_type", "device_type", "platform"
-        ).order_by("pk")
+        rules = self.queryset.select_related("module_type", "parent_module_type", "device_type", "platform").order_by(
+            "pk"
+        )
         return render(request, self.template_name, {"rules": rules, "batch_limit": APPLY_BATCH_LIMIT})
 
 
-class RuleApplicableView(ConditionalLoginRequiredMixin, View):
+class RuleApplicableView(generic.ObjectView):
     """Return JSON indicating whether a rule would rename at least one interface.
 
     Called on demand from the Apply Rules page — NOT at page load — to avoid
     expensive full-scan queries blocking the initial render.
     """
 
-    def get(self, request, pk):
+    queryset = InterfaceNameRule.objects.all()
+
+    def get(self, request, **kwargs):
         """Return JSON {"applicable": bool} for the rule identified by pk."""
         from .engine import has_applicable_interfaces
 
-        rule = get_object_or_404(InterfaceNameRule, pk=pk)
+        rule = self.get_object(**kwargs)
         try:
             applicable = has_applicable_interfaces(rule)
         except Exception as exc:
-            logger.exception("applicability scan failed for rule %s", pk)
-            # Only expose the exception class name to avoid leaking internals
-            # (SQL, file paths, etc.).  Full details are in the server log.
+            logger.exception("applicability scan failed for rule %s", kwargs.get("pk"))
             return JsonResponse(
                 {"applicable": None, "error": f"scan failed: {type(exc).__name__}"},
                 status=500,
@@ -349,21 +391,18 @@ def get(self, request, pk):
         return JsonResponse({"applicable": applicable})
 
 
-class RuleApplyDetailView(ConditionalLoginRequiredMixin, View):
+class RuleApplyDetailView(generic.ObjectView):
     """Show a preview of changes for a specific rule and allow applying them."""
 
+    queryset = InterfaceNameRule.objects.all()
     template_name = "netbox_interface_name_rules/rule_apply_detail.html"
+    additional_permissions = ["dcim.change_interface"]
 
-    def _check_permission(self, request):
-        if not request.user.has_perm("dcim.change_interface"):
-            raise PermissionDenied
-
-    def get(self, request, pk):
+    def get(self, request, **kwargs):
         """Render a preview of all interfaces that would be renamed by this rule."""
         from .engine import find_interfaces_for_rule
 
-        self._check_permission(request)
-        rule = get_object_or_404(InterfaceNameRule, pk=pk)
+        rule = self.get_object(**kwargs)
         try:
             preview, total_checked = find_interfaces_for_rule(rule, limit=APPLY_BATCH_LIMIT)
         except (re.error, ValueError) as exc:
@@ -387,13 +426,11 @@ def get(self, request, pk):
             },
         )
 
-    def post(self, request, pk):
+    def post(self, request, **kwargs):
         """Apply the rule (foreground batch or background job) and redirect back."""
         from .engine import apply_rule_to_existing
 
-        self._check_permission(request)
-
-        rule = get_object_or_404(InterfaceNameRule, pk=pk)
+        rule = self.get_object(**kwargs)
         action = request.POST.get("action", "apply")
 
         if action == "background":