diff --git a/README.md b/README.md
index 3e1d893..ffca9aa 100644
--- a/README.md
+++ b/README.md
@@ -790,11 +790,65 @@ HTML admin. The wire shape is identical regardless of locale —
 only the human-readable strings change.
 
 **The SPA's own chrome strings** ("Add", "Search", "Save and
-continue editing", "Loading…") are still hard-coded English. A
-message-catalog refresh + `config.language` wire field is tracked
-in [#630](https://github.com/MartinCastroAlvarez/django-admin-react/issues/630). Until that lands, non-English-primary shops
-get translated `verbose_name` / `help_text` (via `LocaleMiddleware`)
-but English chrome around them.
+continue editing", "Loading…") flow through the same locale (#630,
+since 1.7.0). Shipped catalogs: English (source-as-key), Spanish,
+Portuguese / pt-BR, French. Adding a new language: drop a JSON file
+under `frontend/packages/ui/src/i18n/`, import it in
+`frontend/packages/ui/src/i18n.ts`, ship.
+
+### Custom widgets (`formfield_overrides` + `registerFieldWidget`)
+
+When your `ModelAdmin` routes a field through a custom widget —
+`formfield_overrides = {MyJSONField: {"widget": MyCustomWidget}}`,
+or a custom `Form` class declaring widgets directly, or a
+third-party widget library — the API surfaces it as
+`widget: "custom"` + `widget_class: "<dotted.Python.Path>"`
+(`django-admin-rest-api` 1.3.0+). The SPA dispatches the render to
+a consumer-registered widget via a small plugin protocol (#625).
+
+Register your widget BEFORE the SPA bundle runs — in your custom
+`change_form_template`, a shared base template, or any `<script>`
+tag that loads ahead of the SPA's bundle:
+
+```html
+<!-- in your Django template -->
+<script>
+  window.darFieldWidgets = window.darFieldWidgets ?? {};
+  window.darFieldWidgets['mypkg.widgets.MarkdownEditor'] = {
+    mount(container, props) {
+      // Read `props.value` for the current value.
+      // Call `props.onChange(next)` when the operator edits.
+      // Render whatever — vanilla JS, jQuery, mini-React, …
+      const textarea = document.createElement('textarea');
+      textarea.value = props.value ?? '';
+      textarea.addEventListener('input', (e) => props.onChange(e.target.value));
+      container.appendChild(textarea);
+      // (Optional) return a cleanup fn called on SPA unmount.
+      return () => textarea.remove();
+    },
+  };
+</script>
+```
+
+The `props` object passed to `mount` has:
+
+| Prop | Type | Description |
+|---|---|---|
+| `value` | `WriteValue` | Current draft value (live — read each access via getter). |
+| `onChange` | `(next) => void` | Call to emit a new value; the SPA re-renders. |
+| `error` | `string[] \| undefined` | Per-field validation errors from the last save attempt. |
+| `widgetClass` | `string` | The dotted class path (handy if a single mount fn handles related widgets). |
+
+When no registration matches the `widget_class` on the wire, the
+SPA falls back to a default text input + a small amber note
+(`Custom widget <class> is not registered; using the default text
+input.`). The operator can still complete the form; the gap is
+explicit and recoverable, not a silent break.
+
+If you'd rather skip the consumer-side widget for a model and keep
+it on the legacy `/admin/`, the
+[experience-toggle strip](#experience-toggle-strip-optional) +
+`LEGACY_ADMIN_URL_PREFIX` give consumers a one-click hop back.
 
 ---
 
diff --git a/frontend/packages/api/src/contract.ts b/frontend/packages/api/src/contract.ts
index 8618e1d..73cb9f9 100644
--- a/frontend/packages/api/src/contract.ts
+++ b/frontend/packages/api/src/contract.ts
@@ -42,8 +42,20 @@ export type FieldType =
  * `shuttle_v` come from `filter_horizontal` / `filter_vertical` (#627) —
  * the SPA renders Django's two-pane "available / chosen" widget for the
  * M2M field, with horizontal or vertical orientation respectively.
+ * `custom` (api 1.3.0+) marks a field whose bound form widget class lives
+ * outside `django.*` — `formfield_overrides` / `formfield_for_dbfield` /
+ * a third-party widget. The SPA dispatches to a consumer-registered
+ * widget via `registerFieldWidget(widget_class, …)` (#625); falls back
+ * to the default control + an "open in legacy admin" note when no
+ * registration matches.
  */
-export type WidgetHint = 'radio' | 'raw_id' | 'password' | 'shuttle_h' | 'shuttle_v';
+export type WidgetHint =
+  | 'radio'
+  | 'raw_id'
+  | 'password'
+  | 'shuttle_h'
+  | 'shuttle_v'
+  | 'custom';
 
 export interface Permissions {
   view: boolean;
@@ -446,6 +458,14 @@ export interface FieldDescriptor {
    * has redacted `value` (it ships `null`).
    */
   widget?: WidgetHint;
+  /**
+   * Dotted Python path of the bound form widget's class (api 1.3.0+),
+   * present only when `widget` is `"custom"`. The SPA dispatches to a
+   * consumer-registered widget via `registerFieldWidget(widget_class,
+   * …)`; falls back to the default control + an "open in legacy admin"
+   * note when no registration matches (#625).
+   */
+  widget_class?: string;
 }
 
 export interface FieldsetDescriptor {
diff --git a/frontend/packages/form/src/CustomWidgetMount.tsx b/frontend/packages/form/src/CustomWidgetMount.tsx
new file mode 100644
index 0000000..db55919
--- /dev/null
+++ b/frontend/packages/form/src/CustomWidgetMount.tsx
@@ -0,0 +1,85 @@
+// CustomWidgetMount — React adapter for the consumer-supplied
+// vanilla mount-fn plugin protocol (#625). Bridges the SPA's
+// controlled-form world (value + onChange every render) to the
+// imperative DOM world of a `function mount(container, props)`
+// contract.
+//
+// Why this layer:
+// - The SPA's React is bundled into the wheel; exposing it on a
+//   global so consumer React components can use it is fragile
+//   across rebuilds.
+// - A vanilla mount-fn contract keeps the consumer free to use
+//   any framework (jQuery, Stimulus, mini-React, vanilla DOM).
+// - The mount fn is called once on mount with the initial props;
+//   value changes invoked from inside the widget (via
+//   `props.onChange`) flow through React's normal re-render path.
+//   Successive mounts after a re-render don't fire — React's
+//   useEffect with `[]` deps mounts exactly once.
+
+import { useEffect, useRef } from 'react';
+
+import type { WriteValue } from '@dar/data';
+import type { CustomWidgetSpec } from '@dar/ui';
+
+interface CustomWidgetMountProps {
+  spec: CustomWidgetSpec;
+  widgetClass: string;
+  value: WriteValue;
+  onChange: (next: WriteValue) => void;
+  error: string[] | undefined;
+}
+
+export function CustomWidgetMount({
+  spec,
+  widgetClass,
+  value,
+  onChange,
+  error,
+}: CustomWidgetMountProps): JSX.Element {
+  const ref = useRef<HTMLDivElement>(null);
+  // Latest props the widget needs to see at re-render time. The
+  // mount fn captured the FIRST onChange; subsequent React renders
+  // would close over a stale onChange unless we forward via a
+  // ref. The widget reads through this ref each time it emits.
+  const latestProps = useRef({ value, onChange, error, widgetClass });
+  latestProps.current = { value, onChange, error, widgetClass };
+
+  useEffect(() => {
+    if (!ref.current) return undefined;
+    const container = ref.current;
+    // Mount with stable proxies — the widget's mount fn captures
+    // these once; the wrappers read through latestProps.current so
+    // every emit and every value-read sees the freshest binding.
+    const cleanup = spec.mount(container, {
+      get value() {
+        return latestProps.current.value;
+      },
+      onChange: (next) => latestProps.current.onChange(next),
+      get error() {
+        return latestProps.current.error;
+      },
+      get widgetClass() {
+        return latestProps.current.widgetClass;
+      },
+    });
+    return () => {
+      if (typeof cleanup === 'function') cleanup();
+      // Defensive: if the widget didn't fully tear down its DOM,
+      // wipe the container so a re-mount starts clean. The mount
+      // fn is the source of truth; this is a last-resort backstop.
+      container.innerHTML = '';
+    };
+    // Intentional: mount-once contract. Re-mounting on every value
+    // change would defeat the imperative widget's own state
+    // management. The latestProps ref pattern (above) forwards
+    // value / onChange / error to the widget without re-mounting.
+  }, [spec]);
+
+  return (
+    <div
+      ref={ref}
+      data-custom-widget-class={widgetClass}
+      className="rounded border border-gray-300 p-2"
+    />
+  );
+}
diff --git a/frontend/packages/form/src/FieldInput.tsx b/frontend/packages/form/src/FieldInput.tsx
index fff1ecb..0845162 100644
--- a/frontend/packages/form/src/FieldInput.tsx
+++ b/frontend/packages/form/src/FieldInput.tsx
@@ -13,9 +13,10 @@ import { Plus } from 'lucide-react';
 
 import type { FieldDescriptor, FieldValue, WriteValue } from '@dar/data';
 import { FieldValueView } from '@dar/details';
-import { Checkbox } from '@dar/ui';
+import { Checkbox, lookupFieldWidget, t } from '@dar/ui';
 
 import { AutocompleteInput } from './AutocompleteInput';
+import { CustomWidgetMount } from './CustomWidgetMount';
 import { RelatedAddModal } from './RelatedAddModal';
 import { ShuttleSelect } from './ShuttleSelect';
 
@@ -70,6 +71,49 @@ export function FieldInput({ name, field, value, error, onChange }: FieldInputPr
         className={base}
       />
     );
+  } else if (field.widget === 'custom' && field.widget_class) {
+    // Custom widget plugin protocol (#625). The API (1.3.0+) marks
+    // any field whose bound form widget class lives outside
+    // ``django.*`` with ``widget: "custom"`` + the widget's dotted
+    // Python path. Consumers register a vanilla mount fn for that
+    // class via ``registerFieldWidget(class, {mount})``; the SPA's
+    // ``CustomWidgetMount`` adapter bridges React → the mount fn's
+    // imperative DOM world.
+    //
+    // If no registration matches, render the default control for the
+    // field's type with a small inline note so the operator isn't
+    // stuck — they can still type something into the field; the
+    // consumer's missing widget is a deployment gap, not a hard
+    // block. The note links to the legacy admin which has the real
+    // widget rendered server-side.
+    const widgetSpec = lookupFieldWidget(field.widget_class);
+    if (widgetSpec) {
+      control = (
+        <CustomWidgetMount
+          spec={widgetSpec}
+          widgetClass={field.widget_class}
+          value={value}
+          onChange={onChange}
+          error={error}
+        />
+      );
+    } else {
+      control = (
+        <div className="space-y-1">
+          <input
+            id={id}
+            type="text"
+            value={value == null ? '' : String(value)}
+            onChange={(e) => onChange(e.target.value)}
+            className={base}
+          />
+          <p className="text-xs text-amber-700">
+            {t('Custom widget')} <code className="font-mono">{field.widget_class}</code>{' '}
+            {t('is not registered; using the default text input.')}
+          </p>
+        </div>
+      );
+    }
   } else if (field.widget === 'raw_id' && field.type === 'foreignkey') {
     // raw_id_fields (#626 / #251). The consumer explicitly OPTED OUT
     // of an autocomplete picker — typically because the FK target has
diff --git a/frontend/packages/ui/src/custom-widget.test.ts b/frontend/packages/ui/src/custom-widget.test.ts
new file mode 100644
index 0000000..87bb313
--- /dev/null
+++ b/frontend/packages/ui/src/custom-widget.test.ts
@@ -0,0 +1,67 @@
+// Lock the custom widget plugin protocol (#625):
+//
+//   1. `registerFieldWidget(class, spec)` puts a spec in the
+//      module-level registry.
+//   2. `lookupFieldWidget(class)` returns the registered spec or
+//      undefined when nothing matches.
+//   3. The window.darFieldWidgets global is a fallback path for
+//      consumers shipping a vanilla <script> registration (no
+//      build).
+//   4. Module-level registry wins over the window global on
+//      conflict (explicit `registerFieldWidget` is more intentional
+//      than a global assignment).
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  _resetFieldWidgetRegistryForTests,
+  lookupFieldWidget,
+  registerFieldWidget,
+} from './custom-widget';
+
+afterEach(() => {
+  _resetFieldWidgetRegistryForTests();
+  delete window.darFieldWidgets;
+});
+
+describe('registerFieldWidget / lookupFieldWidget', () => {
+  it('round-trips a registered widget by class name', () => {
+    const spec = { mount: vi.fn() };
+    registerFieldWidget('mypkg.MarkdownEditor', spec);
+    expect(lookupFieldWidget('mypkg.MarkdownEditor')).toBe(spec);
+  });
+
+  it('returns undefined when no registration matches', () => {
+    expect(lookupFieldWidget('not.registered')).toBeUndefined();
+  });
+
+  it('latest registration wins (re-register overwrites)', () => {
+    const first = { mount: vi.fn() };
+    const second = { mount: vi.fn() };
+    registerFieldWidget('x', first);
+    registerFieldWidget('x', second);
+    expect(lookupFieldWidget('x')).toBe(second);
+  });
+});
+
+describe('window.darFieldWidgets fallback (no-build path)', () => {
+  it('reads from window.darFieldWidgets when the module registry is empty', () => {
+    const spec = { mount: vi.fn() };
+    window.darFieldWidgets = { 'global.Widget': spec };
+    expect(lookupFieldWidget('global.Widget')).toBe(spec);
+  });
+
+  it('module registry wins over the window global on conflict', () => {
+    const moduleSpec = { mount: vi.fn() };
+    const globalSpec = { mount: vi.fn() };
+    window.darFieldWidgets = { 'shared.Widget': globalSpec };
+    registerFieldWidget('shared.Widget', moduleSpec);
+    expect(lookupFieldWidget('shared.Widget')).toBe(moduleSpec);
+  });
+
+  it('is robust when window.darFieldWidgets is undefined', () => {
+    // Simulate a fresh page where no consumer has registered
+    // anything via either path.
+    delete window.darFieldWidgets;
+    expect(lookupFieldWidget('anything')).toBeUndefined();
+  });
+});
diff --git a/frontend/packages/ui/src/custom-widget.ts b/frontend/packages/ui/src/custom-widget.ts
new file mode 100644
index 0000000..d85508b
--- /dev/null
+++ b/frontend/packages/ui/src/custom-widget.ts
@@ -0,0 +1,117 @@
+// Custom widget plugin protocol (#625).
+//
+// Lets a consumer ship a small JS module that renders their own
+// editor for a Django ``formfield_overrides`` widget the SPA
+// doesn't natively render. The wire-side half (api 1.3.0+) emits
+// ``widget: "custom"`` plus ``widget_class: "<dotted.Python.Path>"``
+// on any field whose bound form widget class lives outside
+// ``django.*`` — this module is the SPA-side dispatcher.
+//
+// Consumer contract:
+//
+//   // Loaded BEFORE the SPA bundle (via a regular `<script>` tag
+//   // in your custom `change_form_template`, or via a shared
+//   // base template that includes both your widget and the SPA):
+//   window.darFieldWidgets = window.darFieldWidgets ?? {};
+//   window.darFieldWidgets['mypkg.widgets.MarkdownEditor'] = {
+//     mount(container, props) {
+//       // Render whatever you want into `container` (vanilla JS,
+//       // jQuery, a mini React, …). Read `props.value` for the
+//       // current value; call `props.onChange(next)` when the
+//       // operator edits; check `props.error` (string[] | undefined)
+//       // for validation errors from the last save attempt.
+//       // Return a cleanup fn that tears down event listeners
+//       // and external resources when the SPA unmounts.
+//     }
+//   };
+//
+// Why vanilla JS, not React: the SPA's React is bundled and tree-
+// shaken — exposing it on a window global is fragile across bundle
+// rebuilds. A vanilla mount-fn contract keeps the consumer's widget
+// framework-agnostic (jQuery, Stimulus, mini-React, vanilla DOM
+// manipulation all work). The SPA wraps the mount fn in a thin
+// React effect that mounts on first paint and cleans up on unmount.
+
+/**
+ * Inlined copy of ``@dar/data``'s ``WriteValue`` type. We can't
+ * import from ``@dar/data`` here because ``@dar/ui`` is the lowest
+ * layer in the workspace and data depends on api / customization
+ * (a dep on ``@dar/data`` from ``@dar/ui`` would invert that
+ * layering). The type is small and stable; the duplication is
+ * deliberate.
+ */
+type WriteValue = string | number | boolean | null | Array<string | number>;
+
+/** Props passed to a custom widget's mount function. */
+export interface CustomWidgetProps {
+  /** The current draft value (whatever the operator has typed into
+   *  the form so far; matches the SPA's WriteValue vocabulary). */
+  value: WriteValue;
+  /** Call to emit a new value as the operator interacts. The SPA
+   *  re-renders the form with the new value; the widget can stay
+   *  controlled (use `value` from the next mount call) or
+   *  uncontrolled (manage its own internal state). */
+  onChange: (next: WriteValue) => void;
+  /** Per-field validation errors from the last save attempt, or
+   *  ``undefined`` if no errors. The widget can render its own
+   *  error UI; the SPA also renders the errors below the widget
+   *  as a fallback so the operator always sees them. */
+  error: string[] | undefined;
+  /** The dotted class path of the widget — useful when a single
+   *  mount fn handles multiple related widgets (color picker for
+   *  hex + rgba, e.g.). */
+  widgetClass: string;
+}
+
+/** A consumer-supplied widget. ``mount`` returns a cleanup fn called
+ *  on unmount. */
+export interface CustomWidgetSpec {
+  mount: (container: HTMLElement, props: CustomWidgetProps) => (() => void) | void;
+}
+
+/** Module-level registry the SPA reads at render time. Synced to
+ *  ``window.darFieldWidgets`` so consumers can populate it via a
+ *  regular ``<script>`` tag that runs before the SPA bundle. */
+const registry: Record<string, CustomWidgetSpec> = {};
+
+declare global {
+  interface Window {
+    darFieldWidgets?: Record<string, CustomWidgetSpec>;
+  }
+}
+
+/**
+ * Register a custom widget. Called either:
+ *   - from consumer code, via ``import { registerFieldWidget }
+ *     from "django-admin-react/widgets"`` (a future thin npm
+ *     publish), OR
+ *   - by assigning to ``window.darFieldWidgets['<class>']``
+ *     directly (the no-build path).
+ *
+ * Calling twice with the same class name overwrites; latest wins.
+ */
+export function registerFieldWidget(widgetClass: string, spec: CustomWidgetSpec): void {
+  registry[widgetClass] = spec;
+}
+
+/**
+ * Look up a registered widget. Returns ``undefined`` when no
+ * registration matches — the SPA's caller falls back to the
+ * default render in that case.
+ *
+ * Reads from both the module-level registry (registered via
+ * ``registerFieldWidget``) AND the ``window.darFieldWidgets``
+ * global (registered via the no-build path). The module wins on
+ * conflict — explicit ``registerFieldWidget`` calls are usually
+ * later + more intentional.
+ */
+export function lookupFieldWidget(widgetClass: string): CustomWidgetSpec | undefined {
+  return registry[widgetClass] ?? window.darFieldWidgets?.[widgetClass];
+}
+
+/** Test-only: wipe the module-level registry between cases. */
+export function _resetFieldWidgetRegistryForTests(): void {
+  for (const key of Object.keys(registry)) {
+    delete registry[key];
+  }
+}
diff --git a/frontend/packages/ui/src/i18n/es.json b/frontend/packages/ui/src/i18n/es.json
index 25735ea..41c351a 100644
--- a/frontend/packages/ui/src/i18n/es.json
+++ b/frontend/packages/ui/src/i18n/es.json
@@ -40,6 +40,8 @@
   "Dismiss": "Descartar",
   "Look up related object in a new tab": "Buscar objeto relacionado en pestaña nueva",
   "Lookup ↗": "Buscar ↗",
+  "Custom widget": "Widget personalizado",
+  "is not registered; using the default text input.": "no está registrado; se usa la entrada de texto predeterminada.",
   "Action failed.": "La acción falló.",
   "The action could not be completed.": "No se pudo completar la acción.",
   "Couldn't load the list": "No se pudo cargar la lista",
diff --git a/frontend/packages/ui/src/i18n/fr.json b/frontend/packages/ui/src/i18n/fr.json
index f7cf7ef..dfd50ca 100644
--- a/frontend/packages/ui/src/i18n/fr.json
+++ b/frontend/packages/ui/src/i18n/fr.json
@@ -40,6 +40,8 @@
   "Dismiss": "Ignorer",
   "Look up related object in a new tab": "Rechercher l'objet associé dans un nouvel onglet",
   "Lookup ↗": "Rechercher ↗",
+  "Custom widget": "Widget personnalisé",
+  "is not registered; using the default text input.": "n'est pas enregistré ; utilisation de la saisie texte par défaut.",
   "Action failed.": "L'action a échoué.",
   "The action could not be completed.": "L'action n'a pas pu être effectuée.",
   "Couldn't load the list": "Impossible de charger la liste",
diff --git a/frontend/packages/ui/src/i18n/pt.json b/frontend/packages/ui/src/i18n/pt.json
index f5d8729..97583b8 100644
--- a/frontend/packages/ui/src/i18n/pt.json
+++ b/frontend/packages/ui/src/i18n/pt.json
@@ -40,6 +40,8 @@
   "Dismiss": "Dispensar",
   "Look up related object in a new tab": "Buscar objeto relacionado em nova aba",
   "Lookup ↗": "Buscar ↗",
+  "Custom widget": "Widget personalizado",
+  "is not registered; using the default text input.": "não está registrado; usando a entrada de texto padrão.",
   "Action failed.": "A ação falhou.",
   "The action could not be completed.": "A ação não pôde ser concluída.",
   "Couldn't load the list": "Não foi possível carregar a lista",
diff --git a/frontend/packages/ui/src/index.ts b/frontend/packages/ui/src/index.ts
index 47bd3a6..f916d5d 100644
--- a/frontend/packages/ui/src/index.ts
+++ b/frontend/packages/ui/src/index.ts
@@ -58,3 +58,9 @@ export type { RefreshButtonProps } from './RefreshButton';
 // The active catalog is hydrated once at boot from
 // `<meta name="dar-language">`; see `loadCatalog` in main.tsx.
 export { t, loadCatalog } from './i18n';
+
+// Custom widget plugin protocol (#625). Lets a consumer register a
+// mount fn for the SPA to call when it encounters a custom widget
+// (formfield_overrides / formfield_for_dbfield / custom Form).
+export { registerFieldWidget, lookupFieldWidget } from './custom-widget';
+export type { CustomWidgetProps, CustomWidgetSpec } from './custom-widget';
diff --git a/poetry.lock b/poetry.lock
index f49a030..ca95638 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -556,14 +556,14 @@ jsonschema = ">=4.0,<5.0"
 
 [[package]]
 name = "django-admin-rest-api"
-version = "1.2.0"
+version = "1.3.0"
 description = "A JSON REST API for the Django admin — same permissions, same ModelAdmin, no new features. Powers django-admin-react and django-admin-mcp."
 optional = false
 python-versions = "<4.0,>=3.10"
 groups = ["main"]
 files = [
-    {file = "django_admin_rest_api-1.2.0-py3-none-any.whl", hash = "sha256:cf818b0a8e58c0e0ef5967ad363ce0e111a17ca24b7b2e9f2a785d1608fbf989"},
-    {file = "django_admin_rest_api-1.2.0.tar.gz", hash = "sha256:5f0c3585f8c97f362e0a86a0818310335172572903ce02f5bcbbfbf8d1514004"},
+    {file = "django_admin_rest_api-1.3.0-py3-none-any.whl", hash = "sha256:fb425b73833e6667f495c6620df903ec0670149ecc14cbe661a14d7af4e2b5b6"},
+    {file = "django_admin_rest_api-1.3.0.tar.gz", hash = "sha256:07f6c08de14d8aeee62685840da2841dc2d803c3cc2c14694cd42d24ea36fb47"},
 ]
 
 [package.dependencies]
@@ -2082,4 +2082,4 @@ zstd = ["backports-zstd (>=1.0.0) ; python_version < \"3.14\""]
 [metadata]
 lock-version = "2.1"
 python-versions = "^3.10"
-content-hash = "bd71a89536a790a3f530d5602c28a2c1b91572c7d22b4c8d864dfcde8b814147"
+content-hash = "7b927f9507fbf97f4a8278bef8472a40e534bc9f6babfdf5958cca5a158ba8d4"
diff --git a/pyproject.toml b/pyproject.toml
index 3e5ac73..fb49211 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-admin-react"
-version = "1.7.0"
+version = "1.8.0"
 description = "A drop-in React single-page admin for Django, driven entirely by ModelAdmin."
 authors = ["django-admin-react contributors"]
 license = "MIT"
@@ -52,7 +52,7 @@ django = ">=4.2,<7.0"
 # React SPA super-layer over `django-admin-rest-api`. The package's URLs
 # are included by `django_admin_react.urls`, and consumers add
 # `"django_admin_rest_api"` to `INSTALLED_APPS` alongside this package.
-django-admin-rest-api = "^1.2.0"
+django-admin-rest-api = "^1.3.0"
 # `django-admin-mcp-api` — MCP-protocol adapter over the same REST API
 # so agents reach the SAME `ModelAdmin`-driven surface. Wire-protocol-only
 # layer; adds NO new functionality, permissions, or validation.